@panoptic-eng/sdk 1.0.0

package/dist/test/index.js

@@ -0,0 +1,1650 @@
+import * as React from "react";
+import { useEffect } from "react";
+import { WagmiProvider, useConnect } from "wagmi";
+import { exec, execSync, spawn } from "node:child_process";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/test/test-utils.ts
+/**
+* Converts an object of options to an array of command line arguments.
+*
+* @param options The options object.
+* @returns The command line arguments.
+*/
+function toArgs(obj, options = { casing: "kebab" }) {
+	const { casing } = options;
+	return Object.entries(obj).flatMap(([key, value]) => {
+		if (value === void 0) return [];
+		if (Array.isArray(value)) return [toFlagCase(key), value.join(",")];
+		if (typeof value === "object" && value !== null) return Object.entries(value).flatMap(([subKey, subValue]) => {
+			if (subValue === void 0) return [];
+			const flag$1 = toFlagCase(`${key}.${subKey}`, casing === "kebab" ? "-" : "_");
+			return [flag$1, Array.isArray(subValue) ? subValue.join(",") : subValue];
+		});
+		const flag = toFlagCase(key, casing === "kebab" ? "-" : "_");
+		if (value === false) return [flag, "false"];
+		if (value === true) return [flag];
+		const stringified = value.toString();
+		if (stringified === "") return [flag];
+		return [flag, stringified];
+	});
+}
+/** Converts to a --flag-case string. */
+function toFlagCase(str, separator = "-") {
+	const keys = [];
+	for (let i = 0; i < str.split(".").length; i++) {
+		const key = str.split(".")[i];
+		if (!key) continue;
+		keys.push(key.replace(/\s+/g, separator).replace(/([a-z])([A-Z])/g, `$1${separator}$2`).toLowerCase());
+	}
+	return `--${keys.join(".")}`;
+}
+const spawnAnvil = (args) => {
+	return new Promise((resolve, reject) => {
+		const subprocess = spawn(
+			"anvil",
+			toArgs({ ...args })
+			// [
+			//   `--fork-url`,
+			//   `https://eth-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_API_KEY}`,
+			//   `--chain-id`,
+			//   `31337`,
+			//   `-vvvvv`,
+			//   `--no-cors`,
+			//   `--fork-block-number`,
+			//   `23146780`,
+			// ]
+);
+		subprocess.stdout.on("data", (data) => {
+			process.stdout.write(data);
+			if (data.toString().includes("Listening on")) {
+				process.stdout.write(data);
+				console.log(data.toString());
+				resolve();
+			}
+		});
+		subprocess.stderr.on("data", (data) => {
+			process.stderr.write(data);
+		});
+		subprocess.on("exit", (code) => {
+			if (code !== 0) {
+				console.error(`Child process exited with code ${code}`);
+				reject(new Error(`Anvil process exited with code ${code}`));
+			}
+		});
+		subprocess.on("error", (err) => {
+			console.error("Failed to start child process:", err);
+			reject(err);
+		});
+	});
+};
+const killAnvilProcess = async (port) => {
+	try {
+		const data = execSync(`lsof -iTCP:${port} -sTCP:LISTEN -t`);
+		const pids = data.toString().split("\n").slice(0, -1);
+		console.debug(`Clearing ports: ${pids.join(", ")}`);
+		for (const pid of pids) exec(`kill -9 ${pid}`, (error) => {
+			if (error) console.error(`Error while killing ${pid}: ${error}`);
+		});
+	} catch (e) {
+		console.error("Cleanup error: ", e.toString());
+	}
+};
+const killAllAnvilProcesses = async () => {
+	try {
+		const data = execSync("lsof -c anvil -t");
+		const pids = data.toString().split("\n").slice(0, -1);
+		console.debug(`Clearing ports: ${pids.join(", ")}`);
+		for (const pid of pids) exec(`kill -9 ${pid}`, (error) => {
+			if (error) console.error(`Error while killing ${pid}: ${error}`);
+		});
+	} catch (e) {
+		console.error("Cleanup error: ", e.toString());
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/subscribable.js
+var Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		this.onSubscribe();
+		return () => {
+			this.listeners.delete(listener);
+			this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/utils.js
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {
+	return void 0;
+}
+function functionalUpdate(updater, input) {
+	return typeof updater === "function" ? updater(input) : updater;
+}
+function isValidTimeout(value) {
+	return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+	return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+	return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function matchQuery(filters, query) {
+	const { type = "all", exact, fetchStatus, predicate, queryKey, stale } = filters;
+	if (queryKey) {
+		if (exact) {
+			if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) return false;
+		} else if (!partialMatchKey(query.queryKey, queryKey)) return false;
+	}
+	if (type !== "all") {
+		const isActive = query.isActive();
+		if (type === "active" && !isActive) return false;
+		if (type === "inactive" && isActive) return false;
+	}
+	if (typeof stale === "boolean" && query.isStale() !== stale) return false;
+	if (fetchStatus && fetchStatus !== query.state.fetchStatus) return false;
+	if (predicate && !predicate(query)) return false;
+	return true;
+}
+function matchMutation(filters, mutation) {
+	const { exact, status, predicate, mutationKey } = filters;
+	if (mutationKey) {
+		if (!mutation.options.mutationKey) return false;
+		if (exact) {
+			if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) return false;
+		} else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) return false;
+	}
+	if (status && mutation.state.status !== status) return false;
+	if (predicate && !predicate(mutation)) return false;
+	return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+	const hashFn = options?.queryKeyHashFn || hashKey;
+	return hashFn(queryKey);
+}
+function hashKey(queryKey) {
+	return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+		result[key] = val[key];
+		return result;
+	}, {}) : val);
+}
+function partialMatchKey(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a && b && typeof a === "object" && typeof b === "object") return !Object.keys(b).some((key) => !partialMatchKey(a[key], b[key]));
+	return false;
+}
+function replaceEqualDeep(a, b) {
+	if (a === b) return a;
+	const array = isPlainArray(a) && isPlainArray(b);
+	if (array || isPlainObject(a) && isPlainObject(b)) {
+		const aItems = array ? a : Object.keys(a);
+		const aSize = aItems.length;
+		const bItems = array ? b : Object.keys(b);
+		const bSize = bItems.length;
+		const copy = array ? [] : {};
+		let equalItems = 0;
+		for (let i = 0; i < bSize; i++) {
+			const key = array ? i : bItems[i];
+			if ((!array && aItems.includes(key) || array) && a[key] === void 0 && b[key] === void 0) {
+				copy[key] = void 0;
+				equalItems++;
+			} else {
+				copy[key] = replaceEqualDeep(a[key], b[key]);
+				if (copy[key] === a[key] && a[key] !== void 0) equalItems++;
+			}
+		}
+		return aSize === bSize && equalItems === aSize ? a : copy;
+	}
+	return b;
+}
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+	if (!hasObjectPrototype(o)) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (!hasObjectPrototype(prot)) return false;
+	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+	if (Object.getPrototypeOf(o) !== Object.prototype) return false;
+	return true;
+}
+function hasObjectPrototype(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function replaceData(prevData, data, options) {
+	if (typeof options.structuralSharing === "function") return options.structuralSharing(prevData, data);
+	else if (options.structuralSharing !== false) return replaceEqualDeep(prevData, data);
+	return data;
+}
+function addToEnd(items, item, max = 0) {
+	const newItems = [...items, item];
+	return max && newItems.length > max ? newItems.slice(1) : newItems;
+}
+function addToStart(items, item, max = 0) {
+	const newItems = [item, ...items];
+	return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+}
+var skipToken = Symbol();
+var ensureQueryFn = (options, fetchOptions) => {
+	if (process.env.NODE_ENV !== "production") {
+		if (options.queryFn === skipToken) console.error(`Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`);
+	}
+	if (!options.queryFn && fetchOptions?.initialPromise) return () => fetchOptions.initialPromise;
+	if (!options.queryFn || options.queryFn === skipToken) return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`));
+	return options.queryFn;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/focusManager.js
+var FocusManager = class extends Subscribable {
+	#focused;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onFocus) => {
+			if (!isServer && window.addEventListener) {
+				const listener = () => onFocus();
+				window.addEventListener("visibilitychange", listener, false);
+				return () => {
+					window.removeEventListener("visibilitychange", listener);
+				};
+			}
+			return;
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup((focused) => {
+			if (typeof focused === "boolean") this.setFocused(focused);
+			else this.onFocus();
+		});
+	}
+	setFocused(focused) {
+		const changed = this.#focused !== focused;
+		if (changed) {
+			this.#focused = focused;
+			this.onFocus();
+		}
+	}
+	onFocus() {
+		const isFocused = this.isFocused();
+		this.listeners.forEach((listener) => {
+			listener(isFocused);
+		});
+	}
+	isFocused() {
+		if (typeof this.#focused === "boolean") return this.#focused;
+		return globalThis.document?.visibilityState !== "hidden";
+	}
+};
+var focusManager = new FocusManager();
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+var OnlineManager = class extends Subscribable {
+	#online = true;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onOnline) => {
+			if (!isServer && window.addEventListener) {
+				const onlineListener = () => onOnline(true);
+				const offlineListener = () => onOnline(false);
+				window.addEventListener("online", onlineListener, false);
+				window.addEventListener("offline", offlineListener, false);
+				return () => {
+					window.removeEventListener("online", onlineListener);
+					window.removeEventListener("offline", offlineListener);
+				};
+			}
+			return;
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup(this.setOnline.bind(this));
+	}
+	setOnline(online) {
+		const changed = this.#online !== online;
+		if (changed) {
+			this.#online = online;
+			this.listeners.forEach((listener) => {
+				listener(online);
+			});
+		}
+	}
+	isOnline() {
+		return this.#online;
+	}
+};
+var onlineManager = new OnlineManager();
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/retryer.js
+function defaultRetryDelay(failureCount) {
+	return Math.min(1e3 * 2 ** failureCount, 3e4);
+}
+function canFetch(networkMode) {
+	return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+var CancelledError = class {
+	constructor(options) {
+		this.revert = options?.revert;
+		this.silent = options?.silent;
+	}
+};
+function isCancelledError(value) {
+	return value instanceof CancelledError;
+}
+function createRetryer(config) {
+	let isRetryCancelled = false;
+	let failureCount = 0;
+	let isResolved = false;
+	let continueFn;
+	let promiseResolve;
+	let promiseReject;
+	const promise = new Promise((outerResolve, outerReject) => {
+		promiseResolve = outerResolve;
+		promiseReject = outerReject;
+	});
+	const cancel = (cancelOptions) => {
+		if (!isResolved) {
+			reject(new CancelledError(cancelOptions));
+			config.abort?.();
+		}
+	};
+	const cancelRetry = () => {
+		isRetryCancelled = true;
+	};
+	const continueRetry = () => {
+		isRetryCancelled = false;
+	};
+	const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
+	const canStart = () => canFetch(config.networkMode) && config.canRun();
+	const resolve = (value) => {
+		if (!isResolved) {
+			isResolved = true;
+			config.onSuccess?.(value);
+			continueFn?.();
+			promiseResolve(value);
+		}
+	};
+	const reject = (value) => {
+		if (!isResolved) {
+			isResolved = true;
+			config.onError?.(value);
+			continueFn?.();
+			promiseReject(value);
+		}
+	};
+	const pause = () => {
+		return new Promise((continueResolve) => {
+			continueFn = (value) => {
+				if (isResolved || canContinue()) continueResolve(value);
+			};
+			config.onPause?.();
+		}).then(() => {
+			continueFn = void 0;
+			if (!isResolved) config.onContinue?.();
+		});
+	};
+	const run = () => {
+		if (isResolved) return;
+		let promiseOrValue;
+		const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+		try {
+			promiseOrValue = initialPromise ?? config.fn();
+		} catch (error) {
+			promiseOrValue = Promise.reject(error);
+		}
+		Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
+			if (isResolved) return;
+			const retry = config.retry ?? (isServer ? 0 : 3);
+			const retryDelay = config.retryDelay ?? defaultRetryDelay;
+			const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
+			const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
+			if (isRetryCancelled || !shouldRetry) {
+				reject(error);
+				return;
+			}
+			failureCount++;
+			config.onFail?.(failureCount, error);
+			sleep(delay).then(() => {
+				return canContinue() ? void 0 : pause();
+			}).then(() => {
+				if (isRetryCancelled) reject(error);
+				else run();
+			});
+		});
+	};
+	return {
+		promise,
+		cancel,
+		continue: () => {
+			continueFn?.();
+			return promise;
+		},
+		cancelRetry,
+		continueRetry,
+		canStart,
+		start: () => {
+			if (canStart()) run();
+			else pause().then(run);
+			return promise;
+		}
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+function createNotifyManager() {
+	let queue = [];
+	let transactions = 0;
+	let notifyFn = (callback) => {
+		callback();
+	};
+	let batchNotifyFn = (callback) => {
+		callback();
+	};
+	let scheduleFn = (cb) => setTimeout(cb, 0);
+	const setScheduler = (fn) => {
+		scheduleFn = fn;
+	};
+	const batch = (callback) => {
+		let result;
+		transactions++;
+		try {
+			result = callback();
+		} finally {
+			transactions--;
+			if (!transactions) flush();
+		}
+		return result;
+	};
+	const schedule = (callback) => {
+		if (transactions) queue.push(callback);
+		else scheduleFn(() => {
+			notifyFn(callback);
+		});
+	};
+	const batchCalls = (callback) => {
+		return (...args) => {
+			schedule(() => {
+				callback(...args);
+			});
+		};
+	};
+	const flush = () => {
+		const originalQueue = queue;
+		queue = [];
+		if (originalQueue.length) scheduleFn(() => {
+			batchNotifyFn(() => {
+				originalQueue.forEach((callback) => {
+					notifyFn(callback);
+				});
+			});
+		});
+	};
+	const setNotifyFunction = (fn) => {
+		notifyFn = fn;
+	};
+	const setBatchNotifyFunction = (fn) => {
+		batchNotifyFn = fn;
+	};
+	return {
+		batch,
+		batchCalls,
+		schedule,
+		setNotifyFunction,
+		setBatchNotifyFunction,
+		setScheduler
+	};
+}
+var notifyManager = createNotifyManager();
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/removable.js
+var Removable = class {
+	#gcTimeout;
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout();
+		if (isValidTimeout(this.gcTime)) this.#gcTimeout = setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime);
+	}
+	updateGcTime(newGcTime) {
+		this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3));
+	}
+	clearGcTimeout() {
+		if (this.#gcTimeout) {
+			clearTimeout(this.#gcTimeout);
+			this.#gcTimeout = void 0;
+		}
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/query.js
+var Query = class extends Removable {
+	#initialState;
+	#revertState;
+	#cache;
+	#retryer;
+	#defaultOptions;
+	#abortSignalConsumed;
+	constructor(config) {
+		super();
+		this.#abortSignalConsumed = false;
+		this.#defaultOptions = config.defaultOptions;
+		this.setOptions(config.options);
+		this.observers = [];
+		this.#cache = config.cache;
+		this.queryKey = config.queryKey;
+		this.queryHash = config.queryHash;
+		this.#initialState = config.state || getDefaultState$1(this.options);
+		this.state = this.#initialState;
+		this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get promise() {
+		return this.#retryer?.promise;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.#defaultOptions,
+			...options
+		};
+		this.updateGcTime(this.options.gcTime);
+	}
+	optionalRemove() {
+		if (!this.observers.length && this.state.fetchStatus === "idle") this.#cache.remove(this);
+	}
+	setData(newData, options) {
+		const data = replaceData(this.state.data, newData, this.options);
+		this.#dispatch({
+			data,
+			type: "success",
+			dataUpdatedAt: options?.updatedAt,
+			manual: options?.manual
+		});
+		return data;
+	}
+	setState(state, setStateOptions) {
+		this.#dispatch({
+			type: "setState",
+			state,
+			setStateOptions
+		});
+	}
+	cancel(options) {
+		const promise = this.#retryer?.promise;
+		this.#retryer?.cancel(options);
+		return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy();
+		this.cancel({ silent: true });
+	}
+	reset() {
+		this.destroy();
+		this.setState(this.#initialState);
+	}
+	isActive() {
+		return this.observers.some((observer) => observer.options.enabled !== false);
+	}
+	isDisabled() {
+		return this.getObserversCount() > 0 && !this.isActive();
+	}
+	isStale() {
+		if (this.state.isInvalidated) return true;
+		if (this.getObserversCount() > 0) return this.observers.some((observer) => observer.getCurrentResult().isStale);
+		return this.state.data === void 0;
+	}
+	isStaleByTime(staleTime = 0) {
+		return this.state.isInvalidated || this.state.data === void 0 || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+	}
+	onFocus() {
+		const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus());
+		observer?.refetch({ cancelRefetch: false });
+		this.#retryer?.continue();
+	}
+	onOnline() {
+		const observer = this.observers.find((x) => x.shouldFetchOnReconnect());
+		observer?.refetch({ cancelRefetch: false });
+		this.#retryer?.continue();
+	}
+	addObserver(observer) {
+		if (!this.observers.includes(observer)) {
+			this.observers.push(observer);
+			this.clearGcTimeout();
+			this.#cache.notify({
+				type: "observerAdded",
+				query: this,
+				observer
+			});
+		}
+	}
+	removeObserver(observer) {
+		if (this.observers.includes(observer)) {
+			this.observers = this.observers.filter((x) => x !== observer);
+			if (!this.observers.length) {
+				if (this.#retryer) if (this.#abortSignalConsumed) this.#retryer.cancel({ revert: true });
+				else this.#retryer.cancelRetry();
+				this.scheduleGc();
+			}
+			this.#cache.notify({
+				type: "observerRemoved",
+				query: this,
+				observer
+			});
+		}
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	invalidate() {
+		if (!this.state.isInvalidated) this.#dispatch({ type: "invalidate" });
+	}
+	fetch(options, fetchOptions) {
+		if (this.state.fetchStatus !== "idle") {
+			if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) this.cancel({ silent: true });
+			else if (this.#retryer) {
+				this.#retryer.continueRetry();
+				return this.#retryer.promise;
+			}
+		}
+		if (options) this.setOptions(options);
+		if (!this.options.queryFn) {
+			const observer = this.observers.find((x) => x.options.queryFn);
+			if (observer) this.setOptions(observer.options);
+		}
+		if (process.env.NODE_ENV !== "production") {
+			if (!Array.isArray(this.options.queryKey)) console.error(`As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`);
+		}
+		const abortController = new AbortController();
+		const addSignalProperty = (object) => {
+			Object.defineProperty(object, "signal", {
+				enumerable: true,
+				get: () => {
+					this.#abortSignalConsumed = true;
+					return abortController.signal;
+				}
+			});
+		};
+		const fetchFn = () => {
+			const queryFn = ensureQueryFn(this.options, fetchOptions);
+			const queryFnContext = {
+				queryKey: this.queryKey,
+				meta: this.meta
+			};
+			addSignalProperty(queryFnContext);
+			this.#abortSignalConsumed = false;
+			if (this.options.persister) return this.options.persister(queryFn, queryFnContext, this);
+			return queryFn(queryFnContext);
+		};
+		const context = {
+			fetchOptions,
+			options: this.options,
+			queryKey: this.queryKey,
+			state: this.state,
+			fetchFn
+		};
+		addSignalProperty(context);
+		this.options.behavior?.onFetch(context, this);
+		this.#revertState = this.state;
+		if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) this.#dispatch({
+			type: "fetch",
+			meta: context.fetchOptions?.meta
+		});
+		const onError = (error) => {
+			if (!(isCancelledError(error) && error.silent)) this.#dispatch({
+				type: "error",
+				error
+			});
+			if (!isCancelledError(error)) {
+				this.#cache.config.onError?.(error, this);
+				this.#cache.config.onSettled?.(this.state.data, error, this);
+			}
+			if (!this.isFetchingOptimistic) this.scheduleGc();
+			this.isFetchingOptimistic = false;
+		};
+		this.#retryer = createRetryer({
+			initialPromise: fetchOptions?.initialPromise,
+			fn: context.fetchFn,
+			abort: abortController.abort.bind(abortController),
+			onSuccess: (data) => {
+				if (data === void 0) {
+					if (process.env.NODE_ENV !== "production") console.error(`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`);
+					onError(new Error(`${this.queryHash} data is undefined`));
+					return;
+				}
+				this.setData(data);
+				this.#cache.config.onSuccess?.(data, this);
+				this.#cache.config.onSettled?.(data, this.state.error, this);
+				if (!this.isFetchingOptimistic) this.scheduleGc();
+				this.isFetchingOptimistic = false;
+			},
+			onError,
+			onFail: (failureCount, error) => {
+				this.#dispatch({
+					type: "failed",
+					failureCount,
+					error
+				});
+			},
+			onPause: () => {
+				this.#dispatch({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#dispatch({ type: "continue" });
+			},
+			retry: context.options.retry,
+			retryDelay: context.options.retryDelay,
+			networkMode: context.options.networkMode,
+			canRun: () => true
+		});
+		return this.#retryer.start();
+	}
+	#dispatch(action) {
+		const reducer = (state) => {
+			switch (action.type) {
+				case "failed": return {
+					...state,
+					fetchFailureCount: action.failureCount,
+					fetchFailureReason: action.error
+				};
+				case "pause": return {
+					...state,
+					fetchStatus: "paused"
+				};
+				case "continue": return {
+					...state,
+					fetchStatus: "fetching"
+				};
+				case "fetch": return {
+					...state,
+					...fetchState(state.data, this.options),
+					fetchMeta: action.meta ?? null
+				};
+				case "success": return {
+					...state,
+					data: action.data,
+					dataUpdateCount: state.dataUpdateCount + 1,
+					dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),
+					error: null,
+					isInvalidated: false,
+					status: "success",
+					...!action.manual && {
+						fetchStatus: "idle",
+						fetchFailureCount: 0,
+						fetchFailureReason: null
+					}
+				};
+				case "error":
+					const error = action.error;
+					if (isCancelledError(error) && error.revert && this.#revertState) return {
+						...this.#revertState,
+						fetchStatus: "idle"
+					};
+					return {
+						...state,
+						error,
+						errorUpdateCount: state.errorUpdateCount + 1,
+						errorUpdatedAt: Date.now(),
+						fetchFailureCount: state.fetchFailureCount + 1,
+						fetchFailureReason: error,
+						fetchStatus: "idle",
+						status: "error"
+					};
+				case "invalidate": return {
+					...state,
+					isInvalidated: true
+				};
+				case "setState": return {
+					...state,
+					...action.state
+				};
+			}
+		};
+		this.state = reducer(this.state);
+		notifyManager.batch(() => {
+			this.observers.forEach((observer) => {
+				observer.onQueryUpdate();
+			});
+			this.#cache.notify({
+				query: this,
+				type: "updated",
+				action
+			});
+		});
+	}
+};
+function fetchState(data, options) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+		...data === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function getDefaultState$1(options) {
+	const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+	const hasData = data !== void 0;
+	const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+	return {
+		data,
+		dataUpdateCount: 0,
+		dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: false,
+		status: hasData ? "success" : "pending",
+		fetchStatus: "idle"
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/queryCache.js
+var QueryCache = class extends Subscribable {
+	constructor(config = {}) {
+		super();
+		this.config = config;
+		this.#queries = /* @__PURE__ */ new Map();
+	}
+	#queries;
+	build(client, options, state) {
+		const queryKey = options.queryKey;
+		const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
+		let query = this.get(queryHash);
+		if (!query) {
+			query = new Query({
+				cache: this,
+				queryKey,
+				queryHash,
+				options: client.defaultQueryOptions(options),
+				state,
+				defaultOptions: client.getQueryDefaults(queryKey)
+			});
+			this.add(query);
+		}
+		return query;
+	}
+	add(query) {
+		if (!this.#queries.has(query.queryHash)) {
+			this.#queries.set(query.queryHash, query);
+			this.notify({
+				type: "added",
+				query
+			});
+		}
+	}
+	remove(query) {
+		const queryInMap = this.#queries.get(query.queryHash);
+		if (queryInMap) {
+			query.destroy();
+			if (queryInMap === query) this.#queries.delete(query.queryHash);
+			this.notify({
+				type: "removed",
+				query
+			});
+		}
+	}
+	clear() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((query) => {
+				this.remove(query);
+			});
+		});
+	}
+	get(queryHash) {
+		return this.#queries.get(queryHash);
+	}
+	getAll() {
+		return [...this.#queries.values()];
+	}
+	find(filters) {
+		const defaultedFilters = {
+			exact: true,
+			...filters
+		};
+		return this.getAll().find((query) => matchQuery(defaultedFilters, query));
+	}
+	findAll(filters = {}) {
+		const queries = this.getAll();
+		return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
+	}
+	notify(event) {
+		notifyManager.batch(() => {
+			this.listeners.forEach((listener) => {
+				listener(event);
+			});
+		});
+	}
+	onFocus() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((query) => {
+				query.onFocus();
+			});
+		});
+	}
+	onOnline() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((query) => {
+				query.onOnline();
+			});
+		});
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/mutation.js
+var Mutation = class extends Removable {
+	#observers;
+	#mutationCache;
+	#retryer;
+	constructor(config) {
+		super();
+		this.mutationId = config.mutationId;
+		this.#mutationCache = config.mutationCache;
+		this.#observers = [];
+		this.state = config.state || getDefaultState();
+		this.setOptions(config.options);
+		this.scheduleGc();
+	}
+	setOptions(options) {
+		this.options = options;
+		this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(observer) {
+		if (!this.#observers.includes(observer)) {
+			this.#observers.push(observer);
+			this.clearGcTimeout();
+			this.#mutationCache.notify({
+				type: "observerAdded",
+				mutation: this,
+				observer
+			});
+		}
+	}
+	removeObserver(observer) {
+		this.#observers = this.#observers.filter((x) => x !== observer);
+		this.scheduleGc();
+		this.#mutationCache.notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer
+		});
+	}
+	optionalRemove() {
+		if (!this.#observers.length) if (this.state.status === "pending") this.scheduleGc();
+		else this.#mutationCache.remove(this);
+	}
+	continue() {
+		return this.#retryer?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(variables) {
+		this.#retryer = createRetryer({
+			fn: () => {
+				if (!this.options.mutationFn) return Promise.reject(new Error("No mutationFn found"));
+				return this.options.mutationFn(variables);
+			},
+			onFail: (failureCount, error) => {
+				this.#dispatch({
+					type: "failed",
+					failureCount,
+					error
+				});
+			},
+			onPause: () => {
+				this.#dispatch({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#dispatch({ type: "continue" });
+			},
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => this.#mutationCache.canRun(this)
+		});
+		const restored = this.state.status === "pending";
+		const isPaused = !this.#retryer.canStart();
+		try {
+			if (!restored) {
+				this.#dispatch({
+					type: "pending",
+					variables,
+					isPaused
+				});
+				await this.#mutationCache.config.onMutate?.(variables, this);
+				const context = await this.options.onMutate?.(variables);
+				if (context !== this.state.context) this.#dispatch({
+					type: "pending",
+					context,
+					variables,
+					isPaused
+				});
+			}
+			const data = await this.#retryer.start();
+			await this.#mutationCache.config.onSuccess?.(data, variables, this.state.context, this);
+			await this.options.onSuccess?.(data, variables, this.state.context);
+			await this.#mutationCache.config.onSettled?.(data, null, this.state.variables, this.state.context, this);
+			await this.options.onSettled?.(data, null, variables, this.state.context);
+			this.#dispatch({
+				type: "success",
+				data
+			});
+			return data;
+		} catch (error) {
+			try {
+				await this.#mutationCache.config.onError?.(error, variables, this.state.context, this);
+				await this.options.onError?.(error, variables, this.state.context);
+				await this.#mutationCache.config.onSettled?.(void 0, error, this.state.variables, this.state.context, this);
+				await this.options.onSettled?.(void 0, error, variables, this.state.context);
+				throw error;
+			} finally {
+				this.#dispatch({
+					type: "error",
+					error
+				});
+			}
+		} finally {
+			this.#mutationCache.runNext(this);
+		}
+	}
+	#dispatch(action) {
+		const reducer = (state) => {
+			switch (action.type) {
+				case "failed": return {
+					...state,
+					failureCount: action.failureCount,
+					failureReason: action.error
+				};
+				case "pause": return {
+					...state,
+					isPaused: true
+				};
+				case "continue": return {
+					...state,
+					isPaused: false
+				};
+				case "pending": return {
+					...state,
+					context: action.context,
+					data: void 0,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					isPaused: action.isPaused,
+					status: "pending",
+					variables: action.variables,
+					submittedAt: Date.now()
+				};
+				case "success": return {
+					...state,
+					data: action.data,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					status: "success",
+					isPaused: false
+				};
+				case "error": return {
+					...state,
+					data: void 0,
+					error: action.error,
+					failureCount: state.failureCount + 1,
+					failureReason: action.error,
+					isPaused: false,
+					status: "error"
+				};
+			}
+		};
+		this.state = reducer(this.state);
+		notifyManager.batch(() => {
+			this.#observers.forEach((observer) => {
+				observer.onMutationUpdate(action);
+			});
+			this.#mutationCache.notify({
+				mutation: this,
+				type: "updated",
+				action
+			});
+		});
+	}
+};
+function getDefaultState() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: false,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/mutationCache.js
+var MutationCache = class extends Subscribable {
+	constructor(config = {}) {
+		super();
+		this.config = config;
+		this.#mutations = /* @__PURE__ */ new Map();
+		this.#mutationId = Date.now();
+	}
+	#mutations;
+	#mutationId;
+	build(client, options, state) {
+		const mutation = new Mutation({
+			mutationCache: this,
+			mutationId: ++this.#mutationId,
+			options: client.defaultMutationOptions(options),
+			state
+		});
+		this.add(mutation);
+		return mutation;
+	}
+	add(mutation) {
+		const scope = scopeFor(mutation);
+		const mutations = this.#mutations.get(scope) ?? [];
+		mutations.push(mutation);
+		this.#mutations.set(scope, mutations);
+		this.notify({
+			type: "added",
+			mutation
+		});
+	}
+	remove(mutation) {
+		const scope = scopeFor(mutation);
+		if (this.#mutations.has(scope)) {
+			const mutations = this.#mutations.get(scope)?.filter((x) => x !== mutation);
+			if (mutations) if (mutations.length === 0) this.#mutations.delete(scope);
+			else this.#mutations.set(scope, mutations);
+		}
+		this.notify({
+			type: "removed",
+			mutation
+		});
+	}
+	canRun(mutation) {
+		const firstPendingMutation = this.#mutations.get(scopeFor(mutation))?.find((m) => m.state.status === "pending");
+		return !firstPendingMutation || firstPendingMutation === mutation;
+	}
+	runNext(mutation) {
+		const foundMutation = this.#mutations.get(scopeFor(mutation))?.find((m) => m !== mutation && m.state.isPaused);
+		return foundMutation?.continue() ?? Promise.resolve();
+	}
+	clear() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((mutation) => {
+				this.remove(mutation);
+			});
+		});
+	}
+	getAll() {
+		return [...this.#mutations.values()].flat();
+	}
+	find(filters) {
+		const defaultedFilters = {
+			exact: true,
+			...filters
+		};
+		return this.getAll().find((mutation) => matchMutation(defaultedFilters, mutation));
+	}
+	findAll(filters = {}) {
+		return this.getAll().filter((mutation) => matchMutation(filters, mutation));
+	}
+	notify(event) {
+		notifyManager.batch(() => {
+			this.listeners.forEach((listener) => {
+				listener(event);
+			});
+		});
+	}
+	resumePausedMutations() {
+		const pausedMutations = this.getAll().filter((x) => x.state.isPaused);
+		return notifyManager.batch(() => Promise.all(pausedMutations.map((mutation) => mutation.continue().catch(noop))));
+	}
+};
+function scopeFor(mutation) {
+	return mutation.options.scope?.id ?? String(mutation.mutationId);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+function infiniteQueryBehavior(pages) {
+	return { onFetch: (context, query) => {
+		const fetchFn = async () => {
+			const options = context.options;
+			const direction = context.fetchOptions?.meta?.fetchMore?.direction;
+			const oldPages = context.state.data?.pages || [];
+			const oldPageParams = context.state.data?.pageParams || [];
+			const empty = {
+				pages: [],
+				pageParams: []
+			};
+			let cancelled = false;
+			const addSignalProperty = (object) => {
+				Object.defineProperty(object, "signal", {
+					enumerable: true,
+					get: () => {
+						if (context.signal.aborted) cancelled = true;
+						else context.signal.addEventListener("abort", () => {
+							cancelled = true;
+						});
+						return context.signal;
+					}
+				});
+			};
+			const queryFn = ensureQueryFn(context.options, context.fetchOptions);
+			const fetchPage = async (data, param, previous) => {
+				if (cancelled) return Promise.reject();
+				if (param == null && data.pages.length) return Promise.resolve(data);
+				const queryFnContext = {
+					queryKey: context.queryKey,
+					pageParam: param,
+					direction: previous ? "backward" : "forward",
+					meta: context.options.meta
+				};
+				addSignalProperty(queryFnContext);
+				const page = await queryFn(queryFnContext);
+				const { maxPages } = context.options;
+				const addTo = previous ? addToStart : addToEnd;
+				return {
+					pages: addTo(data.pages, page, maxPages),
+					pageParams: addTo(data.pageParams, param, maxPages)
+				};
+			};
+			let result;
+			if (direction && oldPages.length) {
+				const previous = direction === "backward";
+				const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+				const oldData = {
+					pages: oldPages,
+					pageParams: oldPageParams
+				};
+				const param = pageParamFn(options, oldData);
+				result = await fetchPage(oldData, param, previous);
+			} else {
+				result = await fetchPage(empty, oldPageParams[0] ?? options.initialPageParam);
+				const remainingPages = pages ?? oldPages.length;
+				for (let i = 1; i < remainingPages; i++) {
+					const param = getNextPageParam(options, result);
+					result = await fetchPage(result, param);
+				}
+			}
+			return result;
+		};
+		if (context.options.persister) context.fetchFn = () => {
+			return context.options.persister?.(fetchFn, {
+				queryKey: context.queryKey,
+				meta: context.options.meta,
+				signal: context.signal
+			}, query);
+		};
+		else context.fetchFn = fetchFn;
+	} };
+}
+function getNextPageParam(options, { pages, pageParams }) {
+	const lastIndex = pages.length - 1;
+	return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams);
+}
+function getPreviousPageParam(options, { pages, pageParams }) {
+	return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.45.0/node_modules/@tanstack/query-core/build/modern/queryClient.js
+var QueryClient = class {
+	#queryCache;
+	#mutationCache;
+	#defaultOptions;
+	#queryDefaults;
+	#mutationDefaults;
+	#mountCount;
+	#unsubscribeFocus;
+	#unsubscribeOnline;
+	constructor(config = {}) {
+		this.#queryCache = config.queryCache || new QueryCache();
+		this.#mutationCache = config.mutationCache || new MutationCache();
+		this.#defaultOptions = config.defaultOptions || {};
+		this.#queryDefaults = /* @__PURE__ */ new Map();
+		this.#mutationDefaults = /* @__PURE__ */ new Map();
+		this.#mountCount = 0;
+	}
+	mount() {
+		this.#mountCount++;
+		if (this.#mountCount !== 1) return;
+		this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {
+			if (focused) {
+				await this.resumePausedMutations();
+				this.#queryCache.onFocus();
+			}
+		});
+		this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {
+			if (online) {
+				await this.resumePausedMutations();
+				this.#queryCache.onOnline();
+			}
+		});
+	}
+	unmount() {
+		this.#mountCount--;
+		if (this.#mountCount !== 0) return;
+		this.#unsubscribeFocus?.();
+		this.#unsubscribeFocus = void 0;
+		this.#unsubscribeOnline?.();
+		this.#unsubscribeOnline = void 0;
+	}
+	isFetching(filters) {
+		return this.#queryCache.findAll({
+			...filters,
+			fetchStatus: "fetching"
+		}).length;
+	}
+	isMutating(filters) {
+		return this.#mutationCache.findAll({
+			...filters,
+			status: "pending"
+		}).length;
+	}
+	getQueryData(queryKey) {
+		const options = this.defaultQueryOptions({ queryKey });
+		return this.#queryCache.get(options.queryHash)?.state.data;
+	}
+	ensureQueryData(options) {
+		const cachedData = this.getQueryData(options.queryKey);
+		if (cachedData === void 0) return this.fetchQuery(options);
+		else {
+			const defaultedOptions = this.defaultQueryOptions(options);
+			const query = this.#queryCache.build(this, defaultedOptions);
+			if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) this.prefetchQuery(defaultedOptions);
+			return Promise.resolve(cachedData);
+		}
+	}
+	getQueriesData(filters) {
+		return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {
+			const data = state.data;
+			return [queryKey, data];
+		});
+	}
+	setQueryData(queryKey, updater, options) {
+		const defaultedOptions = this.defaultQueryOptions({ queryKey });
+		const query = this.#queryCache.get(defaultedOptions.queryHash);
+		const prevData = query?.state.data;
+		const data = functionalUpdate(updater, prevData);
+		if (data === void 0) return void 0;
+		return this.#queryCache.build(this, defaultedOptions).setData(data, {
+			...options,
+			manual: true
+		});
+	}
+	setQueriesData(filters, updater, options) {
+		return notifyManager.batch(() => this.#queryCache.findAll(filters).map(({ queryKey }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
+	}
+	getQueryState(queryKey) {
+		const options = this.defaultQueryOptions({ queryKey });
+		return this.#queryCache.get(options.queryHash)?.state;
+	}
+	removeQueries(filters) {
+		const queryCache = this.#queryCache;
+		notifyManager.batch(() => {
+			queryCache.findAll(filters).forEach((query) => {
+				queryCache.remove(query);
+			});
+		});
+	}
+	resetQueries(filters, options) {
+		const queryCache = this.#queryCache;
+		const refetchFilters = {
+			type: "active",
+			...filters
+		};
+		return notifyManager.batch(() => {
+			queryCache.findAll(filters).forEach((query) => {
+				query.reset();
+			});
+			return this.refetchQueries(refetchFilters, options);
+		});
+	}
+	cancelQueries(filters = {}, cancelOptions = {}) {
+		const defaultedCancelOptions = {
+			revert: true,
+			...cancelOptions
+		};
+		const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)));
+		return Promise.all(promises).then(noop).catch(noop);
+	}
+	invalidateQueries(filters = {}, options = {}) {
+		return notifyManager.batch(() => {
+			this.#queryCache.findAll(filters).forEach((query) => {
+				query.invalidate();
+			});
+			if (filters.refetchType === "none") return Promise.resolve();
+			const refetchFilters = {
+				...filters,
+				type: filters.refetchType ?? filters.type ?? "active"
+			};
+			return this.refetchQueries(refetchFilters, options);
+		});
+	}
+	refetchQueries(filters = {}, options) {
+		const fetchOptions = {
+			...options,
+			cancelRefetch: options?.cancelRefetch ?? true
+		};
+		const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled()).map((query) => {
+			let promise = query.fetch(void 0, fetchOptions);
+			if (!fetchOptions.throwOnError) promise = promise.catch(noop);
+			return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
+		}));
+		return Promise.all(promises).then(noop);
+	}
+	fetchQuery(options) {
+		const defaultedOptions = this.defaultQueryOptions(options);
+		if (defaultedOptions.retry === void 0) defaultedOptions.retry = false;
+		const query = this.#queryCache.build(this, defaultedOptions);
+		return query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query)) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+	}
+	prefetchQuery(options) {
+		return this.fetchQuery(options).then(noop).catch(noop);
+	}
+	fetchInfiniteQuery(options) {
+		options.behavior = infiniteQueryBehavior(options.pages);
+		return this.fetchQuery(options);
+	}
+	prefetchInfiniteQuery(options) {
+		return this.fetchInfiniteQuery(options).then(noop).catch(noop);
+	}
+	resumePausedMutations() {
+		if (onlineManager.isOnline()) return this.#mutationCache.resumePausedMutations();
+		return Promise.resolve();
+	}
+	getQueryCache() {
+		return this.#queryCache;
+	}
+	getMutationCache() {
+		return this.#mutationCache;
+	}
+	getDefaultOptions() {
+		return this.#defaultOptions;
+	}
+	setDefaultOptions(options) {
+		this.#defaultOptions = options;
+	}
+	setQueryDefaults(queryKey, options) {
+		this.#queryDefaults.set(hashKey(queryKey), {
+			queryKey,
+			defaultOptions: options
+		});
+	}
+	getQueryDefaults(queryKey) {
+		const defaults = [...this.#queryDefaults.values()];
+		let result = {};
+		defaults.forEach((queryDefault) => {
+			if (partialMatchKey(queryKey, queryDefault.queryKey)) result = {
+				...result,
+				...queryDefault.defaultOptions
+			};
+		});
+		return result;
+	}
+	setMutationDefaults(mutationKey, options) {
+		this.#mutationDefaults.set(hashKey(mutationKey), {
+			mutationKey,
+			defaultOptions: options
+		});
+	}
+	getMutationDefaults(mutationKey) {
+		const defaults = [...this.#mutationDefaults.values()];
+		let result = {};
+		defaults.forEach((queryDefault) => {
+			if (partialMatchKey(mutationKey, queryDefault.mutationKey)) result = {
+				...result,
+				...queryDefault.defaultOptions
+			};
+		});
+		return result;
+	}
+	defaultQueryOptions(options) {
+		if (options._defaulted) return options;
+		const defaultedOptions = {
+			...this.#defaultOptions.queries,
+			...this.getQueryDefaults(options.queryKey),
+			...options,
+			_defaulted: true
+		};
+		if (!defaultedOptions.queryHash) defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
+		if (defaultedOptions.refetchOnReconnect === void 0) defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
+		if (defaultedOptions.throwOnError === void 0) defaultedOptions.throwOnError = !!defaultedOptions.suspense;
+		if (!defaultedOptions.networkMode && defaultedOptions.persister) defaultedOptions.networkMode = "offlineFirst";
+		if (defaultedOptions.enabled !== true && defaultedOptions.queryFn === skipToken) defaultedOptions.enabled = false;
+		return defaultedOptions;
+	}
+	defaultMutationOptions(options) {
+		if (options?._defaulted) return options;
+		return {
+			...this.#defaultOptions.mutations,
+			...options?.mutationKey && this.getMutationDefaults(options.mutationKey),
+			...options,
+			_defaulted: true
+		};
+	}
+	clear() {
+		this.#queryCache.clear();
+		this.#mutationCache.clear();
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.45.1_react@18.3.0-canary-c3048aab4-20240326/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+"use client";
+var QueryClientContext = React.createContext(void 0);
+var QueryClientProvider = ({ client, children }) => {
+	React.useEffect(() => {
+		client.mount();
+		return () => {
+			client.unmount();
+		};
+	}, [client]);
+	return /* @__PURE__ */ jsx(QueryClientContext.Provider, {
+		value: client,
+		children
+	});
+};
+
+//#endregion
+//#region src/test/react-test-utils.tsx
+const Connect = () => {
+	const { connectors, connect } = useConnect();
+	useEffect(() => {
+		if (connectors[0] === void 0) return void 0;
+		connect({ connector: connectors[0] });
+	}, [connect, connectors]);
+	return /* @__PURE__ */ jsx(Fragment, {});
+};
+const ReactTestWrapper = ({ children, wagmiConfig }) => {
+	const testQueryClient = new QueryClient({ defaultOptions: {
+		queries: { retry: false },
+		mutations: { retry: false }
+	} });
+	return /* @__PURE__ */ jsx(WagmiProvider, {
+		config: wagmiConfig,
+		children: /* @__PURE__ */ jsx(QueryClientProvider, {
+			client: testQueryClient,
+			children: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Connect, {}), children] })
+		})
+	});
+};
+
+//#endregion
+//#region src/test/test-accounts.ts
+const alice = "0x0000000000000000000000000000000000001234";
+const bob = "0x0000000000000000000000000000000000002345";
+const charlie = "0x0000000000000000000000000000000000003456";
+
+//#endregion
+export { ReactTestWrapper, alice, bob, charlie, killAllAnvilProcesses, killAnvilProcess, spawnAnvil };
+//# sourceMappingURL=index.js.map