@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/init-CRbjI7p1.js

@@ -0,0 +1,3494 @@
+import { a as __toESM, t as __commonJSMin } from "./rolldown-runtime-OvD0k9op.js";
+import "./libsodium-wrappers-UH0LaOUE.js";
+import { t as Bip32Account$1 } from "./seam-cardano-CATqBEyK.js";
+import { _ as CardanoRewardAccount, u as toContractAddress } from "./util-BaLzwa32.js";
+import { s as Timestamp } from "./time.vo-DkYYGYp6.js";
+import { t as BigNumber } from "./bignum.vo-B0rK_PQ1.js";
+import { n as Ok, t as Err } from "./asyncoption-Cw07zPH7.js";
+import { t as TokenId } from "./token-id.vo-ClsroxHO.js";
+import { r as LOVELACE_TOKEN_ID } from "./const-C84qHkjp.js";
+import { n as getAdaTokenTickerByNetwork, t as cardanoNetworkMagicToNetworkType } from "./cardano-network-id-to-network-type-CrZfUcyP.js";
+import { a as isNotFoundError, n as ProviderError$1, o as toProviderError, r as ProviderFailure$1 } from "./error-BCp9NkPi.js";
+import { a as BlockfrostToCardanoSDK, c as buildUrl, i as BlockfrostNetworkInfoProvider, n as BlockfrostUtxoProvider, o as BlockfrostProvider, r as BlockfrostTxProvider, s as HttpClient, t as BlockfrostTxSubmitProvider } from "./blockfrost-tx-submit-provider-DPTrapz-.js";
+import { AddressType, KeyRole } from "@laceio/cardano/key-management";
+import { Hash28ByteBase16 } from "@laceio/cardano/crypto";
+import { Asset, Cardano, ProviderError, ProviderFailure, Serialization } from "@laceio/cardano/core";
+import { isNotNil } from "@laceio/cardano/util";
+import { EMPTY, Observable, catchError, defer, distinct, expand, forkJoin, from, map, mergeMap, of, reduce, toArray } from "rxjs";
+import omit from "lodash/omit.js";
+import memoize from "lodash/memoize.js";
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-asset-provider.ts
+var BlockfrostAssetProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	async getAsset({ assetId, extraData }) {
+		try {
+			const response = await this.request(`assets/${assetId.toString()}`);
+			const name = Cardano.AssetId.getAssetName(assetId);
+			const policyId = Cardano.PolicyId(response.policy_id);
+			const quantity = BigInt(response.quantity);
+			return {
+				assetId,
+				fingerprint: Cardano.AssetFingerprint(response.fingerprint),
+				name,
+				nftMetadata: extraData?.nftMetadata ? this.mapNftMetadata(response) : null,
+				policyId,
+				quantity,
+				supply: quantity,
+				tokenMetadata: extraData?.tokenMetadata ? this.mapTokenMetadata(assetId, response) : null
+			};
+		} catch (error) {
+			this.logger.error("getAsset failed", assetId, extraData);
+			throw toProviderError(error);
+		}
+	}
+	mapNftMetadata(asset) {
+		const image = this.metadatumToString(asset.onchain_metadata?.image || asset.metadata?.logo);
+		const name = asset.onchain_metadata?.name || asset.metadata?.name;
+		if (!image || !name) return null;
+		try {
+			return {
+				description: this.metadatumToString(asset.onchain_metadata?.description || asset.metadata?.description),
+				files: Array.isArray(asset.onchain_metadata?.files) ? asset.onchain_metadata.files.map((file) => {
+					const mediaType = file.mediaType;
+					const fileName = file.name;
+					const source = this.metadatumToString(file.src);
+					if (!source || !mediaType) return null;
+					try {
+						return {
+							mediaType: Asset.MediaType(mediaType),
+							name: fileName,
+							otherProperties: this.mapFileMetadataOtherProperties(file),
+							src: Asset.Uri(source)
+						};
+					} catch (error) {
+						this.logger.warn("Failed to parse onchain_metadata file", file, error);
+						return null;
+					}
+				}).filter(isNotNil) : void 0,
+				image: Asset.Uri(image),
+				mediaType: asset.onchain_metadata?.mediaType ? Asset.ImageMediaType(asset.onchain_metadata.mediaType) : void 0,
+				name,
+				otherProperties: this.mapNftMetadataOtherProperties(asset.onchain_metadata),
+				version: this.mapNftMetadataVersion(asset.onchain_metadata)
+			};
+		} catch (error) {
+			this.logger.warn("Failed to parse nft metadata", asset, error);
+			return null;
+		}
+	}
+	asString = (metadatum) => typeof metadatum === "string" ? metadatum : void 0;
+	metadatumToString(metadatum) {
+		let stringMetadatum;
+		if (Array.isArray(metadatum)) stringMetadatum = metadatum.map((metadata) => this.asString(metadata)).filter(isNotNil).join("");
+		else stringMetadatum = this.asString(metadatum);
+		return stringMetadatum;
+	}
+	objToMetadatum(object) {
+		if (typeof object === "string") return object;
+		if (typeof object === "number") return BigInt(object);
+		if (typeof object === "object") {
+			if (object === null) return "";
+			if (Array.isArray(object)) return object.map((item) => this.objToMetadatum(item));
+			return new Map(Object.entries(object).map(([key, value]) => [key, this.objToMetadatum(value)]));
+		}
+		return "";
+	}
+	mapNftMetadataVersion(metadata) {
+		return typeof metadata?.version === "string" ? metadata.version : "1.0";
+	}
+	mapFileMetadataOtherProperties(metadata) {
+		return this.mapOtherProperties(metadata, [
+			"name",
+			"mediaType",
+			"src"
+		]);
+	}
+	mapNftMetadataOtherProperties(metadata) {
+		return this.mapOtherProperties(metadata, [
+			"name",
+			"image",
+			"description",
+			"mediaType",
+			"files",
+			"version"
+		]);
+	}
+	mapOtherProperties(metadata, mainProperties) {
+		if (!metadata) return;
+		const otherProperties = Object.entries(omit(metadata, mainProperties));
+		if (otherProperties.length === 0) return;
+		return new Map(otherProperties.map(([key, value]) => [key, this.objToMetadatum(value)]));
+	}
+	mapTokenMetadata(assetId, asset) {
+		return {
+			assetId,
+			decimals: asset.metadata?.decimals || void 0,
+			desc: this.metadatumToString(asset.metadata?.description || asset.onchain_metadata?.description),
+			icon: this.metadatumToString(asset.metadata?.logo || asset.onchain_metadata?.image),
+			name: asset.metadata?.name || asset.onchain_metadata?.name,
+			ticker: asset.metadata?.ticker || void 0,
+			url: asset.metadata?.url || void 0,
+			version: "1.0"
+		};
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-address-discovery.ts
+/**
+* How far we search for stake keys before concluding there are no more stake credentials.
+*/
+const STAKE_KEY_GAP = 5;
+/**
+* How far we search for payment addresses under a single stake key
+* before concluding that no more addresses exist (or that they are “franken”).
+*/
+const PAYMENT_CREDENTIAL_GAP = 100;
+/**
+* Safety cap for thorough discovery. The thorough predicate continues past
+* the gap when the Blockfrost-returned address set still has unmatched
+* entries; this bound ensures the loop cannot run forever when an unmatched
+* entry is structurally undiscoverable (true "franken" cases).
+*/
+const HARD_UPPER_BOUND = 1e4;
+/**
+* Fetch size for Blockfrost addresses per page.
+*/
+const BLOCKFROST_PAGE_SIZE = 100;
+/**
+* Derive the reward account (stake address) at a given stakeIndex.
+*/
+const deriveRewardAccount = async (account, stakeIndex) => {
+	return CardanoRewardAccount((await account.deriveAddress({
+		type: AddressType.External,
+		index: 0
+	}, stakeIndex)).rewardAccount);
+};
+/**
+* Derive a payment address at a given (payment) index + address type (internal/external).
+*/
+const derivePaymentAddress = async (account, paymentIndex, stakeIndex, isInternal) => {
+	const type = isInternal ? AddressType.Internal : AddressType.External;
+	return account.deriveAddress({
+		type,
+		index: paymentIndex
+	}, stakeIndex);
+};
+const compareAddresses = (a, b) => {
+	const indexDiff = a.index - b.index;
+	if (indexDiff !== 0) return indexDiff;
+	if (a.stakeKeyDerivationPath && b.stakeKeyDerivationPath) return a.stakeKeyDerivationPath.index - b.stakeKeyDerivationPath.index;
+	return 0;
+};
+/**
+* Example BlockfrostAddressDiscovery class that:
+*   - Paginates all addresses from each reward account
+*   - Derives addresses sequentially and checks if they match
+*   - Uses a gap-based approach for both stake keys AND payment addresses
+*   - Logs leftover addresses as unknown
+*/
+var BlockfrostAddressDiscovery = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* @returns Observable that emits all discovered addresses one by one. Completes on first error.
+	*/
+	discover(manager, options = {}) {
+		const isThorough = options.thorough ?? false;
+		this.logger.debug(`Discovering addresses using Blockfrost (thorough=${isThorough})...`);
+		return forkJoin({
+			firstAddress: from(manager.deriveAddress({
+				index: 0,
+				type: AddressType.External
+			}, 0)),
+			discovered: this.#discoverAddresses(manager, isThorough).pipe(toArray())
+		}).pipe(mergeMap(({ firstAddress, discovered }) => from([firstAddress, ...discovered])), distinct(({ address }) => address), map(Ok), catchError((error) => of(Err(error instanceof ProviderError$1 ? error : new ProviderError$1(ProviderFailure$1.Unknown, error)))));
+	}
+	/**
+	* Main discovery logic:
+	*   1. Stake key gap: we keep deriving stake keys until we have
+	*      STAKE_KEY_GAP consecutive stake keys that yield zero discovered addresses.
+	*   2. Payment credential gap: for each stake key, we stop deriving
+	*      payment addresses once we have PAYMENT_CREDENTIAL_GAP consecutive misses.
+	*      In thorough mode, termination additionally requires the Blockfrost
+	*      address set to be drained (bounded by HARD_UPPER_BOUND).
+	*/
+	#discoverAddresses(account, thorough) {
+		return new Observable((subscriber) => {
+			let isUnsubscribed = false;
+			(async () => {
+				let stakeIndex = 0;
+				let stakeGapCount = 0;
+				try {
+					while (stakeGapCount < STAKE_KEY_GAP) {
+						if (isUnsubscribed) break;
+						this.logger.debug(`Deriving reward account for stake index ${stakeIndex}...`);
+						const rewardAccount = await deriveRewardAccount(account, stakeIndex);
+						this.logger.debug(`Fetching addresses for stake credential ${rewardAccount}...`);
+						const allAddressesForStake = await this.#fetchAllAddressesForAccount(rewardAccount);
+						if (allAddressesForStake.length === 0) {
+							stakeGapCount++;
+							stakeIndex++;
+							continue;
+						}
+						stakeGapCount = 0;
+						const { discovered, unknown } = await this.#discoverAddressesForStakeKey(account, stakeIndex, allAddressesForStake, thorough);
+						for (const address of discovered.sort(compareAddresses)) subscriber.next(address);
+						if (unknown.length > 0) this.logger.warn(`The following addresses under stakeIndex ${stakeIndex} were not matched:`, unknown);
+						++stakeIndex;
+					}
+					subscriber.complete();
+				} catch (error) {
+					subscriber.error(error);
+				}
+			})();
+			return () => {
+				isUnsubscribed = true;
+			};
+		});
+	}
+	/**
+	* Discover addresses under a single stake key.
+	*
+	* Standard mode (thorough=false): stop once we hit PAYMENT_CREDENTIAL_GAP
+	* consecutive misses. Matches the BIP-44 gap-limit convention.
+	*
+	* Thorough mode (thorough=true): also require the Blockfrost address set to
+	* be drained before stopping, so high-index entries past the gap can still
+	* be discovered. Bounded by HARD_UPPER_BOUND to guarantee termination when
+	* an entry is structurally undiscoverable.
+	*
+	* @returns Array of discovered (matched) addresses + leftover “unknown/franken” addresses
+	*/
+	async #discoverAddressesForStakeKey(account, stakeIndex, allAddressesForStake, thorough) {
+		const discovered = [];
+		const uniqueAddressesForStake = new Set(allAddressesForStake);
+		let gapCount = 0;
+		let paymentIndex = 0;
+		while (true) {
+			const hasHitGap = gapCount >= PAYMENT_CREDENTIAL_GAP;
+			if (thorough ? hasHitGap && uniqueAddressesForStake.size === 0 || paymentIndex >= HARD_UPPER_BOUND : hasHitGap) {
+				this.logger.debug(`Stopping payment discovery for stakeIndex ${stakeIndex} at paymentIndex ${paymentIndex} (gap=${gapCount}, remaining=${uniqueAddressesForStake.size}, thorough=${thorough}).`);
+				break;
+			}
+			const externalAddr = await derivePaymentAddress(account, paymentIndex, stakeIndex, false);
+			const hasExternalInSet = uniqueAddressesForStake.has(externalAddr.address);
+			const internalAddr = await derivePaymentAddress(account, paymentIndex, stakeIndex, true);
+			const hasInternalInSet = uniqueAddressesForStake.has(internalAddr.address);
+			if (hasExternalInSet) {
+				discovered.push({
+					...externalAddr,
+					stakeKeyDerivationPath: {
+						index: stakeIndex,
+						role: KeyRole.Stake
+					}
+				});
+				uniqueAddressesForStake.delete(externalAddr.address);
+			}
+			if (hasInternalInSet) {
+				discovered.push({
+					...internalAddr,
+					stakeKeyDerivationPath: {
+						index: stakeIndex,
+						role: KeyRole.Stake
+					}
+				});
+				uniqueAddressesForStake.delete(internalAddr.address);
+			}
+			if (!hasExternalInSet && !hasInternalInSet) gapCount++;
+			else gapCount = 0;
+			++paymentIndex;
+		}
+		return {
+			discovered,
+			unknown: [...uniqueAddressesForStake]
+		};
+	}
+	/**
+	* Fetch all addresses associated with a reward account from Blockfrost,
+	* handling pagination until the response has fewer than BLOCKFROST_PAGE_SIZE items.
+	*/
+	async #fetchAllAddressesForAccount(rewardAccount) {
+		const allAddresses = [];
+		let page = 1;
+		this.logger.debug(`Fetching addresses for stake ${rewardAccount} (paginated)...`);
+		while (true) try {
+			const response = await this.request(`accounts/${rewardAccount}/addresses?count=${BLOCKFROST_PAGE_SIZE}&page=${page}`);
+			if (!response || response.length === 0) break;
+			for (const entry of response) allAddresses.push(entry.address);
+			if (response.length < BLOCKFROST_PAGE_SIZE) break;
+			++page;
+		} catch (error) {
+			if (isNotFoundError(error)) {
+				this.logger.debug(`No addresses found for stake ${rewardAccount}. 404 from Blockfrost.`);
+				break;
+			}
+			this.logger.error(`Error fetching addresses for stake ${rewardAccount}:`, error);
+			throw error;
+		}
+		this.logger.debug(`Fetched ${allAddresses.length} addresses for stake ${rewardAccount}`);
+		return allAddresses;
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-tokens-provider.ts
+const amountToRawToken = (amount) => ({
+	available: BigNumber(BigInt(amount.quantity)),
+	pending: BigNumber(0n),
+	tokenId: TokenId(amount.unit)
+});
+var BlockfrostTokensProvider = class extends BlockfrostProvider {
+	getTokens(props) {
+		return from(this.request(`addresses/${props.address}`).then(({ amount }) => Ok(amount.map(amountToRawToken))).catch((error) => {
+			if (isNotFoundError(error)) return Ok([]);
+			return Err(error);
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-activity-provider.ts
+/**
+* Provider responsible for fetching transaction history and details.
+*/
+var BlockfrostActivityProvider = class extends BlockfrostProvider {
+	#txProvider;
+	constructor(client, logger, txProvider = new BlockfrostTxProvider(client, logger)) {
+		super(client, logger);
+		this.#txProvider = txProvider;
+	}
+	/**
+	* Fetches the transaction history for a Cardano address.
+	*
+	* @param address - Cardano payment address to fetch transaction history for
+	* @param numberOfItems - How many history items should be fetched (order: newer → older)
+	* @param startAtBlock - At which block (inclusive) should it start
+	* @param startAtIndex - At which index (inclusive) should it start
+	* @returns Observable with Result containing the history items or an error
+	*/
+	getAddressTransactionHistory({ address, numberOfItems, startAtBlock, startAtIndex, endAtBlock, endAtIndex, order = "desc" }) {
+		const fromIndexParameter = startAtIndex !== void 0 ? `:${startAtIndex}` : "";
+		const toIndexParameter = endAtIndex !== void 0 ? `:${endAtIndex}` : "";
+		const optionalFromParameter = startAtBlock !== void 0 ? `&to=${startAtBlock}${fromIndexParameter}` : "";
+		const optionalToParameter = endAtBlock !== void 0 ? `&from=${endAtBlock}${toIndexParameter}` : "";
+		return from(this.request(`addresses/${address}/transactions?count=${numberOfItems}&order=${order}${optionalFromParameter}${optionalToParameter}`)).pipe(map((addressTxHistory) => Ok(addressTxHistory.map((item) => ({
+			txId: Cardano.TransactionId(item.tx_hash),
+			txIndex: Cardano.TxIndex(item.tx_index),
+			blockNumber: Cardano.BlockNo(item.block_height),
+			blockTime: Timestamp(item.block_time * 1e3)
+		})))), catchError((error) => {
+			if (isNotFoundError(error)) return of(Ok([]));
+			return of(Err(error));
+		}));
+	}
+	/**
+	* Fetches transaction details, cbor and utxos to build a Cardano.HydratedTx
+	* which is returned inside a tuple together with the tx details which holds
+	* additional info not stored in the HydratedTx.
+	*
+	* @param txId - Cardano.TransactionId
+	*/
+	getTransactionDetails(txId) {
+		return forkJoin([
+			from(this.#txProvider.getTransaction(txId)),
+			this.#fetchTxFromCbor(txId),
+			this.#fetchUtxos(txId)
+		]).pipe(map(([txDetails, blockfrostTxCBOR, blockFrostUtxos]) => {
+			const { inputs, outputs, collaterals } = BlockfrostToCardanoSDK.transactionUtxos(blockFrostUtxos, blockfrostTxCBOR);
+			const inputSource = txDetails.valid_contract ? Cardano.InputSource.inputs : Cardano.InputSource.collaterals;
+			const body = {
+				...inputSource === Cardano.InputSource.collaterals ? {
+					collateralReturn: outputs.length > 0 ? outputs[0] : void 0,
+					collaterals: inputs,
+					fee: BigInt(0),
+					inputs: [],
+					outputs: [],
+					totalCollateral: blockfrostTxCBOR.body.fee
+				} : {
+					collateralReturn: blockfrostTxCBOR.body.collateralReturn ?? void 0,
+					collaterals,
+					fee: blockfrostTxCBOR.body.fee,
+					inputs,
+					outputs
+				},
+				certificates: blockfrostTxCBOR.body.certificates ?? [],
+				donation: blockfrostTxCBOR.body.donation,
+				mint: blockfrostTxCBOR.body.mint ? new Map([...blockfrostTxCBOR.body.mint].sort()) : void 0,
+				proposalProcedures: blockfrostTxCBOR.body.proposalProcedures,
+				validityInterval: blockfrostTxCBOR.body.validityInterval ? blockfrostTxCBOR.body.validityInterval : {
+					invalidBefore: void 0,
+					invalidHereafter: void 0
+				},
+				votingProcedures: blockfrostTxCBOR.body.votingProcedures,
+				withdrawals: blockfrostTxCBOR.body.withdrawals
+			};
+			return Ok({
+				auxiliaryData: blockfrostTxCBOR.auxiliaryData,
+				blockHeader: {
+					blockNo: Cardano.BlockNo(txDetails.block_height),
+					hash: Cardano.BlockId(txDetails.block),
+					slot: Cardano.Slot(txDetails.slot)
+				},
+				body,
+				id: txId,
+				index: txDetails.index,
+				inputSource,
+				txSize: 0,
+				witness: blockfrostTxCBOR.witness,
+				blockTime: txDetails.block_time
+			});
+		}), catchError((error) => of(Err(error))));
+	}
+	#fetchTxFromCbor(txId) {
+		return from(this.request(`txs/${txId}/cbor`)).pipe(map(({ cbor }) => Serialization.Transaction.fromCbor(Serialization.TxCBOR(cbor)).toCore()));
+	}
+	#fetchUtxos(txId) {
+		return from(this.request(`txs/${txId}/utxos`));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-input-resolver-provider.ts
+/**
+* A resolver class to fetch and resolve transaction inputs using Blockfrost API.
+*/
+var BlockfrostInputResolverProvider = class extends BlockfrostProvider {
+	/**
+	* Constructs a new BlockfrostInputResolverProvider.
+	*
+	* @param client - The Blockfrost client instance to interact with the Blockfrost API.
+	* @param logger - The logger instance to log messages to.
+	*/
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Resolves a transaction input (`Cardano.TxIn`) to its corresponding output (`Cardano.TxOut`).
+	*
+	* @param input - The transaction input to resolve, including its transaction ID and index.
+	* @returns A promise that resolves to the corresponding `Cardano.TxOut` if found, or `null` if not.
+	*/
+	async resolveInput(input) {
+		this.logger.debug(`Resolving input ${input.txId}#${input.index}`);
+		const out = await this.fetchTxOut(input);
+		if (!out) return null;
+		return out;
+	}
+	/**
+	* Fetches and caches the transaction output (`Cardano.TxOut`) for a given transaction input (`Cardano.TxIn`).
+	*
+	* @param txIn - The transaction input to fetch and cache the output for.
+	* @returns A promise that resolves to the corresponding `Cardano.TxOut` if found, or `null` if not.
+	*/
+	async fetchTxOut(txIn) {
+		let response;
+		try {
+			response = await this.request(`txs/${txIn.txId}/utxos`);
+		} catch (error) {
+			this.logger.error(`Failed to fetch transaction ${txIn.txId}`, error);
+			if (isNotFoundError(error)) return null;
+			throw error;
+		}
+		for (const blockfrostUTxO of response.outputs) {
+			if (blockfrostUTxO.output_index !== txIn.index) continue;
+			const coreTxOut = BlockfrostToCardanoSDK.txOut(blockfrostUTxO);
+			this.logger.debug(`Resolved input ${txIn.txId}#${txIn.index} from Blockfrost`);
+			return coreTxOut;
+		}
+		this.logger.error(`Failed to resolve input ${txIn.txId}#${txIn.index}`);
+		return null;
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-stake-pool-provider.ts
+var BlockfrostStakePoolProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	async getMetadata(poolId) {
+		try {
+			const metadata = await this.request(`pools/${poolId}/metadata`);
+			return Object.keys(metadata).length ? metadata : null;
+		} catch (error) {
+			if (error instanceof ProviderError$1) {
+				if (error.reason === ProviderFailure$1.NotFound) return null;
+				throw error;
+			}
+			throw toProviderError(error);
+		}
+	}
+	async getNetworkData() {
+		try {
+			const [genesis, params, network, retiring] = await Promise.all([
+				this.request("genesis"),
+				this.request("epochs/latest/parameters"),
+				this.request("network"),
+				this.paginatedRequests({
+					endpoint: "pools/retiring",
+					pageSize: 100
+				})
+			]);
+			return {
+				activeSlotsCoefficient: genesis.active_slots_coefficient,
+				desiredNumberOfPools: params.n_opt,
+				epochLength: genesis.epoch_length,
+				liveStake: Number(network.stake.live),
+				maxLovelaceSupply: Number(network.supply.max),
+				monetaryExpansion: params.rho,
+				poolInfluence: params.a0,
+				reserves: Number(network.supply.reserves),
+				retiringPools: retiring.map((pool) => pool.pool_id),
+				slotLength: genesis.slot_length,
+				timestamp: 0,
+				treasuryCut: params.tau
+			};
+		} catch (error) {
+			throw toProviderError(error);
+		}
+	}
+	async getStakePool(poolId) {
+		try {
+			return await this.request(`pools/${poolId}`);
+		} catch (error) {
+			if (error instanceof ProviderError$1) {
+				if (error.reason === ProviderFailure$1.NotFound) return null;
+				throw error;
+			}
+			throw toProviderError(error);
+		}
+	}
+	async getStakePools() {
+		try {
+			return await this.paginatedRequests({
+				endpoint: "pools/extended",
+				pageSize: 100
+			});
+		} catch (error) {
+			throw toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-rewards-provider.ts
+/**
+* Blockfrost returns 404 from the `accounts/*` endpoints for a stake address
+* that has never appeared on-chain. That is a normal state for a fresh
+* account, not an error: it means "never registered, nothing staked, no
+* rewards".
+*/
+const NEVER_ACTIVE_REWARD_ACCOUNT_INFO = {
+	isActive: false,
+	isRegistered: false,
+	rewardsSum: BigNumber(0n),
+	withdrawableAmount: BigNumber(0n),
+	controlledAmount: BigNumber(0n)
+};
+var BlockfrostRewardsProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches the total rewards balance for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the balance for
+	* @param epochs - Optional range of epochs to filter the rewards
+	* @returns Observable with Result containing the rewards or an error
+	*/
+	getAccountRewards({ rewardAccount }) {
+		return defer(async () => this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/rewards?order=desc`,
+			pageSize: 100
+		})).pipe(map((rewards) => Ok(rewards.map((reward) => ({
+			epoch: Cardano.EpochNo(reward.epoch),
+			rewards: BigNumber(BigInt(reward.amount)),
+			poolId: Cardano.PoolId(reward.pool_id)
+		})))), catchError((error) => {
+			if (isNotFoundError(error)) return of(Ok([]));
+			return of(Err(error));
+		}));
+	}
+	/**
+	* Fetches stake account information for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch info for
+	* @returns Observable with Result containing RewardAccountInfo or an error
+	*/
+	getRewardAccountInfo({ rewardAccount }) {
+		return from(this.request(`accounts/${rewardAccount}`).then((account) => Ok({
+			isActive: account.active,
+			isRegistered: account.registered ?? account.active,
+			...account.pool_id && { poolId: Cardano.PoolId(account.pool_id) },
+			...account.drep_id && { drepId: account.drep_id },
+			rewardsSum: BigNumber(BigInt(account.rewards_sum)),
+			withdrawableAmount: BigNumber(BigInt(account.withdrawable_amount)),
+			controlledAmount: BigNumber(BigInt(account.controlled_amount))
+		})).catch((error) => {
+			if (isNotFoundError(error)) return Ok(NEVER_ACTIVE_REWARD_ACCOUNT_INFO);
+			return Err(error);
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-delegations-provider.ts
+var BlockfrostDelegationsProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches all delegation history for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the delegations for
+	* @returns Observable with Result containing all delegations or an error
+	*/
+	getAccountDelegations({ rewardAccount }) {
+		return from(this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/delegations?order=desc`,
+			pageSize: 100
+		})).pipe(map((delegations) => Ok(delegations.map((delegation) => ({
+			activeEpoch: Cardano.EpochNo(delegation.active_epoch),
+			txHash: Cardano.TransactionId(delegation.tx_hash),
+			amount: BigNumber(BigInt(delegation.amount)),
+			poolId: Cardano.PoolId(delegation.pool_id)
+		})))), catchError((error) => of(Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-governance-provider.ts
+const PAGE_SIZE = 100;
+const jsonLdString = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "object" && value !== null && "@value" in value) {
+		const inner = value["@value"];
+		return typeof inner === "string" ? inner : void 0;
+	}
+};
+const getMetadataBody = (jsonMetadata) => {
+	if (typeof jsonMetadata !== "object" || jsonMetadata === null) return void 0;
+	const body = jsonMetadata.body;
+	if (typeof body !== "object" || body === null) return void 0;
+	return body;
+};
+const extractReferences = (references) => {
+	if (!Array.isArray(references)) return void 0;
+	const parsed = references.flatMap((reference) => {
+		if (typeof reference !== "object" || reference === null) return [];
+		const { uri, label } = reference;
+		const uriValue = jsonLdString(uri);
+		if (uriValue === void 0) return [];
+		const labelValue = jsonLdString(label);
+		return [{
+			uri: uriValue,
+			...labelValue !== void 0 && { label: labelValue }
+		}];
+	});
+	return parsed.length > 0 ? parsed : void 0;
+};
+const extractMetadata = (envelope, body) => {
+	const metadata = {};
+	if (typeof envelope?.url === "string") metadata.metadataUrl = envelope.url;
+	if (typeof envelope?.hash === "string") metadata.metadataHash = envelope.hash;
+	const assign = (key, value) => {
+		const parsed = jsonLdString(value);
+		if (parsed !== void 0) metadata[key] = parsed;
+	};
+	if (body) {
+		assign("imageUrl", (typeof body.image === "object" && body.image !== null ? body.image : void 0)?.contentUrl);
+		assign("bio", body.bio);
+		assign("email", body.email);
+		assign("objectives", body.objectives);
+		assign("motivations", body.motivations);
+		assign("qualifications", body.qualifications);
+		assign("paymentAddress", body.paymentAddress);
+		const references = extractReferences(body.references);
+		if (references) metadata.references = references;
+	}
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+};
+const toDRepSummary = (item) => {
+	const credential = {
+		hash: Hash28ByteBase16(item.hex.length === 58 ? item.hex.slice(2) : item.hex),
+		type: item.has_script ? Cardano.CredentialType.ScriptHash : Cardano.CredentialType.KeyHash
+	};
+	const body = getMetadataBody(item.metadata?.json_metadata);
+	return {
+		drepId: Cardano.DRepID(item.drep_id),
+		cip105DrepId: Cardano.DRepID.cip105FromCredential(credential),
+		hex: item.hex,
+		isActive: !item.retired && !item.expired,
+		retired: item.retired,
+		expired: item.expired,
+		amount: item.amount,
+		hasScript: item.has_script,
+		name: jsonLdString(body?.givenName),
+		metadata: extractMetadata(item.metadata, body)
+	};
+};
+var BlockfrostGovernanceProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	getDReps() {
+		const fetchPage = (page) => from(this.request(`governance/dreps?page=${page}&count=${PAGE_SIZE}`));
+		return fetchPage(1).pipe(expand((items, index) => items.length === PAGE_SIZE ? fetchPage(index + 2) : EMPTY), reduce((accumulated, items) => [...accumulated, ...items], []), map((all) => Ok(all.filter((d) => d.drep_id.startsWith("drep1")).map((item) => toDRepSummary(item)))), catchError((error) => of(Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-registrations-provider.ts
+var BlockfrostRegistrationsProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches all registration history for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the registrations for
+	* @returns Observable with Result containing all registrations or an error
+	*/
+	getAccountRegistrations({ rewardAccount }) {
+		return from(this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/registrations?order=desc`,
+			pageSize: 100
+		})).pipe(map((registrations) => Ok(registrations.map((registration) => ({
+			txHash: Cardano.TransactionId(registration.tx_hash),
+			action: registration.action
+		})))), catchError((error) => of(Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-withdrawals-provider.ts
+var BlockfrostWithdrawalsProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches all withdrawal history for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the withdrawals for
+	* @returns Observable with Result containing all withdrawals or an error
+	*/
+	getAccountWithdrawals({ rewardAccount }) {
+		return from(this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/withdrawals?order=desc`,
+			pageSize: 100
+		})).pipe(map((withdrawals) => Ok(withdrawals.map((withdrawal) => ({
+			txHash: Cardano.TransactionId(withdrawal.tx_hash),
+			amount: BigNumber(BigInt(withdrawal.amount))
+		})))), catchError((error) => of(Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-tx-evaluation-provider.ts
+const REDEEMER_PURPOSE_BY_NAME = {
+	spend: Cardano.RedeemerPurpose.spend,
+	mint: Cardano.RedeemerPurpose.mint,
+	certificate: Cardano.RedeemerPurpose.certificate,
+	publish: Cardano.RedeemerPurpose.certificate,
+	withdrawal: Cardano.RedeemerPurpose.withdrawal,
+	withdraw: Cardano.RedeemerPurpose.withdrawal,
+	vote: Cardano.RedeemerPurpose.vote,
+	propose: Cardano.RedeemerPurpose.propose
+};
+const toExUnits = (budget) => {
+	if (typeof budget !== "object" || budget === null) return void 0;
+	const { memory, steps, cpu } = budget;
+	const stepsValue = typeof steps === "number" ? steps : typeof cpu === "number" ? cpu : void 0;
+	if (typeof memory !== "number" || stepsValue === void 0) return void 0;
+	return {
+		memory,
+		steps: stepsValue
+	};
+};
+/** `"<purpose>:<index>"` (v5) or a `{ purpose, index }` object (v6). */
+const toRedeemerRef = (validator) => {
+	const { name, index } = typeof validator === "string" ? {
+		name: validator.split(":")[0],
+		index: Number(validator.split(":")[1] ?? "0")
+	} : {
+		name: validator?.purpose,
+		index: validator?.index ?? 0
+	};
+	const purpose = REDEEMER_PURPOSE_BY_NAME[name?.toLowerCase() ?? ""];
+	if (!purpose || !Number.isInteger(index)) return void 0;
+	return {
+		purpose,
+		index
+	};
+};
+const fromEvaluationResult = (evaluationResult) => Object.entries(evaluationResult).flatMap(([key, value]) => {
+	const ref = toRedeemerRef(key);
+	const budget = toExUnits(value);
+	return ref && budget ? [{
+		...ref,
+		budget
+	}] : [];
+});
+const fromEvaluationEntries = (entries) => entries.flatMap((entry) => {
+	const ref = toRedeemerRef(entry.validator);
+	const budget = toExUnits(entry.budget ?? entry.ex_units);
+	return ref && budget ? [{
+		...ref,
+		budget
+	}] : [];
+});
+/**
+* An empty list only for a collection that was itself empty. A NON-EMPTY
+* collection none of whose entries parsed is a dialect this parser does not
+* know, not a transaction without redeemers — reporting it as `[]` would spend
+* the contract's "no redeemers" answer on the drift this dual parser exists to
+* surface.
+*/
+const parsedOrUnrecognised = (sourceCount, parsed) => sourceCount > 0 && parsed.length === 0 ? void 0 : parsed;
+/**
+* Both dialects, unwrapped from the optional `result` envelope. `undefined`
+* distinguishes "this is not an evaluation" (a fault, an `EvaluationFailure`,
+* an unknown shape, a known envelope carrying only unreadable entries) from a
+* transaction that carries no redeemers, which legitimately evaluates to an
+* empty list.
+*/
+const parseEvaluation = (data) => {
+	const body = typeof data === "object" && data !== null && "result" in data ? data.result : data;
+	if (Array.isArray(body)) {
+		const entries = body;
+		return parsedOrUnrecognised(entries.length, fromEvaluationEntries(entries));
+	}
+	if (typeof body === "object" && body !== null) {
+		const { EvaluationResult: evaluationResult } = body;
+		if (typeof evaluationResult === "object" && evaluationResult !== null) {
+			const result = evaluationResult;
+			return parsedOrUnrecognised(Object.keys(result).length, fromEvaluationResult(result));
+		}
+	}
+};
+/** Truncated so a multi-kilobyte script trace cannot flood the log or the error. */
+const describeUnusableResponse = (data) => {
+	try {
+		return JSON.stringify(data)?.slice(0, 500) ?? "undefined";
+	} catch {
+		return String(data);
+	}
+};
+var BlockfrostTxEvaluationProvider = class extends BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Evaluate a transaction's per-redeemer execution units.
+	*
+	* @param tx - transaction CBOR (unsigned is fine)
+	* @returns Observable with the per-redeemer budgets, or an error when the
+	* network declined to evaluate (script failure, provider fault, HTTP error).
+	*/
+	evaluateTx({ tx }) {
+		return from(this.request("utils/txs/evaluate", {
+			body: tx,
+			headers: { "Content-Type": "application/cbor" },
+			method: "POST"
+		}).then((data) => {
+			const evaluated = parseEvaluation(data);
+			if (evaluated) return Ok(evaluated);
+			const detail = describeUnusableResponse(data);
+			this.logger.warn("evaluateTx: no evaluation in response", detail);
+			return Err(new ProviderError(ProviderFailure.InvalidResponse, void 0, detail));
+		}).catch((error) => Err(error)));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/util.ts
+const serializeMetadatum = ((value, stringifyComposite = false) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "bigint") return value.toString();
+	if (Array.isArray(value)) {
+		const serializedItems = value.map((item) => serializeMetadatum(item));
+		return stringifyComposite ? JSON.stringify(serializedItems) : serializedItems;
+	}
+	if (value instanceof Map) {
+		const serializedEntries = Object.fromEntries([...value.entries()].map(([key, nestedValue]) => [metadatumKeyToString(key), serializeMetadatum(nestedValue)]));
+		return stringifyComposite ? JSON.stringify(serializedEntries) : serializedEntries;
+	}
+	if (value instanceof Uint8Array) try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(value);
+	} catch {
+		return `[Invalid UTF-8: ${value.length} bytes]`;
+	}
+	return String(value);
+});
+const metadatumKeyToString = (value) => serializeMetadatum(value, true);
+const metadatumToSerializableValue = (value) => serializeMetadatum(value);
+const mapToRecord = (map) => [...map?.entries() || []].map(([key, value]) => [key, metadatumToSerializableValue(value)]).reduce((result, [key, value]) => {
+	result[key] = value;
+	return result;
+}, {});
+const mergeDefinedProperties = (properties) => {
+	const definedProperties = properties.filter((property) => property[1] !== void 0);
+	if (definedProperties.length === 0) return;
+	return Object.fromEntries(definedProperties);
+};
+const toContractTokenMetadata = (assetInfo) => ({
+	blockchainSpecific: {
+		metadataSchemaVersion: 1,
+		updatedAt: Timestamp.now(),
+		policyId: assetInfo.policyId.toString(),
+		files: assetInfo.nftMetadata?.files?.map((file) => ({
+			mediaType: file.mediaType,
+			src: file.src,
+			name: file.name,
+			additionalProperties: mapToRecord(file.otherProperties)
+		}))
+	},
+	decimals: assetInfo.tokenMetadata?.decimals || 0,
+	additionalProperties: mergeDefinedProperties([["description", assetInfo.nftMetadata?.description], ...Object.entries(mapToRecord(assetInfo.nftMetadata?.otherProperties) ?? {})]),
+	image: assetInfo.nftMetadata?.image || assetInfo.tokenMetadata?.icon,
+	isNft: assetInfo.supply === 1n,
+	name: assetInfo.nftMetadata?.name || assetInfo.tokenMetadata?.name || assetInfo.fingerprint,
+	ticker: assetInfo.tokenMetadata?.ticker
+});
+/** Base lovelace metadata; ticker and image are set per-network in Blockfrost dependencies. */
+const LOVELACE_METADATA = {
+	decimals: 6,
+	name: "Cardano",
+	ticker: "ADA",
+	blockchainSpecific: {
+		metadataSchemaVersion: 1,
+		updatedAt: Timestamp.now()
+	}
+};
+//#endregion
+//#region ../../node_modules/bottleneck/lib/parser.js
+var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.load = function(received, defaults, onto = {}) {
+		var k, ref, v;
+		for (k in defaults) {
+			v = defaults[k];
+			onto[k] = (ref = received[k]) != null ? ref : v;
+		}
+		return onto;
+	};
+	exports.overwrite = function(received, defaults, onto = {}) {
+		var k, v;
+		for (k in received) {
+			v = received[k];
+			if (defaults[k] !== void 0) onto[k] = v;
+		}
+		return onto;
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/DLList.js
+var require_DLList = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = class DLList {
+		constructor(incr, decr) {
+			this.incr = incr;
+			this.decr = decr;
+			this._first = null;
+			this._last = null;
+			this.length = 0;
+		}
+		push(value) {
+			var node;
+			this.length++;
+			if (typeof this.incr === "function") this.incr();
+			node = {
+				value,
+				prev: this._last,
+				next: null
+			};
+			if (this._last != null) {
+				this._last.next = node;
+				this._last = node;
+			} else this._first = this._last = node;
+		}
+		shift() {
+			var value;
+			if (this._first == null) return;
+			else {
+				this.length--;
+				if (typeof this.decr === "function") this.decr();
+			}
+			value = this._first.value;
+			if ((this._first = this._first.next) != null) this._first.prev = null;
+			else this._last = null;
+			return value;
+		}
+		first() {
+			if (this._first != null) return this._first.value;
+		}
+		getArray() {
+			var node = this._first, ref, results = [];
+			while (node != null) results.push((ref = node, node = node.next, ref.value));
+			return results;
+		}
+		forEachShift(cb) {
+			var node = this.shift();
+			while (node != null) cb(node), node = this.shift();
+		}
+		debug() {
+			var node = this._first, ref, ref1, ref2, results = [];
+			while (node != null) results.push((ref = node, node = node.next, {
+				value: ref.value,
+				prev: (ref1 = ref.prev) != null ? ref1.value : void 0,
+				next: (ref2 = ref.next) != null ? ref2.value : void 0
+			}));
+			return results;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Events.js
+var require_Events = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	module.exports = class Events {
+		constructor(instance) {
+			this.instance = instance;
+			this._events = {};
+			if (this.instance.on != null || this.instance.once != null || this.instance.removeAllListeners != null) throw new Error("An Emitter already exists for this object");
+			this.instance.on = (name, cb) => {
+				return this._addListener(name, "many", cb);
+			};
+			this.instance.once = (name, cb) => {
+				return this._addListener(name, "once", cb);
+			};
+			this.instance.removeAllListeners = (name = null) => {
+				if (name != null) return delete this._events[name];
+				else return this._events = {};
+			};
+		}
+		_addListener(name, status, cb) {
+			var base;
+			if ((base = this._events)[name] == null) base[name] = [];
+			this._events[name].push({
+				cb,
+				status
+			});
+			return this.instance;
+		}
+		listenerCount(name) {
+			if (this._events[name] != null) return this._events[name].length;
+			else return 0;
+		}
+		trigger(name, ...args) {
+			var _this = this;
+			return _asyncToGenerator(function* () {
+				var e, promises;
+				try {
+					if (name !== "debug") _this.trigger("debug", `Event triggered: ${name}`, args);
+					if (_this._events[name] == null) return;
+					_this._events[name] = _this._events[name].filter(function(listener) {
+						return listener.status !== "none";
+					});
+					promises = _this._events[name].map(/* @__PURE__ */ function() {
+						var _ref = _asyncToGenerator(function* (listener) {
+							var e, returned;
+							if (listener.status === "none") return;
+							if (listener.status === "once") listener.status = "none";
+							try {
+								returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0;
+								if (typeof (returned != null ? returned.then : void 0) === "function") return yield returned;
+								else return returned;
+							} catch (error) {
+								e = error;
+								_this.trigger("error", e);
+								return null;
+							}
+						});
+						return function(_x) {
+							return _ref.apply(this, arguments);
+						};
+					}());
+					return (yield Promise.all(promises)).find(function(x) {
+						return x != null;
+					});
+				} catch (error) {
+					e = error;
+					_this.trigger("error", e);
+					return null;
+				}
+			})();
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Queues.js
+var require_Queues = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var DLList = require_DLList(), Events = require_Events();
+	module.exports = class Queues {
+		constructor(num_priorities) {
+			this.Events = new Events(this);
+			this._length = 0;
+			this._lists = function() {
+				var j, ref, results = [];
+				for (j = 1, ref = num_priorities; 1 <= ref ? j <= ref : j >= ref; 1 <= ref ? ++j : --j) results.push(new DLList(() => {
+					return this.incr();
+				}, () => {
+					return this.decr();
+				}));
+				return results;
+			}.call(this);
+		}
+		incr() {
+			if (this._length++ === 0) return this.Events.trigger("leftzero");
+		}
+		decr() {
+			if (--this._length === 0) return this.Events.trigger("zero");
+		}
+		push(job) {
+			return this._lists[job.options.priority].push(job);
+		}
+		queued(priority) {
+			if (priority != null) return this._lists[priority].length;
+			else return this._length;
+		}
+		shiftAll(fn) {
+			return this._lists.forEach(function(list) {
+				return list.forEachShift(fn);
+			});
+		}
+		getFirst(arr = this._lists) {
+			var j, len, list;
+			for (j = 0, len = arr.length; j < len; j++) {
+				list = arr[j];
+				if (list.length > 0) return list;
+			}
+			return [];
+		}
+		shiftLastFrom(priority) {
+			return this.getFirst(this._lists.slice(priority).reverse()).shift();
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/BottleneckError.js
+var require_BottleneckError = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = class BottleneckError extends Error {};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Job.js
+var require_Job = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var BottleneckError, DEFAULT_PRIORITY, Job, NUM_PRIORITIES = 10, parser;
+	DEFAULT_PRIORITY = 5;
+	parser = require_parser();
+	BottleneckError = require_BottleneckError();
+	Job = class Job {
+		constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) {
+			this.task = task;
+			this.args = args;
+			this.rejectOnDrop = rejectOnDrop;
+			this.Events = Events;
+			this._states = _states;
+			this.Promise = Promise;
+			this.options = parser.load(options, jobDefaults);
+			this.options.priority = this._sanitizePriority(this.options.priority);
+			if (this.options.id === jobDefaults.id) this.options.id = `${this.options.id}-${this._randomIndex()}`;
+			this.promise = new this.Promise((_resolve, _reject) => {
+				this._resolve = _resolve;
+				this._reject = _reject;
+			});
+			this.retryCount = 0;
+		}
+		_sanitizePriority(priority) {
+			var sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority;
+			if (sProperty < 0) return 0;
+			else if (sProperty > NUM_PRIORITIES - 1) return NUM_PRIORITIES - 1;
+			else return sProperty;
+		}
+		_randomIndex() {
+			return Math.random().toString(36).slice(2);
+		}
+		doDrop({ error, message = "This job has been dropped by Bottleneck" } = {}) {
+			if (this._states.remove(this.options.id)) {
+				if (this.rejectOnDrop) this._reject(error != null ? error : new BottleneckError(message));
+				this.Events.trigger("dropped", {
+					args: this.args,
+					options: this.options,
+					task: this.task,
+					promise: this.promise
+				});
+				return true;
+			} else return false;
+		}
+		_assertStatus(expected) {
+			var status = this._states.jobStatus(this.options.id);
+			if (!(status === expected || expected === "DONE" && status === null)) throw new BottleneckError(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`);
+		}
+		doReceive() {
+			this._states.start(this.options.id);
+			return this.Events.trigger("received", {
+				args: this.args,
+				options: this.options
+			});
+		}
+		doQueue(reachedHWM, blocked) {
+			this._assertStatus("RECEIVED");
+			this._states.next(this.options.id);
+			return this.Events.trigger("queued", {
+				args: this.args,
+				options: this.options,
+				reachedHWM,
+				blocked
+			});
+		}
+		doRun() {
+			if (this.retryCount === 0) {
+				this._assertStatus("QUEUED");
+				this._states.next(this.options.id);
+			} else this._assertStatus("EXECUTING");
+			return this.Events.trigger("scheduled", {
+				args: this.args,
+				options: this.options
+			});
+		}
+		doExecute(chained, clearGlobalState, run, free) {
+			var _this = this;
+			return _asyncToGenerator(function* () {
+				var error, eventInfo, passed;
+				if (_this.retryCount === 0) {
+					_this._assertStatus("RUNNING");
+					_this._states.next(_this.options.id);
+				} else _this._assertStatus("EXECUTING");
+				eventInfo = {
+					args: _this.args,
+					options: _this.options,
+					retryCount: _this.retryCount
+				};
+				_this.Events.trigger("executing", eventInfo);
+				try {
+					passed = yield chained != null ? chained.schedule(_this.options, _this.task, ..._this.args) : _this.task(..._this.args);
+					if (clearGlobalState()) {
+						_this.doDone(eventInfo);
+						yield free(_this.options, eventInfo);
+						_this._assertStatus("DONE");
+						return _this._resolve(passed);
+					}
+				} catch (error1) {
+					error = error1;
+					return _this._onFailure(error, eventInfo, clearGlobalState, run, free);
+				}
+			})();
+		}
+		doExpire(clearGlobalState, run, free) {
+			var error, eventInfo;
+			if (this._states.jobStatus(this.options.id === "RUNNING")) this._states.next(this.options.id);
+			this._assertStatus("EXECUTING");
+			eventInfo = {
+				args: this.args,
+				options: this.options,
+				retryCount: this.retryCount
+			};
+			error = new BottleneckError(`This job timed out after ${this.options.expiration} ms.`);
+			return this._onFailure(error, eventInfo, clearGlobalState, run, free);
+		}
+		_onFailure(error, eventInfo, clearGlobalState, run, free) {
+			var _this2 = this;
+			return _asyncToGenerator(function* () {
+				var retry, retryAfter;
+				if (clearGlobalState()) {
+					retry = yield _this2.Events.trigger("failed", error, eventInfo);
+					if (retry != null) {
+						retryAfter = ~~retry;
+						_this2.Events.trigger("retry", `Retrying ${_this2.options.id} after ${retryAfter} ms`, eventInfo);
+						_this2.retryCount++;
+						return run(retryAfter);
+					} else {
+						_this2.doDone(eventInfo);
+						yield free(_this2.options, eventInfo);
+						_this2._assertStatus("DONE");
+						return _this2._reject(error);
+					}
+				}
+			})();
+		}
+		doDone(eventInfo) {
+			this._assertStatus("EXECUTING");
+			this._states.next(this.options.id);
+			return this.Events.trigger("done", eventInfo);
+		}
+	};
+	module.exports = Job;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/LocalDatastore.js
+var require_LocalDatastore = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var BottleneckError, LocalDatastore, parser = require_parser();
+	BottleneckError = require_BottleneckError();
+	LocalDatastore = class LocalDatastore {
+		constructor(instance, storeOptions, storeInstanceOptions) {
+			this.instance = instance;
+			this.storeOptions = storeOptions;
+			this.clientId = this.instance._randomIndex();
+			parser.load(storeInstanceOptions, storeInstanceOptions, this);
+			this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now();
+			this._running = 0;
+			this._done = 0;
+			this._unblockTime = 0;
+			this.ready = this.Promise.resolve();
+			this.clients = {};
+			this._startHeartbeat();
+		}
+		_startHeartbeat() {
+			var base;
+			if (this.heartbeat == null && (this.storeOptions.reservoirRefreshInterval != null && this.storeOptions.reservoirRefreshAmount != null || this.storeOptions.reservoirIncreaseInterval != null && this.storeOptions.reservoirIncreaseAmount != null)) return typeof (base = this.heartbeat = setInterval(() => {
+				var amount, incr, maximum, now = Date.now(), reservoir;
+				if (this.storeOptions.reservoirRefreshInterval != null && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) {
+					this._lastReservoirRefresh = now;
+					this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount;
+					this.instance._drainAll(this.computeCapacity());
+				}
+				if (this.storeOptions.reservoirIncreaseInterval != null && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) {
+					var _this$storeOptions = this.storeOptions;
+					amount = _this$storeOptions.reservoirIncreaseAmount;
+					maximum = _this$storeOptions.reservoirIncreaseMaximum;
+					reservoir = _this$storeOptions.reservoir;
+					this._lastReservoirIncrease = now;
+					incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount;
+					if (incr > 0) {
+						this.storeOptions.reservoir += incr;
+						return this.instance._drainAll(this.computeCapacity());
+					}
+				}
+			}, this.heartbeatInterval)).unref === "function" ? base.unref() : void 0;
+			else return clearInterval(this.heartbeat);
+		}
+		__publish__(message) {
+			var _this = this;
+			return _asyncToGenerator(function* () {
+				yield _this.yieldLoop();
+				return _this.instance.Events.trigger("message", message.toString());
+			})();
+		}
+		__disconnect__(flush) {
+			var _this2 = this;
+			return _asyncToGenerator(function* () {
+				yield _this2.yieldLoop();
+				clearInterval(_this2.heartbeat);
+				return _this2.Promise.resolve();
+			})();
+		}
+		yieldLoop(t = 0) {
+			return new this.Promise(function(resolve, reject) {
+				return setTimeout(resolve, t);
+			});
+		}
+		computePenalty() {
+			var ref;
+			return (ref = this.storeOptions.penalty) != null ? ref : 15 * this.storeOptions.minTime || 5e3;
+		}
+		__updateSettings__(options) {
+			var _this3 = this;
+			return _asyncToGenerator(function* () {
+				yield _this3.yieldLoop();
+				parser.overwrite(options, options, _this3.storeOptions);
+				_this3._startHeartbeat();
+				_this3.instance._drainAll(_this3.computeCapacity());
+				return true;
+			})();
+		}
+		__running__() {
+			var _this4 = this;
+			return _asyncToGenerator(function* () {
+				yield _this4.yieldLoop();
+				return _this4._running;
+			})();
+		}
+		__queued__() {
+			var _this5 = this;
+			return _asyncToGenerator(function* () {
+				yield _this5.yieldLoop();
+				return _this5.instance.queued();
+			})();
+		}
+		__done__() {
+			var _this6 = this;
+			return _asyncToGenerator(function* () {
+				yield _this6.yieldLoop();
+				return _this6._done;
+			})();
+		}
+		__groupCheck__(time) {
+			var _this7 = this;
+			return _asyncToGenerator(function* () {
+				yield _this7.yieldLoop();
+				return _this7._nextRequest + _this7.timeout < time;
+			})();
+		}
+		computeCapacity() {
+			var maxConcurrent, reservoir;
+			var _this$storeOptions2 = this.storeOptions;
+			maxConcurrent = _this$storeOptions2.maxConcurrent;
+			reservoir = _this$storeOptions2.reservoir;
+			if (maxConcurrent != null && reservoir != null) return Math.min(maxConcurrent - this._running, reservoir);
+			else if (maxConcurrent != null) return maxConcurrent - this._running;
+			else if (reservoir != null) return reservoir;
+			else return null;
+		}
+		conditionsCheck(weight) {
+			var capacity = this.computeCapacity();
+			return capacity == null || weight <= capacity;
+		}
+		__incrementReservoir__(incr) {
+			var _this8 = this;
+			return _asyncToGenerator(function* () {
+				var reservoir;
+				yield _this8.yieldLoop();
+				reservoir = _this8.storeOptions.reservoir += incr;
+				_this8.instance._drainAll(_this8.computeCapacity());
+				return reservoir;
+			})();
+		}
+		__currentReservoir__() {
+			var _this9 = this;
+			return _asyncToGenerator(function* () {
+				yield _this9.yieldLoop();
+				return _this9.storeOptions.reservoir;
+			})();
+		}
+		isBlocked(now) {
+			return this._unblockTime >= now;
+		}
+		check(weight, now) {
+			return this.conditionsCheck(weight) && this._nextRequest - now <= 0;
+		}
+		__check__(weight) {
+			var _this10 = this;
+			return _asyncToGenerator(function* () {
+				var now;
+				yield _this10.yieldLoop();
+				now = Date.now();
+				return _this10.check(weight, now);
+			})();
+		}
+		__register__(index, weight, expiration) {
+			var _this11 = this;
+			return _asyncToGenerator(function* () {
+				var now, wait;
+				yield _this11.yieldLoop();
+				now = Date.now();
+				if (_this11.conditionsCheck(weight)) {
+					_this11._running += weight;
+					if (_this11.storeOptions.reservoir != null) _this11.storeOptions.reservoir -= weight;
+					wait = Math.max(_this11._nextRequest - now, 0);
+					_this11._nextRequest = now + wait + _this11.storeOptions.minTime;
+					return {
+						success: true,
+						wait,
+						reservoir: _this11.storeOptions.reservoir
+					};
+				} else return { success: false };
+			})();
+		}
+		strategyIsBlock() {
+			return this.storeOptions.strategy === 3;
+		}
+		__submit__(queueLength, weight) {
+			var _this12 = this;
+			return _asyncToGenerator(function* () {
+				var blocked, now, reachedHWM;
+				yield _this12.yieldLoop();
+				if (_this12.storeOptions.maxConcurrent != null && weight > _this12.storeOptions.maxConcurrent) throw new BottleneckError(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${_this12.storeOptions.maxConcurrent}`);
+				now = Date.now();
+				reachedHWM = _this12.storeOptions.highWater != null && queueLength === _this12.storeOptions.highWater && !_this12.check(weight, now);
+				blocked = _this12.strategyIsBlock() && (reachedHWM || _this12.isBlocked(now));
+				if (blocked) {
+					_this12._unblockTime = now + _this12.computePenalty();
+					_this12._nextRequest = _this12._unblockTime + _this12.storeOptions.minTime;
+					_this12.instance._dropAllQueued();
+				}
+				return {
+					reachedHWM,
+					blocked,
+					strategy: _this12.storeOptions.strategy
+				};
+			})();
+		}
+		__free__(index, weight) {
+			var _this13 = this;
+			return _asyncToGenerator(function* () {
+				yield _this13.yieldLoop();
+				_this13._running -= weight;
+				_this13._done += weight;
+				_this13.instance._drainAll(_this13.computeCapacity());
+				return { running: _this13._running };
+			})();
+		}
+	};
+	module.exports = LocalDatastore;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/lua.json
+var require_lua = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"blacklist_client.lua": "local blacklist = ARGV[num_static_argv + 1]\n\nif redis.call('zscore', client_last_seen_key, blacklist) then\n  redis.call('zadd', client_last_seen_key, 0, blacklist)\nend\n\n\nreturn {}\n",
+		"check.lua": "local weight = tonumber(ARGV[num_static_argv + 1])\n\nlocal capacity = process_tick(now, false)['capacity']\nlocal nextRequest = tonumber(redis.call('hget', settings_key, 'nextRequest'))\n\nreturn conditions_check(capacity, weight) and nextRequest - now <= 0\n",
+		"conditions_check.lua": "local conditions_check = function (capacity, weight)\n  return capacity == nil or weight <= capacity\nend\n",
+		"current_reservoir.lua": "return process_tick(now, false)['reservoir']\n",
+		"done.lua": "process_tick(now, false)\n\nreturn tonumber(redis.call('hget', settings_key, 'done'))\n",
+		"free.lua": "local index = ARGV[num_static_argv + 1]\n\nredis.call('zadd', job_expirations_key, 0, index)\n\nreturn process_tick(now, false)['running']\n",
+		"get_time.lua": "redis.replicate_commands()\n\nlocal get_time = function ()\n  local time = redis.call('time')\n\n  return tonumber(time[1]..string.sub(time[2], 1, 3))\nend\n",
+		"group_check.lua": "return not (redis.call('exists', settings_key) == 1)\n",
+		"heartbeat.lua": "process_tick(now, true)\n",
+		"increment_reservoir.lua": "local incr = tonumber(ARGV[num_static_argv + 1])\n\nredis.call('hincrby', settings_key, 'reservoir', incr)\n\nlocal reservoir = process_tick(now, true)['reservoir']\n\nlocal groupTimeout = tonumber(redis.call('hget', settings_key, 'groupTimeout'))\nrefresh_expiration(0, 0, groupTimeout)\n\nreturn reservoir\n",
+		"init.lua": "local clear = tonumber(ARGV[num_static_argv + 1])\nlocal limiter_version = ARGV[num_static_argv + 2]\nlocal num_local_argv = num_static_argv + 2\n\nif clear == 1 then\n  redis.call('del', unpack(KEYS))\nend\n\nif redis.call('exists', settings_key) == 0 then\n  -- Create\n  local args = {'hmset', settings_key}\n\n  for i = num_local_argv + 1, #ARGV do\n    table.insert(args, ARGV[i])\n  end\n\n  redis.call(unpack(args))\n  redis.call('hmset', settings_key,\n    'nextRequest', now,\n    'lastReservoirRefresh', now,\n    'lastReservoirIncrease', now,\n    'running', 0,\n    'done', 0,\n    'unblockTime', 0,\n    'capacityPriorityCounter', 0\n  )\n\nelse\n  -- Apply migrations\n  local settings = redis.call('hmget', settings_key,\n    'id',\n    'version'\n  )\n  local id = settings[1]\n  local current_version = settings[2]\n\n  if current_version ~= limiter_version then\n    local version_digits = {}\n    for k, v in string.gmatch(current_version, \"([^.]+)\") do\n      table.insert(version_digits, tonumber(k))\n    end\n\n    -- 2.10.0\n    if version_digits[2] < 10 then\n      redis.call('hsetnx', settings_key, 'reservoirRefreshInterval', '')\n      redis.call('hsetnx', settings_key, 'reservoirRefreshAmount', '')\n      redis.call('hsetnx', settings_key, 'lastReservoirRefresh', '')\n      redis.call('hsetnx', settings_key, 'done', 0)\n      redis.call('hset', settings_key, 'version', '2.10.0')\n    end\n\n    -- 2.11.1\n    if version_digits[2] < 11 or (version_digits[2] == 11 and version_digits[3] < 1) then\n      if redis.call('hstrlen', settings_key, 'lastReservoirRefresh') == 0 then\n        redis.call('hmset', settings_key,\n          'lastReservoirRefresh', now,\n          'version', '2.11.1'\n        )\n      end\n    end\n\n    -- 2.14.0\n    if version_digits[2] < 14 then\n      local old_running_key = 'b_'..id..'_running'\n      local old_executing_key = 'b_'..id..'_executing'\n\n      if redis.call('exists', old_running_key) == 1 then\n        redis.call('rename', old_running_key, job_weights_key)\n      end\n      if redis.call('exists', old_executing_key) == 1 then\n        redis.call('rename', old_executing_key, job_expirations_key)\n      end\n      redis.call('hset', settings_key, 'version', '2.14.0')\n    end\n\n    -- 2.15.2\n    if version_digits[2] < 15 or (version_digits[2] == 15 and version_digits[3] < 2) then\n      redis.call('hsetnx', settings_key, 'capacityPriorityCounter', 0)\n      redis.call('hset', settings_key, 'version', '2.15.2')\n    end\n\n    -- 2.17.0\n    if version_digits[2] < 17 then\n      redis.call('hsetnx', settings_key, 'clientTimeout', 10000)\n      redis.call('hset', settings_key, 'version', '2.17.0')\n    end\n\n    -- 2.18.0\n    if version_digits[2] < 18 then\n      redis.call('hsetnx', settings_key, 'reservoirIncreaseInterval', '')\n      redis.call('hsetnx', settings_key, 'reservoirIncreaseAmount', '')\n      redis.call('hsetnx', settings_key, 'reservoirIncreaseMaximum', '')\n      redis.call('hsetnx', settings_key, 'lastReservoirIncrease', now)\n      redis.call('hset', settings_key, 'version', '2.18.0')\n    end\n\n  end\n\n  process_tick(now, false)\nend\n\nlocal groupTimeout = tonumber(redis.call('hget', settings_key, 'groupTimeout'))\nrefresh_expiration(0, 0, groupTimeout)\n\nreturn {}\n",
+		"process_tick.lua": "local process_tick = function (now, always_publish)\n\n  local compute_capacity = function (maxConcurrent, running, reservoir)\n    if maxConcurrent ~= nil and reservoir ~= nil then\n      return math.min((maxConcurrent - running), reservoir)\n    elseif maxConcurrent ~= nil then\n      return maxConcurrent - running\n    elseif reservoir ~= nil then\n      return reservoir\n    else\n      return nil\n    end\n  end\n\n  local settings = redis.call('hmget', settings_key,\n    'id',\n    'maxConcurrent',\n    'running',\n    'reservoir',\n    'reservoirRefreshInterval',\n    'reservoirRefreshAmount',\n    'lastReservoirRefresh',\n    'reservoirIncreaseInterval',\n    'reservoirIncreaseAmount',\n    'reservoirIncreaseMaximum',\n    'lastReservoirIncrease',\n    'capacityPriorityCounter',\n    'clientTimeout'\n  )\n  local id = settings[1]\n  local maxConcurrent = tonumber(settings[2])\n  local running = tonumber(settings[3])\n  local reservoir = tonumber(settings[4])\n  local reservoirRefreshInterval = tonumber(settings[5])\n  local reservoirRefreshAmount = tonumber(settings[6])\n  local lastReservoirRefresh = tonumber(settings[7])\n  local reservoirIncreaseInterval = tonumber(settings[8])\n  local reservoirIncreaseAmount = tonumber(settings[9])\n  local reservoirIncreaseMaximum = tonumber(settings[10])\n  local lastReservoirIncrease = tonumber(settings[11])\n  local capacityPriorityCounter = tonumber(settings[12])\n  local clientTimeout = tonumber(settings[13])\n\n  local initial_capacity = compute_capacity(maxConcurrent, running, reservoir)\n\n  --\n  -- Process 'running' changes\n  --\n  local expired = redis.call('zrangebyscore', job_expirations_key, '-inf', '('..now)\n\n  if #expired > 0 then\n    redis.call('zremrangebyscore', job_expirations_key, '-inf', '('..now)\n\n    local flush_batch = function (batch, acc)\n      local weights = redis.call('hmget', job_weights_key, unpack(batch))\n                      redis.call('hdel',  job_weights_key, unpack(batch))\n      local clients = redis.call('hmget', job_clients_key, unpack(batch))\n                      redis.call('hdel',  job_clients_key, unpack(batch))\n\n      -- Calculate sum of removed weights\n      for i = 1, #weights do\n        acc['total'] = acc['total'] + (tonumber(weights[i]) or 0)\n      end\n\n      -- Calculate sum of removed weights by client\n      local client_weights = {}\n      for i = 1, #clients do\n        local removed = tonumber(weights[i]) or 0\n        if removed > 0 then\n          acc['client_weights'][clients[i]] = (acc['client_weights'][clients[i]] or 0) + removed\n        end\n      end\n    end\n\n    local acc = {\n      ['total'] = 0,\n      ['client_weights'] = {}\n    }\n    local batch_size = 1000\n\n    -- Compute changes to Zsets and apply changes to Hashes\n    for i = 1, #expired, batch_size do\n      local batch = {}\n      for j = i, math.min(i + batch_size - 1, #expired) do\n        table.insert(batch, expired[j])\n      end\n\n      flush_batch(batch, acc)\n    end\n\n    -- Apply changes to Zsets\n    if acc['total'] > 0 then\n      redis.call('hincrby', settings_key, 'done', acc['total'])\n      running = tonumber(redis.call('hincrby', settings_key, 'running', -acc['total']))\n    end\n\n    for client, weight in pairs(acc['client_weights']) do\n      redis.call('zincrby', client_running_key, -weight, client)\n    end\n  end\n\n  --\n  -- Process 'reservoir' changes\n  --\n  local reservoirRefreshActive = reservoirRefreshInterval ~= nil and reservoirRefreshAmount ~= nil\n  if reservoirRefreshActive and now >= lastReservoirRefresh + reservoirRefreshInterval then\n    reservoir = reservoirRefreshAmount\n    redis.call('hmset', settings_key,\n      'reservoir', reservoir,\n      'lastReservoirRefresh', now\n    )\n  end\n\n  local reservoirIncreaseActive = reservoirIncreaseInterval ~= nil and reservoirIncreaseAmount ~= nil\n  if reservoirIncreaseActive and now >= lastReservoirIncrease + reservoirIncreaseInterval then\n    local num_intervals = math.floor((now - lastReservoirIncrease) / reservoirIncreaseInterval)\n    local incr = reservoirIncreaseAmount * num_intervals\n    if reservoirIncreaseMaximum ~= nil then\n      incr = math.min(incr, reservoirIncreaseMaximum - (reservoir or 0))\n    end\n    if incr > 0 then\n      reservoir = (reservoir or 0) + incr\n    end\n    redis.call('hmset', settings_key,\n      'reservoir', reservoir,\n      'lastReservoirIncrease', lastReservoirIncrease + (num_intervals * reservoirIncreaseInterval)\n    )\n  end\n\n  --\n  -- Clear unresponsive clients\n  --\n  local unresponsive = redis.call('zrangebyscore', client_last_seen_key, '-inf', (now - clientTimeout))\n  local unresponsive_lookup = {}\n  local terminated_clients = {}\n  for i = 1, #unresponsive do\n    unresponsive_lookup[unresponsive[i]] = true\n    if tonumber(redis.call('zscore', client_running_key, unresponsive[i])) == 0 then\n      table.insert(terminated_clients, unresponsive[i])\n    end\n  end\n  if #terminated_clients > 0 then\n    redis.call('zrem', client_running_key,         unpack(terminated_clients))\n    redis.call('hdel', client_num_queued_key,      unpack(terminated_clients))\n    redis.call('zrem', client_last_registered_key, unpack(terminated_clients))\n    redis.call('zrem', client_last_seen_key,       unpack(terminated_clients))\n  end\n\n  --\n  -- Broadcast capacity changes\n  --\n  local final_capacity = compute_capacity(maxConcurrent, running, reservoir)\n\n  if always_publish or (initial_capacity ~= nil and final_capacity == nil) then\n    -- always_publish or was not unlimited, now unlimited\n    redis.call('publish', 'b_'..id, 'capacity:'..(final_capacity or ''))\n\n  elseif initial_capacity ~= nil and final_capacity ~= nil and final_capacity > initial_capacity then\n    -- capacity was increased\n    -- send the capacity message to the limiter having the lowest number of running jobs\n    -- the tiebreaker is the limiter having not registered a job in the longest time\n\n    local lowest_concurrency_value = nil\n    local lowest_concurrency_clients = {}\n    local lowest_concurrency_last_registered = {}\n    local client_concurrencies = redis.call('zrange', client_running_key, 0, -1, 'withscores')\n\n    for i = 1, #client_concurrencies, 2 do\n      local client = client_concurrencies[i]\n      local concurrency = tonumber(client_concurrencies[i+1])\n\n      if (\n        lowest_concurrency_value == nil or lowest_concurrency_value == concurrency\n      ) and (\n        not unresponsive_lookup[client]\n      ) and (\n        tonumber(redis.call('hget', client_num_queued_key, client)) > 0\n      ) then\n        lowest_concurrency_value = concurrency\n        table.insert(lowest_concurrency_clients, client)\n        local last_registered = tonumber(redis.call('zscore', client_last_registered_key, client))\n        table.insert(lowest_concurrency_last_registered, last_registered)\n      end\n    end\n\n    if #lowest_concurrency_clients > 0 then\n      local position = 1\n      local earliest = lowest_concurrency_last_registered[1]\n\n      for i,v in ipairs(lowest_concurrency_last_registered) do\n        if v < earliest then\n          position = i\n          earliest = v\n        end\n      end\n\n      local next_client = lowest_concurrency_clients[position]\n      redis.call('publish', 'b_'..id,\n        'capacity-priority:'..(final_capacity or '')..\n        ':'..next_client..\n        ':'..capacityPriorityCounter\n      )\n      redis.call('hincrby', settings_key, 'capacityPriorityCounter', '1')\n    else\n      redis.call('publish', 'b_'..id, 'capacity:'..(final_capacity or ''))\n    end\n  end\n\n  return {\n    ['capacity'] = final_capacity,\n    ['running'] = running,\n    ['reservoir'] = reservoir\n  }\nend\n",
+		"queued.lua": "local clientTimeout = tonumber(redis.call('hget', settings_key, 'clientTimeout'))\nlocal valid_clients = redis.call('zrangebyscore', client_last_seen_key, (now - clientTimeout), 'inf')\nlocal client_queued = redis.call('hmget', client_num_queued_key, unpack(valid_clients))\n\nlocal sum = 0\nfor i = 1, #client_queued do\n  sum = sum + tonumber(client_queued[i])\nend\n\nreturn sum\n",
+		"refresh_expiration.lua": "local refresh_expiration = function (now, nextRequest, groupTimeout)\n\n  if groupTimeout ~= nil then\n    local ttl = (nextRequest + groupTimeout) - now\n\n    for i = 1, #KEYS do\n      redis.call('pexpire', KEYS[i], ttl)\n    end\n  end\n\nend\n",
+		"refs.lua": "local settings_key = KEYS[1]\nlocal job_weights_key = KEYS[2]\nlocal job_expirations_key = KEYS[3]\nlocal job_clients_key = KEYS[4]\nlocal client_running_key = KEYS[5]\nlocal client_num_queued_key = KEYS[6]\nlocal client_last_registered_key = KEYS[7]\nlocal client_last_seen_key = KEYS[8]\n\nlocal now = tonumber(ARGV[1])\nlocal client = ARGV[2]\n\nlocal num_static_argv = 2\n",
+		"register.lua": "local index = ARGV[num_static_argv + 1]\nlocal weight = tonumber(ARGV[num_static_argv + 2])\nlocal expiration = tonumber(ARGV[num_static_argv + 3])\n\nlocal state = process_tick(now, false)\nlocal capacity = state['capacity']\nlocal reservoir = state['reservoir']\n\nlocal settings = redis.call('hmget', settings_key,\n  'nextRequest',\n  'minTime',\n  'groupTimeout'\n)\nlocal nextRequest = tonumber(settings[1])\nlocal minTime = tonumber(settings[2])\nlocal groupTimeout = tonumber(settings[3])\n\nif conditions_check(capacity, weight) then\n\n  redis.call('hincrby', settings_key, 'running', weight)\n  redis.call('hset', job_weights_key, index, weight)\n  if expiration ~= nil then\n    redis.call('zadd', job_expirations_key, now + expiration, index)\n  end\n  redis.call('hset', job_clients_key, index, client)\n  redis.call('zincrby', client_running_key, weight, client)\n  redis.call('hincrby', client_num_queued_key, client, -1)\n  redis.call('zadd', client_last_registered_key, now, client)\n\n  local wait = math.max(nextRequest - now, 0)\n  local newNextRequest = now + wait + minTime\n\n  if reservoir == nil then\n    redis.call('hset', settings_key,\n      'nextRequest', newNextRequest\n    )\n  else\n    reservoir = reservoir - weight\n    redis.call('hmset', settings_key,\n      'reservoir', reservoir,\n      'nextRequest', newNextRequest\n    )\n  end\n\n  refresh_expiration(now, newNextRequest, groupTimeout)\n\n  return {true, wait, reservoir}\n\nelse\n  return {false}\nend\n",
+		"register_client.lua": "local queued = tonumber(ARGV[num_static_argv + 1])\n\n-- Could have been re-registered concurrently\nif not redis.call('zscore', client_last_seen_key, client) then\n  redis.call('zadd', client_running_key, 0, client)\n  redis.call('hset', client_num_queued_key, client, queued)\n  redis.call('zadd', client_last_registered_key, 0, client)\nend\n\nredis.call('zadd', client_last_seen_key, now, client)\n\nreturn {}\n",
+		"running.lua": "return process_tick(now, false)['running']\n",
+		"submit.lua": "local queueLength = tonumber(ARGV[num_static_argv + 1])\nlocal weight = tonumber(ARGV[num_static_argv + 2])\n\nlocal capacity = process_tick(now, false)['capacity']\n\nlocal settings = redis.call('hmget', settings_key,\n  'id',\n  'maxConcurrent',\n  'highWater',\n  'nextRequest',\n  'strategy',\n  'unblockTime',\n  'penalty',\n  'minTime',\n  'groupTimeout'\n)\nlocal id = settings[1]\nlocal maxConcurrent = tonumber(settings[2])\nlocal highWater = tonumber(settings[3])\nlocal nextRequest = tonumber(settings[4])\nlocal strategy = tonumber(settings[5])\nlocal unblockTime = tonumber(settings[6])\nlocal penalty = tonumber(settings[7])\nlocal minTime = tonumber(settings[8])\nlocal groupTimeout = tonumber(settings[9])\n\nif maxConcurrent ~= nil and weight > maxConcurrent then\n  return redis.error_reply('OVERWEIGHT:'..weight..':'..maxConcurrent)\nend\n\nlocal reachedHWM = (highWater ~= nil and queueLength == highWater\n  and not (\n    conditions_check(capacity, weight)\n    and nextRequest - now <= 0\n  )\n)\n\nlocal blocked = strategy == 3 and (reachedHWM or unblockTime >= now)\n\nif blocked then\n  local computedPenalty = penalty\n  if computedPenalty == nil then\n    if minTime == 0 then\n      computedPenalty = 5000\n    else\n      computedPenalty = 15 * minTime\n    end\n  end\n\n  local newNextRequest = now + computedPenalty + minTime\n\n  redis.call('hmset', settings_key,\n    'unblockTime', now + computedPenalty,\n    'nextRequest', newNextRequest\n  )\n\n  local clients_queued_reset = redis.call('hkeys', client_num_queued_key)\n  local queued_reset = {}\n  for i = 1, #clients_queued_reset do\n    table.insert(queued_reset, clients_queued_reset[i])\n    table.insert(queued_reset, 0)\n  end\n  redis.call('hmset', client_num_queued_key, unpack(queued_reset))\n\n  redis.call('publish', 'b_'..id, 'blocked:')\n\n  refresh_expiration(now, newNextRequest, groupTimeout)\nend\n\nif not blocked and not reachedHWM then\n  redis.call('hincrby', client_num_queued_key, client, 1)\nend\n\nreturn {reachedHWM, blocked, strategy}\n",
+		"update_settings.lua": "local args = {'hmset', settings_key}\n\nfor i = num_static_argv + 1, #ARGV do\n  table.insert(args, ARGV[i])\nend\n\nredis.call(unpack(args))\n\nprocess_tick(now, true)\n\nlocal groupTimeout = tonumber(redis.call('hget', settings_key, 'groupTimeout'))\nrefresh_expiration(0, 0, groupTimeout)\n\nreturn {}\n",
+		"validate_client.lua": "if not redis.call('zscore', client_last_seen_key, client) then\n  return redis.error_reply('UNKNOWN_CLIENT')\nend\n\nredis.call('zadd', client_last_seen_key, now, client)\n",
+		"validate_keys.lua": "if not (redis.call('exists', settings_key) == 1) then\n  return redis.error_reply('SETTINGS_KEY_NOT_FOUND')\nend\n"
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Scripts.js
+var require_Scripts = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var headers, lua = require_lua(), templates;
+	headers = {
+		refs: lua["refs.lua"],
+		validate_keys: lua["validate_keys.lua"],
+		validate_client: lua["validate_client.lua"],
+		refresh_expiration: lua["refresh_expiration.lua"],
+		process_tick: lua["process_tick.lua"],
+		conditions_check: lua["conditions_check.lua"],
+		get_time: lua["get_time.lua"]
+	};
+	exports.allKeys = function(id) {
+		return [
+			`b_${id}_settings`,
+			`b_${id}_job_weights`,
+			`b_${id}_job_expirations`,
+			`b_${id}_job_clients`,
+			`b_${id}_client_running`,
+			`b_${id}_client_num_queued`,
+			`b_${id}_client_last_registered`,
+			`b_${id}_client_last_seen`
+		];
+	};
+	templates = {
+		init: {
+			keys: exports.allKeys,
+			headers: ["process_tick"],
+			refresh_expiration: true,
+			code: lua["init.lua"]
+		},
+		group_check: {
+			keys: exports.allKeys,
+			headers: [],
+			refresh_expiration: false,
+			code: lua["group_check.lua"]
+		},
+		register_client: {
+			keys: exports.allKeys,
+			headers: ["validate_keys"],
+			refresh_expiration: false,
+			code: lua["register_client.lua"]
+		},
+		blacklist_client: {
+			keys: exports.allKeys,
+			headers: ["validate_keys", "validate_client"],
+			refresh_expiration: false,
+			code: lua["blacklist_client.lua"]
+		},
+		heartbeat: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: false,
+			code: lua["heartbeat.lua"]
+		},
+		update_settings: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: true,
+			code: lua["update_settings.lua"]
+		},
+		running: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: false,
+			code: lua["running.lua"]
+		},
+		queued: {
+			keys: exports.allKeys,
+			headers: ["validate_keys", "validate_client"],
+			refresh_expiration: false,
+			code: lua["queued.lua"]
+		},
+		done: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: false,
+			code: lua["done.lua"]
+		},
+		check: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick",
+				"conditions_check"
+			],
+			refresh_expiration: false,
+			code: lua["check.lua"]
+		},
+		submit: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick",
+				"conditions_check"
+			],
+			refresh_expiration: true,
+			code: lua["submit.lua"]
+		},
+		register: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick",
+				"conditions_check"
+			],
+			refresh_expiration: true,
+			code: lua["register.lua"]
+		},
+		free: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: true,
+			code: lua["free.lua"]
+		},
+		current_reservoir: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: false,
+			code: lua["current_reservoir.lua"]
+		},
+		increment_reservoir: {
+			keys: exports.allKeys,
+			headers: [
+				"validate_keys",
+				"validate_client",
+				"process_tick"
+			],
+			refresh_expiration: true,
+			code: lua["increment_reservoir.lua"]
+		}
+	};
+	exports.names = Object.keys(templates);
+	exports.keys = function(name, id) {
+		return templates[name].keys(id);
+	};
+	exports.payload = function(name) {
+		var template = templates[name];
+		return Array.prototype.concat(headers.refs, template.headers.map(function(h) {
+			return headers[h];
+		}), template.refresh_expiration ? headers.refresh_expiration : "", template.code).join("\n");
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/RedisConnection.js
+var require_RedisConnection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var Events, RedisConnection, Scripts, parser = require_parser();
+	Events = require_Events();
+	Scripts = require_Scripts();
+	RedisConnection = function() {
+		class RedisConnection {
+			constructor(options = {}) {
+				parser.load(options, this.defaults, this);
+				if (this.Redis == null) this.Redis = eval("require")("redis");
+				if (this.Events == null) this.Events = new Events(this);
+				this.terminated = false;
+				if (this.client == null) this.client = this.Redis.createClient(this.clientOptions);
+				this.subscriber = this.client.duplicate();
+				this.limiters = {};
+				this.shas = {};
+				this.ready = this.Promise.all([this._setup(this.client, false), this._setup(this.subscriber, true)]).then(() => {
+					return this._loadScripts();
+				}).then(() => {
+					return {
+						client: this.client,
+						subscriber: this.subscriber
+					};
+				});
+			}
+			_setup(client, sub) {
+				client.setMaxListeners(0);
+				return new this.Promise((resolve, reject) => {
+					client.on("error", (e) => {
+						return this.Events.trigger("error", e);
+					});
+					if (sub) client.on("message", (channel, message) => {
+						var ref;
+						return (ref = this.limiters[channel]) != null ? ref._store.onMessage(channel, message) : void 0;
+					});
+					if (client.ready) return resolve();
+					else return client.once("ready", resolve);
+				});
+			}
+			_loadScript(name) {
+				return new this.Promise((resolve, reject) => {
+					var payload = Scripts.payload(name);
+					return this.client.multi([[
+						"script",
+						"load",
+						payload
+					]]).exec((err, replies) => {
+						if (err != null) return reject(err);
+						this.shas[name] = replies[0];
+						return resolve(replies[0]);
+					});
+				});
+			}
+			_loadScripts() {
+				return this.Promise.all(Scripts.names.map((k) => {
+					return this._loadScript(k);
+				}));
+			}
+			__runCommand__(cmd) {
+				var _this = this;
+				return _asyncToGenerator(function* () {
+					yield _this.ready;
+					return new _this.Promise((resolve, reject) => {
+						return _this.client.multi([cmd]).exec_atomic(function(err, replies) {
+							if (err != null) return reject(err);
+							else return resolve(replies[0]);
+						});
+					});
+				})();
+			}
+			__addLimiter__(instance) {
+				return this.Promise.all([instance.channel(), instance.channel_client()].map((channel) => {
+					return new this.Promise((resolve, reject) => {
+						var handler = (chan) => {
+							if (chan === channel) {
+								this.subscriber.removeListener("subscribe", handler);
+								this.limiters[channel] = instance;
+								return resolve();
+							}
+						};
+						this.subscriber.on("subscribe", handler);
+						return this.subscriber.subscribe(channel);
+					});
+				}));
+			}
+			__removeLimiter__(instance) {
+				var _this2 = this;
+				return this.Promise.all([instance.channel(), instance.channel_client()].map(/* @__PURE__ */ function() {
+					var _ref = _asyncToGenerator(function* (channel) {
+						if (!_this2.terminated) yield new _this2.Promise((resolve, reject) => {
+							return _this2.subscriber.unsubscribe(channel, function(err, chan) {
+								if (err != null) return reject(err);
+								if (chan === channel) return resolve();
+							});
+						});
+						return delete _this2.limiters[channel];
+					});
+					return function(_x) {
+						return _ref.apply(this, arguments);
+					};
+				}()));
+			}
+			__scriptArgs__(name, id, args, cb) {
+				var keys = Scripts.keys(name, id);
+				return [this.shas[name], keys.length].concat(keys, args, cb);
+			}
+			__scriptFn__(name) {
+				return this.client.evalsha.bind(this.client);
+			}
+			disconnect(flush = true) {
+				var i, k, len, ref = Object.keys(this.limiters);
+				for (i = 0, len = ref.length; i < len; i++) {
+					k = ref[i];
+					clearInterval(this.limiters[k]._store.heartbeat);
+				}
+				this.limiters = {};
+				this.terminated = true;
+				this.client.end(flush);
+				this.subscriber.end(flush);
+				return this.Promise.resolve();
+			}
+		}
+		RedisConnection.prototype.datastore = "redis";
+		RedisConnection.prototype.defaults = {
+			Redis: null,
+			clientOptions: {},
+			client: null,
+			Promise,
+			Events: null
+		};
+		return RedisConnection;
+	}.call(void 0);
+	module.exports = RedisConnection;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/IORedisConnection.js
+var require_IORedisConnection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _slicedToArray(arr, i) {
+		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+	}
+	function _nonIterableRest() {
+		throw new TypeError("Invalid attempt to destructure non-iterable instance");
+	}
+	function _iterableToArrayLimit(arr, i) {
+		var _arr = [];
+		var _n = true;
+		var _d = false;
+		var _e = void 0;
+		try {
+			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+				_arr.push(_s.value);
+				if (i && _arr.length === i) break;
+			}
+		} catch (err) {
+			_d = true;
+			_e = err;
+		} finally {
+			try {
+				if (!_n && _i["return"] != null) _i["return"]();
+			} finally {
+				if (_d) throw _e;
+			}
+		}
+		return _arr;
+	}
+	function _arrayWithHoles(arr) {
+		if (Array.isArray(arr)) return arr;
+	}
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var Events, IORedisConnection, Scripts, parser = require_parser();
+	Events = require_Events();
+	Scripts = require_Scripts();
+	IORedisConnection = function() {
+		class IORedisConnection {
+			constructor(options = {}) {
+				parser.load(options, this.defaults, this);
+				if (this.Redis == null) this.Redis = eval("require")("ioredis");
+				if (this.Events == null) this.Events = new Events(this);
+				this.terminated = false;
+				if (this.clusterNodes != null) {
+					this.client = new this.Redis.Cluster(this.clusterNodes, this.clientOptions);
+					this.subscriber = new this.Redis.Cluster(this.clusterNodes, this.clientOptions);
+				} else if (this.client != null && this.client.duplicate == null) this.subscriber = new this.Redis.Cluster(this.client.startupNodes, this.client.options);
+				else {
+					if (this.client == null) this.client = new this.Redis(this.clientOptions);
+					this.subscriber = this.client.duplicate();
+				}
+				this.limiters = {};
+				this.ready = this.Promise.all([this._setup(this.client, false), this._setup(this.subscriber, true)]).then(() => {
+					this._loadScripts();
+					return {
+						client: this.client,
+						subscriber: this.subscriber
+					};
+				});
+			}
+			_setup(client, sub) {
+				client.setMaxListeners(0);
+				return new this.Promise((resolve, reject) => {
+					client.on("error", (e) => {
+						return this.Events.trigger("error", e);
+					});
+					if (sub) client.on("message", (channel, message) => {
+						var ref;
+						return (ref = this.limiters[channel]) != null ? ref._store.onMessage(channel, message) : void 0;
+					});
+					if (client.status === "ready") return resolve();
+					else return client.once("ready", resolve);
+				});
+			}
+			_loadScripts() {
+				return Scripts.names.forEach((name) => {
+					return this.client.defineCommand(name, { lua: Scripts.payload(name) });
+				});
+			}
+			__runCommand__(cmd) {
+				var _this = this;
+				return _asyncToGenerator(function* () {
+					var _, deleted;
+					yield _this.ready;
+					var _ref2$ = _slicedToArray(_slicedToArray(yield _this.client.pipeline([cmd]).exec(), 1)[0], 2);
+					_ref2$[0];
+					deleted = _ref2$[1];
+					return deleted;
+				})();
+			}
+			__addLimiter__(instance) {
+				return this.Promise.all([instance.channel(), instance.channel_client()].map((channel) => {
+					return new this.Promise((resolve, reject) => {
+						return this.subscriber.subscribe(channel, () => {
+							this.limiters[channel] = instance;
+							return resolve();
+						});
+					});
+				}));
+			}
+			__removeLimiter__(instance) {
+				var _this2 = this;
+				return [instance.channel(), instance.channel_client()].forEach(/* @__PURE__ */ function() {
+					var _ref3 = _asyncToGenerator(function* (channel) {
+						if (!_this2.terminated) yield _this2.subscriber.unsubscribe(channel);
+						return delete _this2.limiters[channel];
+					});
+					return function(_x) {
+						return _ref3.apply(this, arguments);
+					};
+				}());
+			}
+			__scriptArgs__(name, id, args, cb) {
+				var keys = Scripts.keys(name, id);
+				return [keys.length].concat(keys, args, cb);
+			}
+			__scriptFn__(name) {
+				return this.client[name].bind(this.client);
+			}
+			disconnect(flush = true) {
+				var i, k, len, ref = Object.keys(this.limiters);
+				for (i = 0, len = ref.length; i < len; i++) {
+					k = ref[i];
+					clearInterval(this.limiters[k]._store.heartbeat);
+				}
+				this.limiters = {};
+				this.terminated = true;
+				if (flush) return this.Promise.all([this.client.quit(), this.subscriber.quit()]);
+				else {
+					this.client.disconnect();
+					this.subscriber.disconnect();
+					return this.Promise.resolve();
+				}
+			}
+		}
+		IORedisConnection.prototype.datastore = "ioredis";
+		IORedisConnection.prototype.defaults = {
+			Redis: null,
+			clientOptions: {},
+			clusterNodes: null,
+			client: null,
+			Promise,
+			Events: null
+		};
+		return IORedisConnection;
+	}.call(void 0);
+	module.exports = IORedisConnection;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/RedisDatastore.js
+var require_RedisDatastore = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _slicedToArray(arr, i) {
+		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+	}
+	function _nonIterableRest() {
+		throw new TypeError("Invalid attempt to destructure non-iterable instance");
+	}
+	function _iterableToArrayLimit(arr, i) {
+		var _arr = [];
+		var _n = true;
+		var _d = false;
+		var _e = void 0;
+		try {
+			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+				_arr.push(_s.value);
+				if (i && _arr.length === i) break;
+			}
+		} catch (err) {
+			_d = true;
+			_e = err;
+		} finally {
+			try {
+				if (!_n && _i["return"] != null) _i["return"]();
+			} finally {
+				if (_d) throw _e;
+			}
+		}
+		return _arr;
+	}
+	function _arrayWithHoles(arr) {
+		if (Array.isArray(arr)) return arr;
+	}
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var BottleneckError, IORedisConnection, RedisConnection, RedisDatastore, parser = require_parser();
+	BottleneckError = require_BottleneckError();
+	RedisConnection = require_RedisConnection();
+	IORedisConnection = require_IORedisConnection();
+	RedisDatastore = class RedisDatastore {
+		constructor(instance, storeOptions, storeInstanceOptions) {
+			this.instance = instance;
+			this.storeOptions = storeOptions;
+			this.originalId = this.instance.id;
+			this.clientId = this.instance._randomIndex();
+			parser.load(storeInstanceOptions, storeInstanceOptions, this);
+			this.clients = {};
+			this.capacityPriorityCounters = {};
+			this.sharedConnection = this.connection != null;
+			if (this.connection == null) this.connection = this.instance.datastore === "redis" ? new RedisConnection({
+				Redis: this.Redis,
+				clientOptions: this.clientOptions,
+				Promise: this.Promise,
+				Events: this.instance.Events
+			}) : this.instance.datastore === "ioredis" ? new IORedisConnection({
+				Redis: this.Redis,
+				clientOptions: this.clientOptions,
+				clusterNodes: this.clusterNodes,
+				Promise: this.Promise,
+				Events: this.instance.Events
+			}) : void 0;
+			this.instance.connection = this.connection;
+			this.instance.datastore = this.connection.datastore;
+			this.ready = this.connection.ready.then((clients) => {
+				this.clients = clients;
+				return this.runScript("init", this.prepareInitSettings(this.clearDatastore));
+			}).then(() => {
+				return this.connection.__addLimiter__(this.instance);
+			}).then(() => {
+				return this.runScript("register_client", [this.instance.queued()]);
+			}).then(() => {
+				var base;
+				if (typeof (base = this.heartbeat = setInterval(() => {
+					return this.runScript("heartbeat", []).catch((e) => {
+						return this.instance.Events.trigger("error", e);
+					});
+				}, this.heartbeatInterval)).unref === "function") base.unref();
+				return this.clients;
+			});
+		}
+		__publish__(message) {
+			var _this = this;
+			return _asyncToGenerator(function* () {
+				return (yield _this.ready).client.publish(_this.instance.channel(), `message:${message.toString()}`);
+			})();
+		}
+		onMessage(channel, message) {
+			var _this2 = this;
+			return _asyncToGenerator(function* () {
+				var capacity, counter, data, drained, e, newCapacity, pos, priorityClient, rawCapacity, type;
+				try {
+					pos = message.indexOf(":");
+					var _ref2 = [message.slice(0, pos), message.slice(pos + 1)];
+					type = _ref2[0];
+					data = _ref2[1];
+					if (type === "capacity") return yield _this2.instance._drainAll(data.length > 0 ? ~~data : void 0);
+					else if (type === "capacity-priority") {
+						var _data$split2 = _slicedToArray(data.split(":"), 3);
+						rawCapacity = _data$split2[0];
+						priorityClient = _data$split2[1];
+						counter = _data$split2[2];
+						capacity = rawCapacity.length > 0 ? ~~rawCapacity : void 0;
+						if (priorityClient === _this2.clientId) {
+							drained = yield _this2.instance._drainAll(capacity);
+							newCapacity = capacity != null ? capacity - (drained || 0) : "";
+							return yield _this2.clients.client.publish(_this2.instance.channel(), `capacity-priority:${newCapacity}::${counter}`);
+						} else if (priorityClient === "") {
+							clearTimeout(_this2.capacityPriorityCounters[counter]);
+							delete _this2.capacityPriorityCounters[counter];
+							return _this2.instance._drainAll(capacity);
+						} else return _this2.capacityPriorityCounters[counter] = setTimeout(/* @__PURE__ */ _asyncToGenerator(function* () {
+							var e;
+							try {
+								delete _this2.capacityPriorityCounters[counter];
+								yield _this2.runScript("blacklist_client", [priorityClient]);
+								return yield _this2.instance._drainAll(capacity);
+							} catch (error) {
+								e = error;
+								return _this2.instance.Events.trigger("error", e);
+							}
+						}), 1e3);
+					} else if (type === "message") return _this2.instance.Events.trigger("message", data);
+					else if (type === "blocked") return yield _this2.instance._dropAllQueued();
+				} catch (error) {
+					e = error;
+					return _this2.instance.Events.trigger("error", e);
+				}
+			})();
+		}
+		__disconnect__(flush) {
+			clearInterval(this.heartbeat);
+			if (this.sharedConnection) return this.connection.__removeLimiter__(this.instance);
+			else return this.connection.disconnect(flush);
+		}
+		runScript(name, args) {
+			var _this3 = this;
+			return _asyncToGenerator(function* () {
+				if (!(name === "init" || name === "register_client")) yield _this3.ready;
+				return new _this3.Promise((resolve, reject) => {
+					var all_args = [Date.now(), _this3.clientId].concat(args), arr;
+					_this3.instance.Events.trigger("debug", `Calling Redis script: ${name}.lua`, all_args);
+					arr = _this3.connection.__scriptArgs__(name, _this3.originalId, all_args, function(err, replies) {
+						if (err != null) return reject(err);
+						return resolve(replies);
+					});
+					return _this3.connection.__scriptFn__(name)(...arr);
+				}).catch((e) => {
+					if (e.message === "SETTINGS_KEY_NOT_FOUND") if (name === "heartbeat") return _this3.Promise.resolve();
+					else return _this3.runScript("init", _this3.prepareInitSettings(false)).then(() => {
+						return _this3.runScript(name, args);
+					});
+					else if (e.message === "UNKNOWN_CLIENT") return _this3.runScript("register_client", [_this3.instance.queued()]).then(() => {
+						return _this3.runScript(name, args);
+					});
+					else return _this3.Promise.reject(e);
+				});
+			})();
+		}
+		prepareArray(arr) {
+			var i, len, results = [], x;
+			for (i = 0, len = arr.length; i < len; i++) {
+				x = arr[i];
+				results.push(x != null ? x.toString() : "");
+			}
+			return results;
+		}
+		prepareObject(obj) {
+			var arr = [], k, v;
+			for (k in obj) {
+				v = obj[k];
+				arr.push(k, v != null ? v.toString() : "");
+			}
+			return arr;
+		}
+		prepareInitSettings(clear) {
+			var args = this.prepareObject(Object.assign({}, this.storeOptions, {
+				id: this.originalId,
+				version: this.instance.version,
+				groupTimeout: this.timeout,
+				clientTimeout: this.clientTimeout
+			}));
+			args.unshift(clear ? 1 : 0, this.instance.version);
+			return args;
+		}
+		convertBool(b) {
+			return !!b;
+		}
+		__updateSettings__(options) {
+			var _this4 = this;
+			return _asyncToGenerator(function* () {
+				yield _this4.runScript("update_settings", _this4.prepareObject(options));
+				return parser.overwrite(options, options, _this4.storeOptions);
+			})();
+		}
+		__running__() {
+			return this.runScript("running", []);
+		}
+		__queued__() {
+			return this.runScript("queued", []);
+		}
+		__done__() {
+			return this.runScript("done", []);
+		}
+		__groupCheck__() {
+			var _this5 = this;
+			return _asyncToGenerator(function* () {
+				return _this5.convertBool(yield _this5.runScript("group_check", []));
+			})();
+		}
+		__incrementReservoir__(incr) {
+			return this.runScript("increment_reservoir", [incr]);
+		}
+		__currentReservoir__() {
+			return this.runScript("current_reservoir", []);
+		}
+		__check__(weight) {
+			var _this6 = this;
+			return _asyncToGenerator(function* () {
+				return _this6.convertBool(yield _this6.runScript("check", _this6.prepareArray([weight])));
+			})();
+		}
+		__register__(index, weight, expiration) {
+			var _this7 = this;
+			return _asyncToGenerator(function* () {
+				var reservoir, success, wait;
+				var _ref5 = _slicedToArray(yield _this7.runScript("register", _this7.prepareArray([
+					index,
+					weight,
+					expiration
+				])), 3);
+				success = _ref5[0];
+				wait = _ref5[1];
+				reservoir = _ref5[2];
+				return {
+					success: _this7.convertBool(success),
+					wait,
+					reservoir
+				};
+			})();
+		}
+		__submit__(queueLength, weight) {
+			var _this8 = this;
+			return _asyncToGenerator(function* () {
+				var blocked, e, maxConcurrent, reachedHWM, strategy;
+				try {
+					var _ref7 = _slicedToArray(yield _this8.runScript("submit", _this8.prepareArray([queueLength, weight])), 3);
+					reachedHWM = _ref7[0];
+					blocked = _ref7[1];
+					strategy = _ref7[2];
+					return {
+						reachedHWM: _this8.convertBool(reachedHWM),
+						blocked: _this8.convertBool(blocked),
+						strategy
+					};
+				} catch (error) {
+					e = error;
+					if (e.message.indexOf("OVERWEIGHT") === 0) {
+						var _e$message$split2 = _slicedToArray(e.message.split(":"), 3);
+						_e$message$split2[0];
+						weight = _e$message$split2[1];
+						maxConcurrent = _e$message$split2[2];
+						throw new BottleneckError(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${maxConcurrent}`);
+					} else throw e;
+				}
+			})();
+		}
+		__free__(index, weight) {
+			var _this9 = this;
+			return _asyncToGenerator(function* () {
+				return { running: yield _this9.runScript("free", _this9.prepareArray([index])) };
+			})();
+		}
+	};
+	module.exports = RedisDatastore;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/States.js
+var require_States = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var BottleneckError = require_BottleneckError();
+	module.exports = class States {
+		constructor(status1) {
+			this.status = status1;
+			this._jobs = {};
+			this.counts = this.status.map(function() {
+				return 0;
+			});
+		}
+		next(id) {
+			var current = this._jobs[id], next = current + 1;
+			if (current != null && next < this.status.length) {
+				this.counts[current]--;
+				this.counts[next]++;
+				return this._jobs[id]++;
+			} else if (current != null) {
+				this.counts[current]--;
+				return delete this._jobs[id];
+			}
+		}
+		start(id) {
+			var initial = 0;
+			this._jobs[id] = initial;
+			return this.counts[initial]++;
+		}
+		remove(id) {
+			var current = this._jobs[id];
+			if (current != null) {
+				this.counts[current]--;
+				delete this._jobs[id];
+			}
+			return current != null;
+		}
+		jobStatus(id) {
+			var ref;
+			return (ref = this.status[this._jobs[id]]) != null ? ref : null;
+		}
+		statusJobs(status) {
+			var k, pos, ref, results, v;
+			if (status != null) {
+				pos = this.status.indexOf(status);
+				if (pos < 0) throw new BottleneckError(`status must be one of ${this.status.join(", ")}`);
+				ref = this._jobs;
+				results = [];
+				for (k in ref) {
+					v = ref[k];
+					if (v === pos) results.push(k);
+				}
+				return results;
+			} else return Object.keys(this._jobs);
+		}
+		statusCounts() {
+			return this.counts.reduce((acc, v, i) => {
+				acc[this.status[i]] = v;
+				return acc;
+			}, {});
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Sync.js
+var require_Sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var DLList = require_DLList();
+	module.exports = class Sync {
+		constructor(name, Promise) {
+			this.schedule = this.schedule.bind(this);
+			this.name = name;
+			this.Promise = Promise;
+			this._running = 0;
+			this._queue = new DLList();
+		}
+		isEmpty() {
+			return this._queue.length === 0;
+		}
+		_tryToRun() {
+			var _this = this;
+			return _asyncToGenerator(function* () {
+				var args, cb, error, reject, resolve, returned, task;
+				if (_this._running < 1 && _this._queue.length > 0) {
+					_this._running++;
+					var _this$_queue$shift = _this._queue.shift();
+					task = _this$_queue$shift.task;
+					args = _this$_queue$shift.args;
+					resolve = _this$_queue$shift.resolve;
+					reject = _this$_queue$shift.reject;
+					cb = yield _asyncToGenerator(function* () {
+						try {
+							returned = yield task(...args);
+							return function() {
+								return resolve(returned);
+							};
+						} catch (error1) {
+							error = error1;
+							return function() {
+								return reject(error);
+							};
+						}
+					})();
+					_this._running--;
+					_this._tryToRun();
+					return cb();
+				}
+			})();
+		}
+		schedule(task, ...args) {
+			var promise, reject, resolve = reject = null;
+			promise = new this.Promise(function(_resolve, _reject) {
+				resolve = _resolve;
+				return reject = _reject;
+			});
+			this._queue.push({
+				task,
+				args,
+				resolve,
+				reject
+			});
+			this._tryToRun();
+			return promise;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/version.json
+var require_version = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = { "version": "2.19.5" };
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Group.js
+var require_Group = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _slicedToArray(arr, i) {
+		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+	}
+	function _nonIterableRest() {
+		throw new TypeError("Invalid attempt to destructure non-iterable instance");
+	}
+	function _iterableToArrayLimit(arr, i) {
+		var _arr = [];
+		var _n = true;
+		var _d = false;
+		var _e = void 0;
+		try {
+			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+				_arr.push(_s.value);
+				if (i && _arr.length === i) break;
+			}
+		} catch (err) {
+			_d = true;
+			_e = err;
+		} finally {
+			try {
+				if (!_n && _i["return"] != null) _i["return"]();
+			} finally {
+				if (_d) throw _e;
+			}
+		}
+		return _arr;
+	}
+	function _arrayWithHoles(arr) {
+		if (Array.isArray(arr)) return arr;
+	}
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var Events, Group, IORedisConnection, RedisConnection, Scripts, parser = require_parser();
+	Events = require_Events();
+	RedisConnection = require_RedisConnection();
+	IORedisConnection = require_IORedisConnection();
+	Scripts = require_Scripts();
+	Group = function() {
+		class Group {
+			constructor(limiterOptions = {}) {
+				this.deleteKey = this.deleteKey.bind(this);
+				this.limiterOptions = limiterOptions;
+				parser.load(this.limiterOptions, this.defaults, this);
+				this.Events = new Events(this);
+				this.instances = {};
+				this.Bottleneck = require_Bottleneck();
+				this._startAutoCleanup();
+				this.sharedConnection = this.connection != null;
+				if (this.connection == null) {
+					if (this.limiterOptions.datastore === "redis") this.connection = new RedisConnection(Object.assign({}, this.limiterOptions, { Events: this.Events }));
+					else if (this.limiterOptions.datastore === "ioredis") this.connection = new IORedisConnection(Object.assign({}, this.limiterOptions, { Events: this.Events }));
+				}
+			}
+			key(key = "") {
+				var ref;
+				return (ref = this.instances[key]) != null ? ref : (() => {
+					var limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, {
+						id: `${this.id}-${key}`,
+						timeout: this.timeout,
+						connection: this.connection
+					}));
+					this.Events.trigger("created", limiter, key);
+					return limiter;
+				})();
+			}
+			deleteKey(key = "") {
+				var _this = this;
+				return _asyncToGenerator(function* () {
+					var deleted, instance = _this.instances[key];
+					if (_this.connection) deleted = yield _this.connection.__runCommand__(["del", ...Scripts.allKeys(`${_this.id}-${key}`)]);
+					if (instance != null) {
+						delete _this.instances[key];
+						yield instance.disconnect();
+					}
+					return instance != null || deleted > 0;
+				})();
+			}
+			limiters() {
+				var k, ref = this.instances, results = [], v;
+				for (k in ref) {
+					v = ref[k];
+					results.push({
+						key: k,
+						limiter: v
+					});
+				}
+				return results;
+			}
+			keys() {
+				return Object.keys(this.instances);
+			}
+			clusterKeys() {
+				var _this2 = this;
+				return _asyncToGenerator(function* () {
+					var cursor, end, found, i, k, keys, len, next, start;
+					if (_this2.connection == null) return _this2.Promise.resolve(_this2.keys());
+					keys = [];
+					cursor = null;
+					start = `b_${_this2.id}-`.length;
+					end = 9;
+					while (cursor !== 0) {
+						var _ref2 = _slicedToArray(yield _this2.connection.__runCommand__([
+							"scan",
+							cursor != null ? cursor : 0,
+							"match",
+							`b_${_this2.id}-*_settings`,
+							"count",
+							1e4
+						]), 2);
+						next = _ref2[0];
+						found = _ref2[1];
+						cursor = ~~next;
+						for (i = 0, len = found.length; i < len; i++) {
+							k = found[i];
+							keys.push(k.slice(start, -end));
+						}
+					}
+					return keys;
+				})();
+			}
+			_startAutoCleanup() {
+				var _this3 = this;
+				var base;
+				clearInterval(this.interval);
+				return typeof (base = this.interval = setInterval(/* @__PURE__ */ _asyncToGenerator(function* () {
+					var e, k, ref, results, time = Date.now(), v;
+					ref = _this3.instances;
+					results = [];
+					for (k in ref) {
+						v = ref[k];
+						try {
+							if (yield v._store.__groupCheck__(time)) results.push(_this3.deleteKey(k));
+							else results.push(void 0);
+						} catch (error) {
+							e = error;
+							results.push(v.Events.trigger("error", e));
+						}
+					}
+					return results;
+				}), this.timeout / 2)).unref === "function" ? base.unref() : void 0;
+			}
+			updateSettings(options = {}) {
+				parser.overwrite(options, this.defaults, this);
+				parser.overwrite(options, options, this.limiterOptions);
+				if (options.timeout != null) return this._startAutoCleanup();
+			}
+			disconnect(flush = true) {
+				var ref;
+				if (!this.sharedConnection) return (ref = this.connection) != null ? ref.disconnect(flush) : void 0;
+			}
+		}
+		Group.prototype.defaults = {
+			timeout: 1e3 * 60 * 5,
+			connection: null,
+			Promise,
+			id: "group-key"
+		};
+		return Group;
+	}.call(void 0);
+	module.exports = Group;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Batcher.js
+var require_Batcher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Batcher, Events, parser = require_parser();
+	Events = require_Events();
+	Batcher = function() {
+		class Batcher {
+			constructor(options = {}) {
+				this.options = options;
+				parser.load(this.options, this.defaults, this);
+				this.Events = new Events(this);
+				this._arr = [];
+				this._resetPromise();
+				this._lastFlush = Date.now();
+			}
+			_resetPromise() {
+				return this._promise = new this.Promise((res, rej) => {
+					return this._resolve = res;
+				});
+			}
+			_flush() {
+				clearTimeout(this._timeout);
+				this._lastFlush = Date.now();
+				this._resolve();
+				this.Events.trigger("batch", this._arr);
+				this._arr = [];
+				return this._resetPromise();
+			}
+			add(data) {
+				var ret;
+				this._arr.push(data);
+				ret = this._promise;
+				if (this._arr.length === this.maxSize) this._flush();
+				else if (this.maxTime != null && this._arr.length === 1) this._timeout = setTimeout(() => {
+					return this._flush();
+				}, this.maxTime);
+				return ret;
+			}
+		}
+		Batcher.prototype.defaults = {
+			maxTime: null,
+			maxSize: null,
+			Promise
+		};
+		return Batcher;
+	}.call(void 0);
+	module.exports = Batcher;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/Bottleneck.js
+var require_Bottleneck = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _slicedToArray(arr, i) {
+		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+	}
+	function _iterableToArrayLimit(arr, i) {
+		var _arr = [];
+		var _n = true;
+		var _d = false;
+		var _e = void 0;
+		try {
+			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+				_arr.push(_s.value);
+				if (i && _arr.length === i) break;
+			}
+		} catch (err) {
+			_d = true;
+			_e = err;
+		} finally {
+			try {
+				if (!_n && _i["return"] != null) _i["return"]();
+			} finally {
+				if (_d) throw _e;
+			}
+		}
+		return _arr;
+	}
+	function _toArray(arr) {
+		return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();
+	}
+	function _nonIterableRest() {
+		throw new TypeError("Invalid attempt to destructure non-iterable instance");
+	}
+	function _iterableToArray(iter) {
+		if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+	}
+	function _arrayWithHoles(arr) {
+		if (Array.isArray(arr)) return arr;
+	}
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+		try {
+			var info = gen[key](arg);
+			var value = info.value;
+		} catch (error) {
+			reject(error);
+			return;
+		}
+		if (info.done) resolve(value);
+		else Promise.resolve(value).then(_next, _throw);
+	}
+	function _asyncToGenerator(fn) {
+		return function() {
+			var self = this, args = arguments;
+			return new Promise(function(resolve, reject) {
+				var gen = fn.apply(self, args);
+				function _next(value) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+				}
+				function _throw(err) {
+					asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+				}
+				_next(void 0);
+			});
+		};
+	}
+	var Bottleneck, DEFAULT_PRIORITY, Events, Job, LocalDatastore, NUM_PRIORITIES, Queues, RedisDatastore, States, Sync, parser, splice = [].splice;
+	NUM_PRIORITIES = 10;
+	DEFAULT_PRIORITY = 5;
+	parser = require_parser();
+	Queues = require_Queues();
+	Job = require_Job();
+	LocalDatastore = require_LocalDatastore();
+	RedisDatastore = require_RedisDatastore();
+	Events = require_Events();
+	States = require_States();
+	Sync = require_Sync();
+	Bottleneck = function() {
+		class Bottleneck {
+			constructor(options = {}, ...invalid) {
+				var storeInstanceOptions, storeOptions;
+				this._addToQueue = this._addToQueue.bind(this);
+				this._validateOptions(options, invalid);
+				parser.load(options, this.instanceDefaults, this);
+				this._queues = new Queues(NUM_PRIORITIES);
+				this._scheduled = {};
+				this._states = new States([
+					"RECEIVED",
+					"QUEUED",
+					"RUNNING",
+					"EXECUTING"
+				].concat(this.trackDoneStatus ? ["DONE"] : []));
+				this._limiter = null;
+				this.Events = new Events(this);
+				this._submitLock = new Sync("submit", this.Promise);
+				this._registerLock = new Sync("register", this.Promise);
+				storeOptions = parser.load(options, this.storeDefaults, {});
+				this._store = function() {
+					if (this.datastore === "redis" || this.datastore === "ioredis" || this.connection != null) {
+						storeInstanceOptions = parser.load(options, this.redisStoreDefaults, {});
+						return new RedisDatastore(this, storeOptions, storeInstanceOptions);
+					} else if (this.datastore === "local") {
+						storeInstanceOptions = parser.load(options, this.localStoreDefaults, {});
+						return new LocalDatastore(this, storeOptions, storeInstanceOptions);
+					} else throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`);
+				}.call(this);
+				this._queues.on("leftzero", () => {
+					var ref;
+					return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0;
+				});
+				this._queues.on("zero", () => {
+					var ref;
+					return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0;
+				});
+			}
+			_validateOptions(options, invalid) {
+				if (!(options != null && typeof options === "object" && invalid.length === 0)) throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1.");
+			}
+			ready() {
+				return this._store.ready;
+			}
+			clients() {
+				return this._store.clients;
+			}
+			channel() {
+				return `b_${this.id}`;
+			}
+			channel_client() {
+				return `b_${this.id}_${this._store.clientId}`;
+			}
+			publish(message) {
+				return this._store.__publish__(message);
+			}
+			disconnect(flush = true) {
+				return this._store.__disconnect__(flush);
+			}
+			chain(_limiter) {
+				this._limiter = _limiter;
+				return this;
+			}
+			queued(priority) {
+				return this._queues.queued(priority);
+			}
+			clusterQueued() {
+				return this._store.__queued__();
+			}
+			empty() {
+				return this.queued() === 0 && this._submitLock.isEmpty();
+			}
+			running() {
+				return this._store.__running__();
+			}
+			done() {
+				return this._store.__done__();
+			}
+			jobStatus(id) {
+				return this._states.jobStatus(id);
+			}
+			jobs(status) {
+				return this._states.statusJobs(status);
+			}
+			counts() {
+				return this._states.statusCounts();
+			}
+			_randomIndex() {
+				return Math.random().toString(36).slice(2);
+			}
+			check(weight = 1) {
+				return this._store.__check__(weight);
+			}
+			_clearGlobalState(index) {
+				if (this._scheduled[index] != null) {
+					clearTimeout(this._scheduled[index].expiration);
+					delete this._scheduled[index];
+					return true;
+				} else return false;
+			}
+			_free(index, job, options, eventInfo) {
+				var _this = this;
+				return _asyncToGenerator(function* () {
+					var e, running;
+					try {
+						running = (yield _this._store.__free__(index, options.weight)).running;
+						_this.Events.trigger("debug", `Freed ${options.id}`, eventInfo);
+						if (running === 0 && _this.empty()) return _this.Events.trigger("idle");
+					} catch (error1) {
+						e = error1;
+						return _this.Events.trigger("error", e);
+					}
+				})();
+			}
+			_run(index, job, wait) {
+				var clearGlobalState, free, run;
+				job.doRun();
+				clearGlobalState = this._clearGlobalState.bind(this, index);
+				run = this._run.bind(this, index, job);
+				free = this._free.bind(this, index, job);
+				return this._scheduled[index] = {
+					timeout: setTimeout(() => {
+						return job.doExecute(this._limiter, clearGlobalState, run, free);
+					}, wait),
+					expiration: job.options.expiration != null ? setTimeout(function() {
+						return job.doExpire(clearGlobalState, run, free);
+					}, wait + job.options.expiration) : void 0,
+					job
+				};
+			}
+			_drainOne(capacity) {
+				return this._registerLock.schedule(() => {
+					var args, index, next, options, queue;
+					if (this.queued() === 0) return this.Promise.resolve(null);
+					queue = this._queues.getFirst();
+					var _next2 = next = queue.first();
+					options = _next2.options;
+					args = _next2.args;
+					if (capacity != null && options.weight > capacity) return this.Promise.resolve(null);
+					this.Events.trigger("debug", `Draining ${options.id}`, {
+						args,
+						options
+					});
+					index = this._randomIndex();
+					return this._store.__register__(index, options.weight, options.expiration).then(({ success, wait, reservoir }) => {
+						var empty;
+						this.Events.trigger("debug", `Drained ${options.id}`, {
+							success,
+							args,
+							options
+						});
+						if (success) {
+							queue.shift();
+							empty = this.empty();
+							if (empty) this.Events.trigger("empty");
+							if (reservoir === 0) this.Events.trigger("depleted", empty);
+							this._run(index, next, wait);
+							return this.Promise.resolve(options.weight);
+						} else return this.Promise.resolve(null);
+					});
+				});
+			}
+			_drainAll(capacity, total = 0) {
+				return this._drainOne(capacity).then((drained) => {
+					var newCapacity;
+					if (drained != null) {
+						newCapacity = capacity != null ? capacity - drained : capacity;
+						return this._drainAll(newCapacity, total + drained);
+					} else return this.Promise.resolve(total);
+				}).catch((e) => {
+					return this.Events.trigger("error", e);
+				});
+			}
+			_dropAllQueued(message) {
+				return this._queues.shiftAll(function(job) {
+					return job.doDrop({ message });
+				});
+			}
+			stop(options = {}) {
+				var done, waitForExecuting;
+				options = parser.load(options, this.stopDefaults);
+				waitForExecuting = (at) => {
+					var finished = () => {
+						var counts = this._states.counts;
+						return counts[0] + counts[1] + counts[2] + counts[3] === at;
+					};
+					return new this.Promise((resolve, reject) => {
+						if (finished()) return resolve();
+						else return this.on("done", () => {
+							if (finished()) {
+								this.removeAllListeners("done");
+								return resolve();
+							}
+						});
+					});
+				};
+				done = options.dropWaitingJobs ? (this._run = function(index, next) {
+					return next.doDrop({ message: options.dropErrorMessage });
+				}, this._drainOne = () => {
+					return this.Promise.resolve(null);
+				}, this._registerLock.schedule(() => {
+					return this._submitLock.schedule(() => {
+						var k, ref = this._scheduled, v;
+						for (k in ref) {
+							v = ref[k];
+							if (this.jobStatus(v.job.options.id) === "RUNNING") {
+								clearTimeout(v.timeout);
+								clearTimeout(v.expiration);
+								v.job.doDrop({ message: options.dropErrorMessage });
+							}
+						}
+						this._dropAllQueued(options.dropErrorMessage);
+						return waitForExecuting(0);
+					});
+				})) : this.schedule({
+					priority: NUM_PRIORITIES - 1,
+					weight: 0
+				}, () => {
+					return waitForExecuting(1);
+				});
+				this._receive = function(job) {
+					return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage));
+				};
+				this.stop = () => {
+					return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called"));
+				};
+				return done;
+			}
+			_addToQueue(job) {
+				var _this2 = this;
+				return _asyncToGenerator(function* () {
+					var args = job.args, blocked, error, options = job.options, reachedHWM, shifted, strategy;
+					try {
+						var _ref2 = yield _this2._store.__submit__(_this2.queued(), options.weight);
+						reachedHWM = _ref2.reachedHWM;
+						blocked = _ref2.blocked;
+						strategy = _ref2.strategy;
+					} catch (error1) {
+						error = error1;
+						_this2.Events.trigger("debug", `Could not queue ${options.id}`, {
+							args,
+							options,
+							error
+						});
+						job.doDrop({ error });
+						return false;
+					}
+					if (blocked) {
+						job.doDrop();
+						return true;
+					} else if (reachedHWM) {
+						shifted = strategy === Bottleneck.prototype.strategy.LEAK ? _this2._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? _this2._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0;
+						if (shifted != null) shifted.doDrop();
+						if (shifted == null || strategy === Bottleneck.prototype.strategy.OVERFLOW) {
+							if (shifted == null) job.doDrop();
+							return reachedHWM;
+						}
+					}
+					job.doQueue(reachedHWM, blocked);
+					_this2._queues.push(job);
+					yield _this2._drainAll();
+					return reachedHWM;
+				})();
+			}
+			_receive(job) {
+				if (this._states.jobStatus(job.options.id) != null) {
+					job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`));
+					return false;
+				} else {
+					job.doReceive();
+					return this._submitLock.schedule(this._addToQueue, job);
+				}
+			}
+			submit(...args) {
+				var cb, fn, job, options, ref, ref1, task;
+				if (typeof args[0] === "function") {
+					var _ref3, _ref4, _splice$call, _splice$call2;
+					ref = args, _ref3 = ref, _ref4 = _toArray(_ref3), fn = _ref4[0], args = _ref4.slice(1), _splice$call = splice.call(args, -1), _splice$call2 = _slicedToArray(_splice$call, 1), cb = _splice$call2[0];
+					options = parser.load({}, this.jobDefaults);
+				} else {
+					var _ref5, _ref6, _splice$call3, _splice$call4;
+					ref1 = args, _ref5 = ref1, _ref6 = _toArray(_ref5), options = _ref6[0], fn = _ref6[1], args = _ref6.slice(2), _splice$call3 = splice.call(args, -1), _splice$call4 = _slicedToArray(_splice$call3, 1), cb = _splice$call4[0];
+					options = parser.load(options, this.jobDefaults);
+				}
+				task = (...args) => {
+					return new this.Promise(function(resolve, reject) {
+						return fn(...args, function(...args) {
+							return (args[0] != null ? reject : resolve)(args);
+						});
+					});
+				};
+				job = new Job(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise);
+				job.promise.then(function(args) {
+					return typeof cb === "function" ? cb(...args) : void 0;
+				}).catch(function(args) {
+					if (Array.isArray(args)) return typeof cb === "function" ? cb(...args) : void 0;
+					else return typeof cb === "function" ? cb(args) : void 0;
+				});
+				return this._receive(job);
+			}
+			schedule(...args) {
+				var job, options, task;
+				if (typeof args[0] === "function") {
+					var _args2 = _toArray(args);
+					task = _args2[0];
+					args = _args2.slice(1);
+					options = {};
+				} else {
+					var _args4 = _toArray(args);
+					options = _args4[0];
+					task = _args4[1];
+					args = _args4.slice(2);
+				}
+				job = new Job(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise);
+				this._receive(job);
+				return job.promise;
+			}
+			wrap(fn) {
+				var schedule = this.schedule.bind(this), wrapped = function wrapped(...args) {
+					return schedule(fn.bind(this), ...args);
+				};
+				wrapped.withOptions = function(options, ...args) {
+					return schedule(options, fn, ...args);
+				};
+				return wrapped;
+			}
+			updateSettings(options = {}) {
+				var _this3 = this;
+				return _asyncToGenerator(function* () {
+					yield _this3._store.__updateSettings__(parser.overwrite(options, _this3.storeDefaults));
+					parser.overwrite(options, _this3.instanceDefaults, _this3);
+					return _this3;
+				})();
+			}
+			currentReservoir() {
+				return this._store.__currentReservoir__();
+			}
+			incrementReservoir(incr = 0) {
+				return this._store.__incrementReservoir__(incr);
+			}
+		}
+		Bottleneck.default = Bottleneck;
+		Bottleneck.Events = Events;
+		Bottleneck.version = Bottleneck.prototype.version = require_version().version;
+		Bottleneck.strategy = Bottleneck.prototype.strategy = {
+			LEAK: 1,
+			OVERFLOW: 2,
+			OVERFLOW_PRIORITY: 4,
+			BLOCK: 3
+		};
+		Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = require_BottleneckError();
+		Bottleneck.Group = Bottleneck.prototype.Group = require_Group();
+		Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require_RedisConnection();
+		Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require_IORedisConnection();
+		Bottleneck.Batcher = Bottleneck.prototype.Batcher = require_Batcher();
+		Bottleneck.prototype.jobDefaults = {
+			priority: DEFAULT_PRIORITY,
+			weight: 1,
+			expiration: null,
+			id: "<no-id>"
+		};
+		Bottleneck.prototype.storeDefaults = {
+			maxConcurrent: null,
+			minTime: 0,
+			highWater: null,
+			strategy: Bottleneck.prototype.strategy.LEAK,
+			penalty: null,
+			reservoir: null,
+			reservoirRefreshInterval: null,
+			reservoirRefreshAmount: null,
+			reservoirIncreaseInterval: null,
+			reservoirIncreaseAmount: null,
+			reservoirIncreaseMaximum: null
+		};
+		Bottleneck.prototype.localStoreDefaults = {
+			Promise,
+			timeout: null,
+			heartbeatInterval: 250
+		};
+		Bottleneck.prototype.redisStoreDefaults = {
+			Promise,
+			timeout: null,
+			heartbeatInterval: 5e3,
+			clientTimeout: 1e4,
+			Redis: null,
+			clientOptions: {},
+			clusterNodes: null,
+			clearDatastore: false,
+			connection: null
+		};
+		Bottleneck.prototype.instanceDefaults = {
+			datastore: "local",
+			connection: null,
+			id: "<no-id>",
+			rejectOnDrop: true,
+			trackDoneStatus: false,
+			Promise
+		};
+		Bottleneck.prototype.stopDefaults = {
+			enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.",
+			dropWaitingJobs: true,
+			dropErrorMessage: "This limiter has been stopped."
+		};
+		return Bottleneck;
+	}.call(void 0);
+	module.exports = Bottleneck;
+}));
+//#endregion
+//#region ../../node_modules/bottleneck/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_Bottleneck();
+}));
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/blockfrost-config.ts
+var import_lib = /* @__PURE__ */ __toESM(require_lib());
+const computeBlockfrostConfigIdentifier = ({ clientConfig: { baseUrl, projectId } }) => `${baseUrl}-${projectId}`;
+const getBlockfrostClient = memoize(({ clientConfig, rateLimiterConfig }) => {
+	const rateLimiter = new import_lib.default({
+		reservoir: rateLimiterConfig.size,
+		reservoirIncreaseAmount: rateLimiterConfig.increaseAmount,
+		reservoirIncreaseInterval: rateLimiterConfig.increaseInterval,
+		reservoirIncreaseMaximum: rateLimiterConfig.size
+	});
+	return new HttpClient({
+		baseUrl: buildUrl(["api", clientConfig.apiVersion], clientConfig.baseUrl),
+		requestInit: { headers: { ...clientConfig.projectId && { project_id: clientConfig.projectId } } }
+	}, { rateLimiter });
+}, computeBlockfrostConfigIdentifier);
+//#endregion
+//#region ../../packages/lib/ui-toolkit/src/design-system/atoms/icons/urls.ts
+const cardanoIconDataUrl = "data:image/png;base64,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";
+const bitcoinIconDataUrl = "data:image/png;base64,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";
+const Blockchains = {
+	Cardano: cardanoIconDataUrl,
+	Bitcoin: bitcoinIconDataUrl
+};
+//#endregion
+//#region ../../packages/module/cardano-provider-blockfrost/src/store/dependencies.ts
+const getNetworkInfoProvider = memoize((config, logger) => {
+	return new BlockfrostNetworkInfoProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAssetProvider = memoize((config, logger) => {
+	return new BlockfrostAssetProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAddressDiscoveryProvider = memoize((config, logger) => {
+	return new BlockfrostAddressDiscovery(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getInputResolverProvider = memoize((config, logger) => {
+	return new BlockfrostInputResolverProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getTokensProvider = memoize((config, logger) => {
+	return new BlockfrostTokensProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountActivityProvider = memoize((config, logger) => {
+	return new BlockfrostActivityProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountRewardsProvider = memoize((config, logger) => {
+	return new BlockfrostRewardsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountDelegationsProvider = memoize((config, logger) => {
+	return new BlockfrostDelegationsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountRegistrationsProvider = memoize((config, logger) => {
+	return new BlockfrostRegistrationsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountWithdrawalsProvider = memoize((config, logger) => {
+	return new BlockfrostWithdrawalsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getStakePoolProvider = memoize((config, logger) => {
+	return new BlockfrostStakePoolProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getUtxoProvider = memoize((config, logger) => {
+	return new BlockfrostUtxoProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getTxSubmitProvider = memoize((config, logger) => {
+	return new BlockfrostTxSubmitProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getTxEvaluationProvider = memoize((config, logger) => {
+	return new BlockfrostTxEvaluationProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getGovernanceProvider = memoize((config, logger) => {
+	return new BlockfrostGovernanceProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getBlockfrostConfig = (context, configs) => {
+	const config = configs[context.chainId.networkMagic];
+	if (!config) throw new Error(`Assertion failed: no blockfrost config found (${context.chainId.networkMagic}`);
+	return config;
+};
+const initializeDependencies = async ({ runtime: { config: { cardanoProvider: { blockfrostConfigs } } }, loadModules }, { logger }) => {
+	const bip32Ed25519 = (await loadModules("addons.bip32Ed25519"))[0];
+	const dependencies = {
+		blake2b: (await loadModules("addons.blake2b"))[0],
+		bip32Ed25519
+	};
+	return {
+		cardanoProvider: {
+			getTip: (context) => {
+				return from(getNetworkInfoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).ledgerTip().then(Ok).catch(Err));
+			},
+			getProtocolParameters: (context) => {
+				const provider = getNetworkInfoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				return defer(async () => provider.protocolParameters().then(Ok).catch(Err));
+			},
+			getEraSummaries: (context) => {
+				const provider = getNetworkInfoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				return defer(async () => provider.eraSummaries().then(Ok).catch(Err));
+			},
+			discoverAddresses: ({ xpub, accountIndex, thorough }, context) => {
+				const provider = getAddressDiscoveryProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				const account = new Bip32Account$1({
+					extendedAccountPublicKey: xpub,
+					chainId: context.chainId,
+					accountIndex
+				}, dependencies);
+				return provider.discover(account, { thorough }).pipe(map((result) => result.map((address) => toContractAddress(address, context.chainId.networkMagic))));
+			},
+			getTokenMetadata: ({ tokenId }, context) => {
+				if (tokenId === LOVELACE_TOKEN_ID) {
+					const ticker = getAdaTokenTickerByNetwork(cardanoNetworkMagicToNetworkType(context.chainId.networkMagic));
+					return of(Ok({
+						...LOVELACE_METADATA,
+						ticker,
+						image: Blockchains.Cardano
+					}));
+				}
+				const provider = getAssetProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				const assetId = Cardano.AssetId(tokenId);
+				return defer(async () => provider.getAsset({
+					assetId,
+					extraData: {
+						nftMetadata: true,
+						tokenMetadata: true
+					}
+				}).then((assetInfo) => Ok(toContractTokenMetadata(assetInfo))).catch(Err));
+			},
+			getTokens: (props, context) => {
+				return getTokensProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getTokens(props);
+			},
+			getAccountRewards: (props, context) => {
+				return getAccountRewardsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountRewards(props);
+			},
+			getAccountDelegations: (props, context) => {
+				return getAccountDelegationsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountDelegations(props);
+			},
+			getAccountRegistrations: (props, context) => {
+				return getAccountRegistrationsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountRegistrations(props);
+			},
+			getAccountWithdrawals: (props, context) => {
+				return getAccountWithdrawalsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountWithdrawals(props);
+			},
+			getRewardAccountInfo: (props, context) => {
+				return getAccountRewardsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getRewardAccountInfo(props);
+			},
+			getAccountUtxos: (props, context) => {
+				return getUtxoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountUtxos(props);
+			},
+			getUtxosAtAddress: (props, context) => {
+				return getUtxoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getUtxosAtAddress(props);
+			},
+			getAddressTransactionHistory: (props, context) => {
+				return getAccountActivityProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAddressTransactionHistory(props);
+			},
+			getTransactionDetails: (txId, context) => {
+				return getAccountActivityProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getTransactionDetails(txId);
+			},
+			resolveInput: (txIn, context) => {
+				const provider = getInputResolverProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				return defer(async () => provider.resolveInput(txIn).then(Ok).catch(Err));
+			},
+			submitTx: (props, context) => {
+				return from(getTxSubmitProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).submitTx(props).then((id) => Ok(Cardano.TransactionId(id))).catch(Err));
+			},
+			evaluateTx: (props, context) => {
+				return getTxEvaluationProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).evaluateTx(props);
+			},
+			getDReps: (context) => {
+				return getGovernanceProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getDReps();
+			}
+		},
+		cardanoStakePoolsProvider: {
+			getMetadata: (poolId, context) => {
+				return from(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getMetadata(poolId).then(Ok).catch(Err));
+			},
+			getNetworkData: (context) => {
+				return from(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getNetworkData().then(Ok).catch(Err));
+			},
+			getStakePool: (poolId, context) => {
+				return from(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getStakePool(poolId).then(Ok).catch(Err));
+			},
+			getStakePools: (context) => {
+				return from(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getStakePools().then(Ok).catch(Err));
+			}
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/cardano-provider-blockfrost/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+export { redux as default };