@camstack/addon-tailscale-client 0.1.12

package/dist/modern-CWdms43F.mjs

@@ -0,0 +1,2184 @@
+import { a as e, d as t, f as n, h as r, i, l as a, o, t as s, u as c } from "./__mfe_internal__addon_tailscale_client_page__loadShare__react__loadShare__.mjs-BBqTAV2L.mjs";
+import { n as l } from "./__mfe_internal__addon_tailscale_client_page__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.mjs-BK8BTUon.mjs";
+//#region ../../node_modules/@tanstack/query-core/build/modern/subscribable.js
+var u = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(e) {
+		return this.listeners.add(e), this.onSubscribe(), () => {
+			this.listeners.delete(e), this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+}, d = new class extends u {
+	#e;
+	#t;
+	#n;
+	constructor() {
+		super(), this.#n = (e) => {
+			if (typeof window < "u" && window.addEventListener) {
+				let t = () => e();
+				return window.addEventListener("visibilitychange", t, !1), () => {
+					window.removeEventListener("visibilitychange", t);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		this.#t || this.setEventListener(this.#n);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (this.#t?.(), this.#t = void 0);
+	}
+	setEventListener(e) {
+		this.#n = e, this.#t?.(), this.#t = e((e) => {
+			typeof e == "boolean" ? this.setFocused(e) : this.onFocus();
+		});
+	}
+	setFocused(e) {
+		this.#e !== e && (this.#e = e, this.onFocus());
+	}
+	onFocus() {
+		let e = this.isFocused();
+		this.listeners.forEach((t) => {
+			t(e);
+		});
+	}
+	isFocused() {
+		return typeof this.#e == "boolean" ? this.#e : globalThis.document?.visibilityState !== "hidden";
+	}
+}(), f = {
+	setTimeout: (e, t) => setTimeout(e, t),
+	clearTimeout: (e) => clearTimeout(e),
+	setInterval: (e, t) => setInterval(e, t),
+	clearInterval: (e) => clearInterval(e)
+}, p = new class {
+	#e = f;
+	setTimeoutProvider(e) {
+		this.#e = e;
+	}
+	setTimeout(e, t) {
+		return this.#e.setTimeout(e, t);
+	}
+	clearTimeout(e) {
+		this.#e.clearTimeout(e);
+	}
+	setInterval(e, t) {
+		return this.#e.setInterval(e, t);
+	}
+	clearInterval(e) {
+		this.#e.clearInterval(e);
+	}
+}();
+function m(e) {
+	setTimeout(e, 0);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/utils.js
+var h = typeof window > "u" || "Deno" in globalThis;
+function g() {}
+function _(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function v(e) {
+	return typeof e == "number" && e >= 0 && e !== Infinity;
+}
+function y(e, t) {
+	return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function b(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function x(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function S(e, t) {
+	let { type: n = "all", exact: r, fetchStatus: i, predicate: a, queryKey: o, stale: s } = e;
+	if (o) {
+		if (r) {
+			if (t.queryHash !== w(o, t.options)) return !1;
+		} else if (!E(t.queryKey, o)) return !1;
+	}
+	if (n !== "all") {
+		let e = t.isActive();
+		if (n === "active" && !e || n === "inactive" && e) return !1;
+	}
+	return !(typeof s == "boolean" && t.isStale() !== s || i && i !== t.state.fetchStatus || a && !a(t));
+}
+function C(e, t) {
+	let { exact: n, status: r, predicate: i, mutationKey: a } = e;
+	if (a) {
+		if (!t.options.mutationKey) return !1;
+		if (n) {
+			if (T(t.options.mutationKey) !== T(a)) return !1;
+		} else if (!E(t.options.mutationKey, a)) return !1;
+	}
+	return !(r && t.state.status !== r || i && !i(t));
+}
+function w(e, t) {
+	return (t?.queryKeyHashFn || T)(e);
+}
+function T(e) {
+	return JSON.stringify(e, (e, t) => k(t) ? Object.keys(t).sort().reduce((e, n) => (e[n] = t[n], e), {}) : t);
+}
+function E(e, t) {
+	return e === t ? !0 : typeof e == typeof t && e && t && typeof e == "object" && typeof t == "object" ? Object.keys(t).every((n) => E(e[n], t[n])) : !1;
+}
+var ee = Object.prototype.hasOwnProperty;
+function D(e, t, n = 0) {
+	if (e === t) return e;
+	if (n > 500) return t;
+	let r = te(e) && te(t);
+	if (!r && !(k(e) && k(t))) return t;
+	let i = (r ? e : Object.keys(e)).length, a = r ? t : Object.keys(t), o = a.length, s = r ? Array(o) : {}, c = 0;
+	for (let l = 0; l < o; l++) {
+		let o = r ? l : a[l], u = e[o], d = t[o];
+		if (u === d) {
+			s[o] = u, (r ? l < i : ee.call(e, o)) && c++;
+			continue;
+		}
+		if (u === null || d === null || typeof u != "object" || typeof d != "object") {
+			s[o] = d;
+			continue;
+		}
+		let f = D(u, d, n + 1);
+		s[o] = f, f === u && c++;
+	}
+	return i === o && c === i ? e : s;
+}
+function O(e, t) {
+	if (!t || Object.keys(e).length !== Object.keys(t).length) return !1;
+	for (let n in e) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+function te(e) {
+	return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function k(e) {
+	if (!ne(e)) return !1;
+	let t = e.constructor;
+	if (t === void 0) return !0;
+	let n = t.prototype;
+	return !(!ne(n) || !n.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function ne(e) {
+	return Object.prototype.toString.call(e) === "[object Object]";
+}
+function re(e) {
+	return new Promise((t) => {
+		p.setTimeout(t, e);
+	});
+}
+function A(e, t, n) {
+	return typeof n.structuralSharing == "function" ? n.structuralSharing(e, t) : n.structuralSharing === !1 ? t : D(e, t);
+}
+function ie(e) {
+	return e;
+}
+function ae(e, t, n = 0) {
+	let r = [...e, t];
+	return n && r.length > n ? r.slice(1) : r;
+}
+function oe(e, t, n = 0) {
+	let r = [t, ...e];
+	return n && r.length > n ? r.slice(0, -1) : r;
+}
+var j = /* @__PURE__ */ Symbol();
+function se(e, t) {
+	return !e.queryFn && t?.initialPromise ? () => t.initialPromise : !e.queryFn || e.queryFn === j ? () => Promise.reject(/* @__PURE__ */ Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function M(e, t) {
+	return typeof e == "function" ? e(...t) : !!e;
+}
+function ce(e, t, n) {
+	let r = !1, i;
+	return Object.defineProperty(e, "signal", {
+		enumerable: !0,
+		get: () => (i ??= t(), r ? i : (r = !0, i.aborted ? n() : i.addEventListener("abort", n, { once: !0 }), i))
+	}), e;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var N = /* @__PURE__ */ (() => {
+	let e = () => h;
+	return {
+		isServer() {
+			return e();
+		},
+		setIsServer(t) {
+			e = t;
+		}
+	};
+})();
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/thenable.js
+function P() {
+	let e, t, n = new Promise((n, r) => {
+		e = n, t = r;
+	});
+	n.status = "pending", n.catch(() => {});
+	function r(e) {
+		Object.assign(n, e), delete n.resolve, delete n.reject;
+	}
+	return n.resolve = (t) => {
+		r({
+			status: "fulfilled",
+			value: t
+		}), e(t);
+	}, n.reject = (e) => {
+		r({
+			status: "rejected",
+			reason: e
+		}), t(e);
+	}, n;
+}
+function le(e) {
+	let t;
+	if (e.then((e) => (t = e, e), g)?.catch(g), t !== void 0) return { data: t };
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/hydration.js
+function ue(e) {
+	return e;
+}
+function de(e) {
+	return {
+		mutationKey: e.options.mutationKey,
+		state: e.state,
+		...e.options.scope && { scope: e.options.scope },
+		...e.meta && { meta: e.meta }
+	};
+}
+function fe(e, t, n) {
+	let r = () => {
+		let r = e.promise?.then(t).catch((e) => n(e) ? Promise.reject(/* @__PURE__ */ Error("redacted")) : Promise.reject(e));
+		return r?.catch(g), r;
+	};
+	return {
+		dehydratedAt: Date.now(),
+		state: {
+			...e.state,
+			...e.state.data !== void 0 && { data: t(e.state.data) }
+		},
+		queryKey: e.queryKey,
+		queryHash: e.queryHash,
+		...e.state.status === "pending" && { promise: r() },
+		...e.meta && { meta: e.meta },
+		...e.queryType && { queryType: e.queryType }
+	};
+}
+function pe(e) {
+	return e.state.isPaused;
+}
+function me(e) {
+	return e.state.status === "success";
+}
+function he(e) {
+	return !0;
+}
+function ge(e, t = {}) {
+	let n = t.shouldDehydrateMutation ?? e.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? pe, r = e.getMutationCache().getAll().flatMap((e) => n(e) ? [de(e)] : []), i = t.shouldDehydrateQuery ?? e.getDefaultOptions().dehydrate?.shouldDehydrateQuery ?? me, a = t.shouldRedactErrors ?? e.getDefaultOptions().dehydrate?.shouldRedactErrors ?? he, o = t.serializeData ?? e.getDefaultOptions().dehydrate?.serializeData ?? ue;
+	return {
+		mutations: r,
+		queries: e.getQueryCache().getAll().flatMap((e) => i(e) ? [fe(e, o, a)] : [])
+	};
+}
+function F(e, t, n) {
+	if (typeof t != "object" || !t) return;
+	let r = e.getMutationCache(), i = e.getQueryCache(), a = n?.defaultOptions?.deserializeData ?? e.getDefaultOptions().hydrate?.deserializeData ?? ue, o = t.mutations || [], s = t.queries || [];
+	o.forEach(({ state: t, ...i }) => {
+		r.build(e, {
+			...e.getDefaultOptions().hydrate?.mutations,
+			...n?.defaultOptions?.mutations,
+			...i
+		}, t);
+	}), s.forEach(({ queryKey: t, state: r, queryHash: o, meta: s, promise: c, dehydratedAt: l, queryType: u }) => {
+		let d = c ? le(c) : void 0, f = r.data === void 0 ? d?.data : r.data, p = f === void 0 ? f : a(f), m = i.get(o), h = m?.state.status === "pending", _ = m?.state.fetchStatus === "fetching";
+		if (m) {
+			let e = d && l !== void 0 && l > m.state.dataUpdatedAt;
+			if (r.dataUpdatedAt > m.state.dataUpdatedAt || e) {
+				let { fetchStatus: e, ...t } = r;
+				m.setState({
+					...t,
+					data: p,
+					...r.status === "pending" && p !== void 0 && {
+						status: "success",
+						...!_ && { fetchStatus: "idle" }
+					}
+				});
+			}
+		} else m = i.build(e, {
+			...e.getDefaultOptions().hydrate?.queries,
+			...n?.defaultOptions?.queries,
+			queryKey: t,
+			queryHash: o,
+			meta: s,
+			_type: u
+		}, {
+			...r,
+			data: p,
+			fetchStatus: "idle",
+			status: r.status === "pending" && p !== void 0 ? "success" : r.status
+		});
+		c && !d && !h && !_ && (l === void 0 || l > m.state.dataUpdatedAt) && m.fetch(void 0, { initialPromise: Promise.resolve(c).then(a) }).catch(g);
+	});
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var _e = m;
+function ve() {
+	let e = [], t = 0, n = (e) => {
+		e();
+	}, r = (e) => {
+		e();
+	}, i = _e, a = (r) => {
+		t ? e.push(r) : i(() => {
+			n(r);
+		});
+	}, o = () => {
+		let t = e;
+		e = [], t.length && i(() => {
+			r(() => {
+				t.forEach((e) => {
+					n(e);
+				});
+			});
+		});
+	};
+	return {
+		batch: (e) => {
+			let n;
+			t++;
+			try {
+				n = e();
+			} finally {
+				t--, t || o();
+			}
+			return n;
+		},
+		batchCalls: (e) => (...t) => {
+			a(() => {
+				e(...t);
+			});
+		},
+		schedule: a,
+		setNotifyFunction: (e) => {
+			n = e;
+		},
+		setBatchNotifyFunction: (e) => {
+			r = e;
+		},
+		setScheduler: (e) => {
+			i = e;
+		}
+	};
+}
+var I = ve(), L = new class extends u {
+	#e = !0;
+	#t;
+	#n;
+	constructor() {
+		super(), this.#n = (e) => {
+			if (typeof window < "u" && window.addEventListener) {
+				let t = () => e(!0), n = () => e(!1);
+				return window.addEventListener("online", t, !1), window.addEventListener("offline", n, !1), () => {
+					window.removeEventListener("online", t), window.removeEventListener("offline", n);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		this.#t || this.setEventListener(this.#n);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (this.#t?.(), this.#t = void 0);
+	}
+	setEventListener(e) {
+		this.#n = e, this.#t?.(), this.#t = e(this.setOnline.bind(this));
+	}
+	setOnline(e) {
+		this.#e !== e && (this.#e = e, this.listeners.forEach((t) => {
+			t(e);
+		}));
+	}
+	isOnline() {
+		return this.#e;
+	}
+}();
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/retryer.js
+function ye(e) {
+	return Math.min(1e3 * 2 ** e, 3e4);
+}
+function be(e) {
+	return (e ?? "online") === "online" ? L.isOnline() : !0;
+}
+var R = class extends Error {
+	constructor(e) {
+		super("CancelledError"), this.revert = e?.revert, this.silent = e?.silent;
+	}
+};
+function xe(e) {
+	return e instanceof R;
+}
+function Se(e) {
+	let t = !1, n = 0, r, i = P(), a = () => i.status !== "pending", o = (t) => {
+		if (!a()) {
+			let n = new R(t);
+			p(n), e.onCancel?.(n);
+		}
+	}, s = () => {
+		t = !0;
+	}, c = () => {
+		t = !1;
+	}, l = () => d.isFocused() && (e.networkMode === "always" || L.isOnline()) && e.canRun(), u = () => be(e.networkMode) && e.canRun(), f = (e) => {
+		a() || (r?.(), i.resolve(e));
+	}, p = (e) => {
+		a() || (r?.(), i.reject(e));
+	}, m = () => new Promise((t) => {
+		r = (e) => {
+			(a() || l()) && t(e);
+		}, e.onPause?.();
+	}).then(() => {
+		r = void 0, a() || e.onContinue?.();
+	}), h = () => {
+		if (a()) return;
+		let r, i = n === 0 ? e.initialPromise : void 0;
+		try {
+			r = i ?? e.fn();
+		} catch (e) {
+			r = Promise.reject(e);
+		}
+		Promise.resolve(r).then(f).catch((r) => {
+			if (a()) return;
+			let i = e.retry ?? (N.isServer() ? 0 : 3), o = e.retryDelay ?? ye, s = typeof o == "function" ? o(n, r) : o, c = i === !0 || typeof i == "number" && n < i || typeof i == "function" && i(n, r);
+			if (t || !c) {
+				p(r);
+				return;
+			}
+			n++, e.onFail?.(n, r), re(s).then(() => l() ? void 0 : m()).then(() => {
+				t ? p(r) : h();
+			});
+		});
+	};
+	return {
+		promise: i,
+		status: () => i.status,
+		cancel: o,
+		continue: () => (r?.(), i),
+		cancelRetry: s,
+		continueRetry: c,
+		canStart: u,
+		start: () => (u() ? h() : m().then(h), i)
+	};
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/removable.js
+var Ce = class {
+	#e;
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout(), v(this.gcTime) && (this.#e = p.setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime));
+	}
+	updateGcTime(e) {
+		this.gcTime = Math.max(this.gcTime || 0, e ?? (N.isServer() ? Infinity : 300 * 1e3));
+	}
+	clearGcTimeout() {
+		this.#e !== void 0 && (p.clearTimeout(this.#e), this.#e = void 0);
+	}
+};
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+function we(e) {
+	return { onFetch: (t, n) => {
+		let r = t.options, i = t.fetchOptions?.meta?.fetchMore?.direction, a = t.state.data?.pages || [], o = t.state.data?.pageParams || [], s = {
+			pages: [],
+			pageParams: []
+		}, c = 0, l = async () => {
+			let n = !1, l = (e) => {
+				ce(e, () => t.signal, () => n = !0);
+			}, u = se(t.options, t.fetchOptions), d = async (e, r, i) => {
+				if (n) return Promise.reject(t.signal.reason);
+				if (r == null && e.pages.length) return Promise.resolve(e);
+				let a = await u((() => {
+					let e = {
+						client: t.client,
+						queryKey: t.queryKey,
+						pageParam: r,
+						direction: i ? "backward" : "forward",
+						meta: t.options.meta
+					};
+					return l(e), e;
+				})()), { maxPages: o } = t.options, s = i ? oe : ae;
+				return {
+					pages: s(e.pages, a, o),
+					pageParams: s(e.pageParams, r, o)
+				};
+			};
+			if (i && a.length) {
+				let e = i === "backward", t = e ? Te : z, n = {
+					pages: a,
+					pageParams: o
+				};
+				s = await d(n, t(r, n), e);
+			} else {
+				let t = e ?? a.length;
+				do {
+					let e = c === 0 ? o[0] ?? r.initialPageParam : z(r, s);
+					if (c > 0 && e == null) break;
+					s = await d(s, e), c++;
+				} while (c < t);
+			}
+			return s;
+		};
+		t.options.persister ? t.fetchFn = () => t.options.persister?.(l, {
+			client: t.client,
+			queryKey: t.queryKey,
+			meta: t.options.meta,
+			signal: t.signal
+		}, n) : t.fetchFn = l;
+	} };
+}
+function z(e, { pages: t, pageParams: n }) {
+	let r = t.length - 1;
+	return t.length > 0 ? e.getNextPageParam(t[r], t, n[r], n) : void 0;
+}
+function Te(e, { pages: t, pageParams: n }) {
+	return t.length > 0 ? e.getPreviousPageParam?.(t[0], t, n[0], n) : void 0;
+}
+function Ee(e, t) {
+	return t ? z(e, t) != null : !1;
+}
+function De(e, t) {
+	return !t || !e.getPreviousPageParam ? !1 : Te(e, t) != null;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/query.js
+var Oe = class extends Ce {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	constructor(e) {
+		super(), this.#s = !1, this.#o = e.defaultOptions, this.setOptions(e.options), this.observers = [], this.#i = e.client, this.#r = this.#i.getQueryCache(), this.queryKey = e.queryKey, this.queryHash = e.queryHash, this.#t = je(this.options), this.state = e.state ?? this.#t, this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get queryType() {
+		return this.#e;
+	}
+	get promise() {
+		return this.#a?.promise;
+	}
+	setOptions(e) {
+		if (this.options = {
+			...this.#o,
+			...e
+		}, e?._type && (this.#e = e._type), this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+			let e = je(this.options);
+			e.data !== void 0 && (this.setState(Ae(e.data, e.dataUpdatedAt)), this.#t = e);
+		}
+	}
+	optionalRemove() {
+		!this.observers.length && this.state.fetchStatus === "idle" && this.#r.remove(this);
+	}
+	setData(e, t) {
+		let n = A(this.state.data, e, this.options);
+		return this.#l({
+			data: n,
+			type: "success",
+			dataUpdatedAt: t?.updatedAt,
+			manual: t?.manual
+		}), n;
+	}
+	setState(e) {
+		this.#l({
+			type: "setState",
+			state: e
+		});
+	}
+	cancel(e) {
+		let t = this.#a?.promise;
+		return this.#a?.cancel(e), t ? t.then(g).catch(g) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy(), this.cancel({ silent: !0 });
+	}
+	get resetState() {
+		return this.#t;
+	}
+	reset() {
+		this.destroy(), this.setState(this.resetState);
+	}
+	isActive() {
+		return this.observers.some((e) => x(e.options.enabled, this) !== !1);
+	}
+	isDisabled() {
+		return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === j || !this.isFetched();
+	}
+	isFetched() {
+		return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+	}
+	isStatic() {
+		return this.getObserversCount() > 0 ? this.observers.some((e) => b(e.options.staleTime, this) === "static") : !1;
+	}
+	isStale() {
+		return this.getObserversCount() > 0 ? this.observers.some((e) => e.getCurrentResult().isStale) : this.state.data === void 0 || this.state.isInvalidated;
+	}
+	isStaleByTime(e = 0) {
+		return this.state.data === void 0 ? !0 : e === "static" ? !1 : this.state.isInvalidated ? !0 : !y(this.state.dataUpdatedAt, e);
+	}
+	onFocus() {
+		this.observers.find((e) => e.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), this.#a?.continue();
+	}
+	onOnline() {
+		this.observers.find((e) => e.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), this.#a?.continue();
+	}
+	addObserver(e) {
+		this.observers.includes(e) || (this.observers.push(e), this.clearGcTimeout(), this.#r.notify({
+			type: "observerAdded",
+			query: this,
+			observer: e
+		}));
+	}
+	removeObserver(e) {
+		this.observers.includes(e) && (this.observers = this.observers.filter((t) => t !== e), this.observers.length || (this.#a && (this.#s || this.#c() ? this.#a.cancel({ revert: !0 }) : this.#a.cancelRetry()), this.scheduleGc()), this.#r.notify({
+			type: "observerRemoved",
+			query: this,
+			observer: e
+		}));
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	#c() {
+		return this.state.fetchStatus === "paused" && this.state.status === "pending";
+	}
+	invalidate() {
+		this.state.isInvalidated || this.#l({ type: "invalidate" });
+	}
+	async fetch(e, t) {
+		if (this.state.fetchStatus !== "idle" && this.#a?.status() !== "rejected") {
+			if (this.state.data !== void 0 && t?.cancelRefetch) this.cancel({ silent: !0 });
+			else if (this.#a) return this.#a.continueRetry(), this.#a.promise;
+		}
+		if (e && this.setOptions(e), !this.options.queryFn) {
+			let e = this.observers.find((e) => e.options.queryFn);
+			e && this.setOptions(e.options);
+		}
+		let n = new AbortController(), r = (e) => {
+			Object.defineProperty(e, "signal", {
+				enumerable: !0,
+				get: () => (this.#s = !0, n.signal)
+			});
+		}, i = () => {
+			let e = se(this.options, t), n = (() => {
+				let e = {
+					client: this.#i,
+					queryKey: this.queryKey,
+					meta: this.meta
+				};
+				return r(e), e;
+			})();
+			return this.#s = !1, this.options.persister ? this.options.persister(e, n, this) : e(n);
+		}, a = (() => {
+			let e = {
+				fetchOptions: t,
+				options: this.options,
+				queryKey: this.queryKey,
+				client: this.#i,
+				state: this.state,
+				fetchFn: i
+			};
+			return r(e), e;
+		})();
+		(this.#e === "infinite" ? we(this.options.pages) : this.options.behavior)?.onFetch(a, this), this.#n = this.state, (this.state.fetchStatus === "idle" || this.state.fetchMeta !== a.fetchOptions?.meta) && this.#l({
+			type: "fetch",
+			meta: a.fetchOptions?.meta
+		}), this.#a = Se({
+			initialPromise: t?.initialPromise,
+			fn: a.fetchFn,
+			onCancel: (e) => {
+				e instanceof R && e.revert && this.setState({
+					...this.#n,
+					fetchStatus: "idle"
+				}), n.abort();
+			},
+			onFail: (e, t) => {
+				this.#l({
+					type: "failed",
+					failureCount: e,
+					error: t
+				});
+			},
+			onPause: () => {
+				this.#l({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#l({ type: "continue" });
+			},
+			retry: a.options.retry,
+			retryDelay: a.options.retryDelay,
+			networkMode: a.options.networkMode,
+			canRun: () => !0
+		});
+		try {
+			let e = await this.#a.start();
+			if (e === void 0) throw Error(`${this.queryHash} data is undefined`);
+			return this.setData(e), this.#r.config.onSuccess?.(e, this), this.#r.config.onSettled?.(e, this.state.error, this), e;
+		} catch (e) {
+			if (e instanceof R) {
+				if (e.silent) return this.#a.promise;
+				if (e.revert) {
+					if (this.state.data === void 0) throw e;
+					return this.state.data;
+				}
+			}
+			throw this.#l({
+				type: "error",
+				error: e
+			}), this.#r.config.onError?.(e, this), this.#r.config.onSettled?.(this.state.data, e, this), e;
+		} finally {
+			this.scheduleGc();
+		}
+	}
+	#l(e) {
+		let t = (t) => {
+			switch (e.type) {
+				case "failed": return {
+					...t,
+					fetchFailureCount: e.failureCount,
+					fetchFailureReason: e.error
+				};
+				case "pause": return {
+					...t,
+					fetchStatus: "paused"
+				};
+				case "continue": return {
+					...t,
+					fetchStatus: "fetching"
+				};
+				case "fetch": return {
+					...t,
+					...ke(t.data, this.options),
+					fetchMeta: e.meta ?? null
+				};
+				case "success":
+					let n = {
+						...t,
+						...Ae(e.data, e.dataUpdatedAt),
+						dataUpdateCount: t.dataUpdateCount + 1,
+						...!e.manual && {
+							fetchStatus: "idle",
+							fetchFailureCount: 0,
+							fetchFailureReason: null
+						}
+					};
+					return this.#n = e.manual ? n : void 0, n;
+				case "error":
+					let r = e.error;
+					return {
+						...t,
+						error: r,
+						errorUpdateCount: t.errorUpdateCount + 1,
+						errorUpdatedAt: Date.now(),
+						fetchFailureCount: t.fetchFailureCount + 1,
+						fetchFailureReason: r,
+						fetchStatus: "idle",
+						status: "error",
+						isInvalidated: !0
+					};
+				case "invalidate": return {
+					...t,
+					isInvalidated: !0
+				};
+				case "setState": return {
+					...t,
+					...e.state
+				};
+			}
+		};
+		this.state = t(this.state), I.batch(() => {
+			this.observers.forEach((e) => {
+				e.onQueryUpdate();
+			}), this.#r.notify({
+				query: this,
+				type: "updated",
+				action: e
+			});
+		});
+	}
+};
+function ke(e, t) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: be(t.networkMode) ? "fetching" : "paused",
+		...e === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function Ae(e, t) {
+	return {
+		data: e,
+		dataUpdatedAt: t ?? Date.now(),
+		error: null,
+		isInvalidated: !1,
+		status: "success"
+	};
+}
+function je(e) {
+	let t = typeof e.initialData == "function" ? e.initialData() : e.initialData, n = t !== void 0, r = n ? typeof e.initialDataUpdatedAt == "function" ? e.initialDataUpdatedAt() : e.initialDataUpdatedAt : 0;
+	return {
+		data: t,
+		dataUpdateCount: 0,
+		dataUpdatedAt: n ? r ?? Date.now() : 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: !1,
+		status: n ? "success" : "pending",
+		fetchStatus: "idle"
+	};
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/queryObserver.js
+var B = class extends u {
+	constructor(e, t) {
+		super(), this.options = t, this.#e = e, this.#s = null, this.#o = P(), this.bindMethods(), this.setOptions(t);
+	}
+	#e;
+	#t = void 0;
+	#n = void 0;
+	#r = void 0;
+	#i;
+	#a;
+	#o;
+	#s;
+	#c;
+	#l;
+	#u;
+	#d;
+	#f;
+	#p;
+	#m = /* @__PURE__ */ new Set();
+	bindMethods() {
+		this.refetch = this.refetch.bind(this);
+	}
+	onSubscribe() {
+		this.listeners.size === 1 && (this.#t.addObserver(this), Ne(this.#t, this.options) ? this.#h() : this.updateResult(), this.#y());
+	}
+	onUnsubscribe() {
+		this.hasListeners() || this.destroy();
+	}
+	shouldFetchOnReconnect() {
+		return V(this.#t, this.options, this.options.refetchOnReconnect);
+	}
+	shouldFetchOnWindowFocus() {
+		return V(this.#t, this.options, this.options.refetchOnWindowFocus);
+	}
+	destroy() {
+		this.listeners = /* @__PURE__ */ new Set(), this.#b(), this.#x(), this.#t.removeObserver(this);
+	}
+	setOptions(e) {
+		let t = this.options, n = this.#t;
+		if (this.options = this.#e.defaultQueryOptions(e), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof x(this.options.enabled, this.#t) != "boolean") throw Error("Expected enabled to be a boolean or a callback that returns a boolean");
+		this.#S(), this.#t.setOptions(this.options), t._defaulted && !O(this.options, t) && this.#e.getQueryCache().notify({
+			type: "observerOptionsUpdated",
+			query: this.#t,
+			observer: this
+		});
+		let r = this.hasListeners();
+		r && H(this.#t, n, this.options, t) && this.#h(), this.updateResult(), r && (this.#t !== n || x(this.options.enabled, this.#t) !== x(t.enabled, this.#t) || b(this.options.staleTime, this.#t) !== b(t.staleTime, this.#t)) && this.#g();
+		let i = this.#_();
+		r && (this.#t !== n || x(this.options.enabled, this.#t) !== x(t.enabled, this.#t) || i !== this.#p) && this.#v(i);
+	}
+	getOptimisticResult(e) {
+		let t = this.#e.getQueryCache().build(this.#e, e), n = this.createResult(t, e);
+		return Pe(this, n) && (this.#r = n, this.#a = this.options, this.#i = this.#t.state), n;
+	}
+	getCurrentResult() {
+		return this.#r;
+	}
+	trackResult(e, t) {
+		return new Proxy(e, { get: (e, n) => (this.trackProp(n), t?.(n), n === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && this.#o.status === "pending" && this.#o.reject(/* @__PURE__ */ Error("experimental_prefetchInRender feature flag is not enabled"))), Reflect.get(e, n)) });
+	}
+	trackProp(e) {
+		this.#m.add(e);
+	}
+	getCurrentQuery() {
+		return this.#t;
+	}
+	refetch({ ...e } = {}) {
+		return this.fetch({ ...e });
+	}
+	fetchOptimistic(e) {
+		let t = this.#e.defaultQueryOptions(e), n = this.#e.getQueryCache().build(this.#e, t);
+		return n.fetch().then(() => this.createResult(n, t));
+	}
+	fetch(e) {
+		return this.#h({
+			...e,
+			cancelRefetch: e.cancelRefetch ?? !0
+		}).then(() => (this.updateResult(), this.#r));
+	}
+	#h(e) {
+		this.#S();
+		let t = this.#t.fetch(this.options, e);
+		return e?.throwOnError || (t = t.catch(g)), t;
+	}
+	#g() {
+		this.#b();
+		let e = b(this.options.staleTime, this.#t);
+		if (N.isServer() || this.#r.isStale || !v(e)) return;
+		let t = y(this.#r.dataUpdatedAt, e) + 1;
+		this.#d = p.setTimeout(() => {
+			this.#r.isStale || this.updateResult();
+		}, t);
+	}
+	#_() {
+		return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(this.#t) : this.options.refetchInterval) ?? !1;
+	}
+	#v(e) {
+		this.#x(), this.#p = e, !(N.isServer() || x(this.options.enabled, this.#t) === !1 || !v(this.#p) || this.#p === 0) && (this.#f = p.setInterval(() => {
+			(this.options.refetchIntervalInBackground || d.isFocused()) && this.#h();
+		}, this.#p));
+	}
+	#y() {
+		this.#g(), this.#v(this.#_());
+	}
+	#b() {
+		this.#d !== void 0 && (p.clearTimeout(this.#d), this.#d = void 0);
+	}
+	#x() {
+		this.#f !== void 0 && (p.clearInterval(this.#f), this.#f = void 0);
+	}
+	createResult(e, t) {
+		let n = this.#t, r = this.options, i = this.#r, a = this.#i, o = this.#a, s = e === n ? this.#n : e.state, { state: c } = e, l = { ...c }, u = !1, d;
+		if (t._optimisticResults) {
+			let i = this.hasListeners(), a = !i && Ne(e, t), o = i && H(e, n, t, r);
+			(a || o) && (l = {
+				...l,
+				...ke(c.data, e.options)
+			}), t._optimisticResults === "isRestoring" && (l.fetchStatus = "idle");
+		}
+		let { error: f, errorUpdatedAt: p, status: m } = l;
+		d = l.data;
+		let h = !1;
+		if (t.placeholderData !== void 0 && d === void 0 && m === "pending") {
+			let e;
+			i?.isPlaceholderData && t.placeholderData === o?.placeholderData ? (e = i.data, h = !0) : e = typeof t.placeholderData == "function" ? t.placeholderData(this.#u?.state.data, this.#u) : t.placeholderData, e !== void 0 && (m = "success", d = A(i?.data, e, t), u = !0);
+		}
+		if (t.select && d !== void 0 && !h) if (i && d === a?.data && t.select === this.#c) d = this.#l;
+		else try {
+			this.#c = t.select, d = t.select(d), d = A(i?.data, d, t), this.#l = d, this.#s = null;
+		} catch (e) {
+			this.#s = e;
+		}
+		this.#s && (f = this.#s, d = this.#l, p = Date.now(), m = "error");
+		let g = l.fetchStatus === "fetching", _ = m === "pending", v = m === "error", y = _ && g, b = d !== void 0, S = {
+			status: m,
+			fetchStatus: l.fetchStatus,
+			isPending: _,
+			isSuccess: m === "success",
+			isError: v,
+			isInitialLoading: y,
+			isLoading: y,
+			data: d,
+			dataUpdatedAt: l.dataUpdatedAt,
+			error: f,
+			errorUpdatedAt: p,
+			failureCount: l.fetchFailureCount,
+			failureReason: l.fetchFailureReason,
+			errorUpdateCount: l.errorUpdateCount,
+			isFetched: e.isFetched(),
+			isFetchedAfterMount: l.dataUpdateCount > s.dataUpdateCount || l.errorUpdateCount > s.errorUpdateCount,
+			isFetching: g,
+			isRefetching: g && !_,
+			isLoadingError: v && !b,
+			isPaused: l.fetchStatus === "paused",
+			isPlaceholderData: u,
+			isRefetchError: v && b,
+			isStale: U(e, t),
+			refetch: this.refetch,
+			promise: this.#o,
+			isEnabled: x(t.enabled, e) !== !1
+		};
+		if (this.options.experimental_prefetchInRender) {
+			let t = S.data !== void 0, r = S.status === "error" && !t, i = (e) => {
+				r ? e.reject(S.error) : t && e.resolve(S.data);
+			}, a = () => {
+				i(this.#o = S.promise = P());
+			}, o = this.#o;
+			switch (o.status) {
+				case "pending":
+					e.queryHash === n.queryHash && i(o);
+					break;
+				case "fulfilled":
+					(r || S.data !== o.value) && a();
+					break;
+				case "rejected":
+					(!r || S.error !== o.reason) && a();
+					break;
+			}
+		}
+		return S;
+	}
+	updateResult() {
+		let e = this.#r, t = this.createResult(this.#t, this.options);
+		this.#i = this.#t.state, this.#a = this.options, this.#i.data !== void 0 && (this.#u = this.#t), !O(t, e) && (this.#r = t, this.#C({ listeners: (() => {
+			if (!e) return !0;
+			let { notifyOnChangeProps: t } = this.options, n = typeof t == "function" ? t() : t;
+			if (n === "all" || !n && !this.#m.size) return !0;
+			let r = new Set(n ?? this.#m);
+			return this.options.throwOnError && r.add("error"), Object.keys(this.#r).some((t) => {
+				let n = t;
+				return this.#r[n] !== e[n] && r.has(n);
+			});
+		})() }));
+	}
+	#S() {
+		let e = this.#e.getQueryCache().build(this.#e, this.options);
+		if (e === this.#t) return;
+		let t = this.#t;
+		this.#t = e, this.#n = e.state, this.hasListeners() && (t?.removeObserver(this), e.addObserver(this));
+	}
+	onQueryUpdate() {
+		this.updateResult(), this.hasListeners() && this.#y();
+	}
+	#C(e) {
+		I.batch(() => {
+			e.listeners && this.listeners.forEach((e) => {
+				e(this.#r);
+			}), this.#e.getQueryCache().notify({
+				query: this.#t,
+				type: "observerResultsUpdated"
+			});
+		});
+	}
+};
+function Me(e, t) {
+	return x(t.enabled, e) !== !1 && e.state.data === void 0 && !(e.state.status === "error" && x(t.retryOnMount, e) === !1);
+}
+function Ne(e, t) {
+	return Me(e, t) || e.state.data !== void 0 && V(e, t, t.refetchOnMount);
+}
+function V(e, t, n) {
+	if (x(t.enabled, e) !== !1 && b(t.staleTime, e) !== "static") {
+		let r = typeof n == "function" ? n(e) : n;
+		return r === "always" || r !== !1 && U(e, t);
+	}
+	return !1;
+}
+function H(e, t, n, r) {
+	return (e !== t || x(r.enabled, e) === !1) && (!n.suspense || e.state.status !== "error") && U(e, n);
+}
+function U(e, t) {
+	return x(t.enabled, e) !== !1 && e.isStaleByTime(b(t.staleTime, e));
+}
+function Pe(e, t) {
+	return !O(e.getCurrentResult(), t);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js
+var W = class extends B {
+	constructor(e, t) {
+		super(e, t);
+	}
+	bindMethods() {
+		super.bindMethods(), this.fetchNextPage = this.fetchNextPage.bind(this), this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+	}
+	setOptions(e) {
+		e._type = "infinite", super.setOptions(e);
+	}
+	getOptimisticResult(e) {
+		return e._type = "infinite", super.getOptimisticResult(e);
+	}
+	fetchNextPage(e) {
+		return this.fetch({
+			...e,
+			meta: { fetchMore: { direction: "forward" } }
+		});
+	}
+	fetchPreviousPage(e) {
+		return this.fetch({
+			...e,
+			meta: { fetchMore: { direction: "backward" } }
+		});
+	}
+	createResult(e, t) {
+		let { state: n } = e, r = super.createResult(e, t), { isFetching: i, isRefetching: a, isError: o, isRefetchError: s } = r, c = n.fetchMeta?.fetchMore?.direction, l = o && c === "forward", u = i && c === "forward", d = o && c === "backward", f = i && c === "backward";
+		return {
+			...r,
+			fetchNextPage: this.fetchNextPage,
+			fetchPreviousPage: this.fetchPreviousPage,
+			hasNextPage: Ee(t, n.data),
+			hasPreviousPage: De(t, n.data),
+			isFetchNextPageError: l,
+			isFetchingNextPage: u,
+			isFetchPreviousPageError: d,
+			isFetchingPreviousPage: f,
+			isRefetchError: s && !l && !d,
+			isRefetching: a && !u && !f
+		};
+	}
+}, Fe = class extends Ce {
+	#e;
+	#t;
+	#n;
+	#r;
+	constructor(e) {
+		super(), this.#e = e.client, this.mutationId = e.mutationId, this.#n = e.mutationCache, this.#t = [], this.state = e.state || Ie(), this.setOptions(e.options), this.scheduleGc();
+	}
+	setOptions(e) {
+		this.options = e, this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(e) {
+		this.#t.includes(e) || (this.#t.push(e), this.clearGcTimeout(), this.#n.notify({
+			type: "observerAdded",
+			mutation: this,
+			observer: e
+		}));
+	}
+	removeObserver(e) {
+		this.#t = this.#t.filter((t) => t !== e), this.scheduleGc(), this.#n.notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer: e
+		});
+	}
+	optionalRemove() {
+		this.#t.length || (this.state.status === "pending" ? this.scheduleGc() : this.#n.remove(this));
+	}
+	continue() {
+		return this.#r?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(e) {
+		let t = () => {
+			this.#i({ type: "continue" });
+		}, n = {
+			client: this.#e,
+			meta: this.options.meta,
+			mutationKey: this.options.mutationKey
+		};
+		this.#r = Se({
+			fn: () => this.options.mutationFn ? this.options.mutationFn(e, n) : Promise.reject(/* @__PURE__ */ Error("No mutationFn found")),
+			onFail: (e, t) => {
+				this.#i({
+					type: "failed",
+					failureCount: e,
+					error: t
+				});
+			},
+			onPause: () => {
+				this.#i({ type: "pause" });
+			},
+			onContinue: t,
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => this.#n.canRun(this)
+		});
+		let r = this.state.status === "pending", i = !this.#r.canStart();
+		try {
+			if (r) t();
+			else {
+				this.#i({
+					type: "pending",
+					variables: e,
+					isPaused: i
+				}), this.#n.config.onMutate && await this.#n.config.onMutate(e, this, n);
+				let t = await this.options.onMutate?.(e, n);
+				t !== this.state.context && this.#i({
+					type: "pending",
+					context: t,
+					variables: e,
+					isPaused: i
+				});
+			}
+			let a = await this.#r.start();
+			return await this.#n.config.onSuccess?.(a, e, this.state.context, this, n), await this.options.onSuccess?.(a, e, this.state.context, n), await this.#n.config.onSettled?.(a, null, this.state.variables, this.state.context, this, n), await this.options.onSettled?.(a, null, e, this.state.context, n), this.#i({
+				type: "success",
+				data: a
+			}), a;
+		} catch (t) {
+			try {
+				await this.#n.config.onError?.(t, e, this.state.context, this, n);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.options.onError?.(t, e, this.state.context, n);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.#n.config.onSettled?.(void 0, t, this.state.variables, this.state.context, this, n);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.options.onSettled?.(void 0, t, e, this.state.context, n);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			throw this.#i({
+				type: "error",
+				error: t
+			}), t;
+		} finally {
+			this.#n.runNext(this);
+		}
+	}
+	#i(e) {
+		let t = (t) => {
+			switch (e.type) {
+				case "failed": return {
+					...t,
+					failureCount: e.failureCount,
+					failureReason: e.error
+				};
+				case "pause": return {
+					...t,
+					isPaused: !0
+				};
+				case "continue": return {
+					...t,
+					isPaused: !1
+				};
+				case "pending": return {
+					...t,
+					context: e.context,
+					data: void 0,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					isPaused: e.isPaused,
+					status: "pending",
+					variables: e.variables,
+					submittedAt: Date.now()
+				};
+				case "success": return {
+					...t,
+					data: e.data,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					status: "success",
+					isPaused: !1
+				};
+				case "error": return {
+					...t,
+					data: void 0,
+					error: e.error,
+					failureCount: t.failureCount + 1,
+					failureReason: e.error,
+					isPaused: !1,
+					status: "error"
+				};
+			}
+		};
+		this.state = t(this.state), I.batch(() => {
+			this.#t.forEach((t) => {
+				t.onMutationUpdate(e);
+			}), this.#n.notify({
+				mutation: this,
+				type: "updated",
+				action: e
+			});
+		});
+	}
+};
+function Ie() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: !1,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/mutationCache.js
+var Le = class extends u {
+	constructor(e = {}) {
+		super(), this.config = e, this.#e = /* @__PURE__ */ new Set(), this.#t = /* @__PURE__ */ new Map(), this.#n = 0;
+	}
+	#e;
+	#t;
+	#n;
+	build(e, t, n) {
+		let r = new Fe({
+			client: e,
+			mutationCache: this,
+			mutationId: ++this.#n,
+			options: e.defaultMutationOptions(t),
+			state: n
+		});
+		return this.add(r), r;
+	}
+	add(e) {
+		this.#e.add(e);
+		let t = G(e);
+		if (typeof t == "string") {
+			let n = this.#t.get(t);
+			n ? n.push(e) : this.#t.set(t, [e]);
+		}
+		this.notify({
+			type: "added",
+			mutation: e
+		});
+	}
+	remove(e) {
+		if (this.#e.delete(e)) {
+			let t = G(e);
+			if (typeof t == "string") {
+				let n = this.#t.get(t);
+				if (n) if (n.length > 1) {
+					let t = n.indexOf(e);
+					t !== -1 && n.splice(t, 1);
+				} else n[0] === e && this.#t.delete(t);
+			}
+		}
+		this.notify({
+			type: "removed",
+			mutation: e
+		});
+	}
+	canRun(e) {
+		let t = G(e);
+		if (typeof t == "string") {
+			let n = this.#t.get(t)?.find((e) => e.state.status === "pending");
+			return !n || n === e;
+		} else return !0;
+	}
+	runNext(e) {
+		let t = G(e);
+		return typeof t == "string" ? (this.#t.get(t)?.find((t) => t !== e && t.state.isPaused))?.continue() ?? Promise.resolve() : Promise.resolve();
+	}
+	clear() {
+		I.batch(() => {
+			this.#e.forEach((e) => {
+				this.notify({
+					type: "removed",
+					mutation: e
+				});
+			}), this.#e.clear(), this.#t.clear();
+		});
+	}
+	getAll() {
+		return Array.from(this.#e);
+	}
+	find(e) {
+		let t = {
+			exact: !0,
+			...e
+		};
+		return this.getAll().find((e) => C(t, e));
+	}
+	findAll(e = {}) {
+		return this.getAll().filter((t) => C(e, t));
+	}
+	notify(e) {
+		I.batch(() => {
+			this.listeners.forEach((t) => {
+				t(e);
+			});
+		});
+	}
+	resumePausedMutations() {
+		let e = this.getAll().filter((e) => e.state.isPaused);
+		return I.batch(() => Promise.all(e.map((e) => e.continue().catch(g))));
+	}
+};
+function G(e) {
+	return e.options.scope?.id;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+var Re = class extends u {
+	#e;
+	#t = void 0;
+	#n;
+	#r;
+	constructor(e, t) {
+		super(), this.#e = e, this.setOptions(t), this.bindMethods(), this.#i();
+	}
+	bindMethods() {
+		this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+	}
+	setOptions(e) {
+		let t = this.options;
+		this.options = this.#e.defaultMutationOptions(e), O(this.options, t) || this.#e.getMutationCache().notify({
+			type: "observerOptionsUpdated",
+			mutation: this.#n,
+			observer: this
+		}), t?.mutationKey && this.options.mutationKey && T(t.mutationKey) !== T(this.options.mutationKey) ? this.reset() : this.#n?.state.status === "pending" && this.#n.setOptions(this.options);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || this.#n?.removeObserver(this);
+	}
+	onMutationUpdate(e) {
+		this.#i(), this.#a(e);
+	}
+	getCurrentResult() {
+		return this.#t;
+	}
+	reset() {
+		this.#n?.removeObserver(this), this.#n = void 0, this.#i(), this.#a();
+	}
+	mutate(e, t) {
+		return this.#r = t, this.#n?.removeObserver(this), this.#n = this.#e.getMutationCache().build(this.#e, this.options), this.#n.addObserver(this), this.#n.execute(e);
+	}
+	#i() {
+		let e = this.#n?.state ?? Ie();
+		this.#t = {
+			...e,
+			isPending: e.status === "pending",
+			isSuccess: e.status === "success",
+			isError: e.status === "error",
+			isIdle: e.status === "idle",
+			mutate: this.mutate,
+			reset: this.reset
+		};
+	}
+	#a(e) {
+		I.batch(() => {
+			if (this.#r && this.hasListeners()) {
+				let t = this.#t.variables, n = this.#t.context, r = {
+					client: this.#e,
+					meta: this.options.meta,
+					mutationKey: this.options.mutationKey
+				};
+				if (e?.type === "success") {
+					try {
+						this.#r.onSuccess?.(e.data, t, n, r);
+					} catch (e) {
+						Promise.reject(e);
+					}
+					try {
+						this.#r.onSettled?.(e.data, null, t, n, r);
+					} catch (e) {
+						Promise.reject(e);
+					}
+				} else if (e?.type === "error") {
+					try {
+						this.#r.onError?.(e.error, t, n, r);
+					} catch (e) {
+						Promise.reject(e);
+					}
+					try {
+						this.#r.onSettled?.(void 0, e.error, t, n, r);
+					} catch (e) {
+						Promise.reject(e);
+					}
+				}
+			}
+			this.listeners.forEach((e) => {
+				e(this.#t);
+			});
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/queriesObserver.js
+function ze(e, t) {
+	let n = new Set(t);
+	return e.filter((e) => !n.has(e));
+}
+function Be(e, t, n) {
+	let r = e.slice(0);
+	return r[t] = n, r;
+}
+var Ve = class extends u {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	#c;
+	#l = [];
+	constructor(e, t, n) {
+		super(), this.#e = e, this.#r = n, this.#n = [], this.#i = [], this.#t = [], this.setQueries(t);
+	}
+	onSubscribe() {
+		this.listeners.size === 1 && this.#i.forEach((e) => {
+			e.subscribe((t) => {
+				this.#m(e, t);
+			});
+		});
+	}
+	onUnsubscribe() {
+		this.listeners.size || this.destroy();
+	}
+	destroy() {
+		this.listeners = /* @__PURE__ */ new Set(), this.#i.forEach((e) => {
+			e.destroy();
+		});
+	}
+	setQueries(e, t) {
+		this.#n = e, this.#r = t, I.batch(() => {
+			let e = this.#i, t = this.#p(this.#n);
+			t.forEach((e) => e.observer.setOptions(e.defaultedQueryOptions));
+			let n = t.map((e) => e.observer), r = n.map((e) => e.getCurrentResult()), i = e.length !== n.length, a = n.some((t, n) => t !== e[n]), o = i || a, s = o ? !0 : r.some((e, t) => {
+				let n = this.#t[t];
+				return !n || !O(e, n);
+			});
+			!o && !s || (o && (this.#l = t, this.#i = n), this.#t = r, this.hasListeners() && (o && (ze(e, n).forEach((e) => {
+				e.destroy();
+			}), ze(n, e).forEach((e) => {
+				e.subscribe((t) => {
+					this.#m(e, t);
+				});
+			})), this.#h()));
+		});
+	}
+	getCurrentResult() {
+		return this.#t;
+	}
+	getQueries() {
+		return this.#i.map((e) => e.getCurrentQuery());
+	}
+	getObservers() {
+		return this.#i;
+	}
+	getOptimisticResult(e, t) {
+		let n = this.#p(e), r = n.map((e) => e.observer.getOptimisticResult(e.defaultedQueryOptions)), i = n.map((e) => e.defaultedQueryOptions.queryHash);
+		return [
+			r,
+			(e) => this.#d(e ?? r, t, i),
+			() => this.#u(r, n)
+		];
+	}
+	#u(e, t) {
+		return t.map((n, r) => {
+			let i = e[r];
+			return n.defaultedQueryOptions.notifyOnChangeProps ? i : n.observer.trackResult(i, (e) => {
+				t.forEach((t) => {
+					t.observer.trackProp(e);
+				});
+			});
+		});
+	}
+	#d(e, t, n) {
+		if (t) {
+			let r = this.#c, i = n !== void 0 && r !== void 0 && (r.length !== n.length || n.some((e, t) => e !== r[t]));
+			return (!this.#a || this.#t !== this.#s || i || t !== this.#o) && (this.#o = t, this.#s = this.#t, n !== void 0 && (this.#c = n), this.#a = D(this.#a, t(e))), this.#a;
+		}
+		return e;
+	}
+	#f() {
+		return this.#r?.combine !== void 0 && this.#i.some((e, t) => e.options.suspense && this.#t[t]?.data === void 0);
+	}
+	#p(e) {
+		let t = /* @__PURE__ */ new Map();
+		this.#i.forEach((e) => {
+			let n = e.options.queryHash;
+			if (!n) return;
+			let r = t.get(n);
+			r ? r.push(e) : t.set(n, [e]);
+		});
+		let n = [];
+		return e.forEach((e) => {
+			let r = this.#e.defaultQueryOptions(e), i = t.get(r.queryHash)?.shift() ?? new B(this.#e, r);
+			n.push({
+				defaultedQueryOptions: r,
+				observer: i
+			});
+		}), n;
+	}
+	#m(e, t) {
+		let n = this.#i.indexOf(e);
+		n !== -1 && (this.#t = Be(this.#t, n, t), this.#h());
+	}
+	#h() {
+		if (this.hasListeners()) {
+			let e = this.#u(this.#t, this.#l), t = this.#f(), n = this.#a, r = t ? n : this.#d(e, this.#r?.combine);
+			(t || n !== r) && I.batch(() => {
+				this.listeners.forEach((e) => {
+					e(this.#t);
+				});
+			});
+		}
+	}
+}, He = class extends u {
+	constructor(e = {}) {
+		super(), this.config = e, this.#e = /* @__PURE__ */ new Map();
+	}
+	#e;
+	build(e, t, n) {
+		let r = t.queryKey, i = t.queryHash ?? w(r, t), a = this.get(i);
+		return a || (a = new Oe({
+			client: e,
+			queryKey: r,
+			queryHash: i,
+			options: e.defaultQueryOptions(t),
+			state: n,
+			defaultOptions: e.getQueryDefaults(r)
+		}), this.add(a)), a;
+	}
+	add(e) {
+		this.#e.has(e.queryHash) || (this.#e.set(e.queryHash, e), this.notify({
+			type: "added",
+			query: e
+		}));
+	}
+	remove(e) {
+		let t = this.#e.get(e.queryHash);
+		t && (e.destroy(), t === e && this.#e.delete(e.queryHash), this.notify({
+			type: "removed",
+			query: e
+		}));
+	}
+	clear() {
+		I.batch(() => {
+			this.getAll().forEach((e) => {
+				this.remove(e);
+			});
+		});
+	}
+	get(e) {
+		return this.#e.get(e);
+	}
+	getAll() {
+		return [...this.#e.values()];
+	}
+	find(e) {
+		let t = {
+			exact: !0,
+			...e
+		};
+		return this.getAll().find((e) => S(t, e));
+	}
+	findAll(e = {}) {
+		let t = this.getAll();
+		return Object.keys(e).length > 0 ? t.filter((t) => S(e, t)) : t;
+	}
+	notify(e) {
+		I.batch(() => {
+			this.listeners.forEach((t) => {
+				t(e);
+			});
+		});
+	}
+	onFocus() {
+		I.batch(() => {
+			this.getAll().forEach((e) => {
+				e.onFocus();
+			});
+		});
+	}
+	onOnline() {
+		I.batch(() => {
+			this.getAll().forEach((e) => {
+				e.onOnline();
+			});
+		});
+	}
+}, Ue = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	constructor(e = {}) {
+		this.#e = e.queryCache || new He(), this.#t = e.mutationCache || new Le(), this.#n = e.defaultOptions || {}, this.#r = /* @__PURE__ */ new Map(), this.#i = /* @__PURE__ */ new Map(), this.#a = 0;
+	}
+	mount() {
+		this.#a++, this.#a === 1 && (this.#o = d.subscribe(async (e) => {
+			e && (await this.resumePausedMutations(), this.#e.onFocus());
+		}), this.#s = L.subscribe(async (e) => {
+			e && (await this.resumePausedMutations(), this.#e.onOnline());
+		}));
+	}
+	unmount() {
+		this.#a--, this.#a === 0 && (this.#o?.(), this.#o = void 0, this.#s?.(), this.#s = void 0);
+	}
+	isFetching(e) {
+		return this.#e.findAll({
+			...e,
+			fetchStatus: "fetching"
+		}).length;
+	}
+	isMutating(e) {
+		return this.#t.findAll({
+			...e,
+			status: "pending"
+		}).length;
+	}
+	getQueryData(e) {
+		let t = this.defaultQueryOptions({ queryKey: e });
+		return this.#e.get(t.queryHash)?.state.data;
+	}
+	ensureQueryData(e) {
+		let t = this.defaultQueryOptions(e), n = this.#e.build(this, t), r = n.state.data;
+		return r === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && n.isStaleByTime(b(t.staleTime, n)) && this.prefetchQuery(t), Promise.resolve(r));
+	}
+	getQueriesData(e) {
+		return this.#e.findAll(e).map(({ queryKey: e, state: t }) => [e, t.data]);
+	}
+	setQueryData(e, t, n) {
+		let r = this.defaultQueryOptions({ queryKey: e }), i = this.#e.get(r.queryHash)?.state.data, a = _(t, i);
+		if (a !== void 0) return this.#e.build(this, r).setData(a, {
+			...n,
+			manual: !0
+		});
+	}
+	setQueriesData(e, t, n) {
+		return I.batch(() => this.#e.findAll(e).map(({ queryKey: e }) => [e, this.setQueryData(e, t, n)]));
+	}
+	getQueryState(e) {
+		let t = this.defaultQueryOptions({ queryKey: e });
+		return this.#e.get(t.queryHash)?.state;
+	}
+	removeQueries(e) {
+		let t = this.#e;
+		I.batch(() => {
+			t.findAll(e).forEach((e) => {
+				t.remove(e);
+			});
+		});
+	}
+	resetQueries(e, t) {
+		let n = this.#e;
+		return I.batch(() => (n.findAll(e).forEach((e) => {
+			e.reset();
+		}), this.refetchQueries({
+			type: "active",
+			...e
+		}, t)));
+	}
+	cancelQueries(e, t = {}) {
+		let n = {
+			revert: !0,
+			...t
+		}, r = I.batch(() => this.#e.findAll(e).map((e) => e.cancel(n)));
+		return Promise.all(r).then(g).catch(g);
+	}
+	invalidateQueries(e, t = {}) {
+		return I.batch(() => (this.#e.findAll(e).forEach((e) => {
+			e.invalidate();
+		}), e?.refetchType === "none" ? Promise.resolve() : this.refetchQueries({
+			...e,
+			type: e?.refetchType ?? e?.type ?? "active"
+		}, t)));
+	}
+	refetchQueries(e, t = {}) {
+		let n = {
+			...t,
+			cancelRefetch: t.cancelRefetch ?? !0
+		}, r = I.batch(() => this.#e.findAll(e).filter((e) => !e.isDisabled() && !e.isStatic()).map((e) => {
+			let t = e.fetch(void 0, n);
+			return n.throwOnError || (t = t.catch(g)), e.state.fetchStatus === "paused" ? Promise.resolve() : t;
+		}));
+		return Promise.all(r).then(g);
+	}
+	fetchQuery(e) {
+		let t = this.defaultQueryOptions(e);
+		t.retry === void 0 && (t.retry = !1);
+		let n = this.#e.build(this, t);
+		return n.isStaleByTime(b(t.staleTime, n)) ? n.fetch(t) : Promise.resolve(n.state.data);
+	}
+	prefetchQuery(e) {
+		return this.fetchQuery(e).then(g).catch(g);
+	}
+	fetchInfiniteQuery(e) {
+		return e._type = "infinite", this.fetchQuery(e);
+	}
+	prefetchInfiniteQuery(e) {
+		return this.fetchInfiniteQuery(e).then(g).catch(g);
+	}
+	ensureInfiniteQueryData(e) {
+		return e._type = "infinite", this.ensureQueryData(e);
+	}
+	resumePausedMutations() {
+		return L.isOnline() ? this.#t.resumePausedMutations() : Promise.resolve();
+	}
+	getQueryCache() {
+		return this.#e;
+	}
+	getMutationCache() {
+		return this.#t;
+	}
+	getDefaultOptions() {
+		return this.#n;
+	}
+	setDefaultOptions(e) {
+		this.#n = e;
+	}
+	setQueryDefaults(e, t) {
+		this.#r.set(T(e), {
+			queryKey: e,
+			defaultOptions: t
+		});
+	}
+	getQueryDefaults(e) {
+		let t = [...this.#r.values()], n = {};
+		return t.forEach((t) => {
+			E(e, t.queryKey) && Object.assign(n, t.defaultOptions);
+		}), n;
+	}
+	setMutationDefaults(e, t) {
+		this.#i.set(T(e), {
+			mutationKey: e,
+			defaultOptions: t
+		});
+	}
+	getMutationDefaults(e) {
+		let t = [...this.#i.values()], n = {};
+		return t.forEach((t) => {
+			E(e, t.mutationKey) && Object.assign(n, t.defaultOptions);
+		}), n;
+	}
+	defaultQueryOptions(e) {
+		if (e._defaulted) return e;
+		let t = {
+			...this.#n.queries,
+			...this.getQueryDefaults(e.queryKey),
+			...e,
+			_defaulted: !0
+		};
+		return t.queryHash ||= w(t.queryKey, t), t.refetchOnReconnect === void 0 && (t.refetchOnReconnect = t.networkMode !== "always"), t.throwOnError === void 0 && (t.throwOnError = !!t.suspense), !t.networkMode && t.persister && (t.networkMode = "offlineFirst"), t.queryFn === j && (t.enabled = !1), t;
+	}
+	defaultMutationOptions(e) {
+		return e?._defaulted ? e : {
+			...this.#n.mutations,
+			...e?.mutationKey && this.getMutationDefaults(e.mutationKey),
+			...e,
+			_defaulted: !0
+		};
+	}
+	clear() {
+		this.#e.clear(), this.#t.clear();
+	}
+};
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/streamedQuery.js
+function We({ streamFn: e, refetchMode: t = "reset", reducer: n = (e, t) => ae(e, t), initialValue: r = [] }) {
+	return async (i) => {
+		let a = i.client.getQueryCache().find({
+			queryKey: i.queryKey,
+			exact: !0
+		}), o = !!a && a.isFetched();
+		o && t === "reset" && a.setState({
+			...a.resetState,
+			fetchStatus: "fetching"
+		});
+		let s = r, c = !1, l = await e(ce({
+			client: i.client,
+			meta: i.meta,
+			queryKey: i.queryKey,
+			pageParam: i.pageParam,
+			direction: i.direction
+		}, () => i.signal, () => c = !0)), u = o && t === "replace";
+		for await (let e of l) {
+			if (c) break;
+			u ? s = n(s, e) : i.client.setQueryData(i.queryKey, (t) => n(t === void 0 ? r : t, e));
+		}
+		return u && !c && i.client.setQueryData(i.queryKey, s), i.client.getQueryData(i.queryKey) ?? r;
+	};
+}
+//#endregion
+//#region ../../node_modules/@tanstack/query-core/build/modern/types.js
+var Ge = /* @__PURE__ */ Symbol("dataTagSymbol"), Ke = /* @__PURE__ */ Symbol("dataTagErrorSymbol"), qe = /* @__PURE__ */ Symbol("unsetMarker");
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+r();
+var K = s(void 0), q = (t) => {
+	let n = e(K);
+	if (t) return t;
+	if (!n) throw Error("No QueryClient set, use QueryClientProvider to set one");
+	return n;
+}, Je = ({ client: e, children: t }) => (o(() => (e.mount(), () => {
+	e.unmount();
+}), [e]), /* @__PURE__ */ l(K.Provider, {
+	value: e,
+	children: t
+}));
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
+r();
+var Ye = s(!1), J = () => e(Ye), Xe = Ye.Provider;
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+r();
+function Ze() {
+	let e = !1;
+	return {
+		clearReset: () => {
+			e = !1;
+		},
+		reset: () => {
+			e = !0;
+		},
+		isReset: () => e
+	};
+}
+var Qe = s(Ze()), Y = () => e(Qe), $e = ({ children: e }) => {
+	let [n] = t(() => Ze());
+	return /* @__PURE__ */ l(Qe.Provider, {
+		value: n,
+		children: typeof e == "function" ? e(n) : e
+	});
+};
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
+r();
+var et = (e, t, n) => {
+	let r = n?.state.error && typeof e.throwOnError == "function" ? M(e.throwOnError, [n.state.error, n]) : e.throwOnError;
+	(e.suspense || e.experimental_prefetchInRender || r) && (t.isReset() || (e.retryOnMount = !1));
+}, tt = (e) => {
+	o(() => {
+		e.clearReset();
+	}, [e]);
+}, nt = ({ result: e, errorResetBoundary: t, throwOnError: n, query: r, suspense: i }) => e.isError && !t.isReset() && !e.isFetching && r && (i && e.data === void 0 || M(n, [e.error, r])), X = (e, t) => t.state.data === void 0, rt = (e) => {
+	if (e.suspense) {
+		let t = 1e3, n = (e) => e === "static" ? e : Math.max(e ?? t, t), r = e.staleTime;
+		e.staleTime = typeof r == "function" ? (...e) => n(r(...e)) : n(r), typeof e.gcTime == "number" && (e.gcTime = Math.max(e.gcTime, t));
+	}
+}, it = (e, t) => e.isLoading && e.isFetching && !t, Z = (e, t) => e?.suspense && t.isPending, Q = (e, t, n) => t.fetchOptimistic(e).catch(() => {
+	n.clearReset();
+});
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useQueries.js
+r();
+function at({ queries: e, ...r }, s) {
+	let c = q(s), l = J(), u = Y(), d = a(() => e.map((e) => {
+		let t = c.defaultQueryOptions(e);
+		return t._optimisticResults = l ? "isRestoring" : "optimistic", t;
+	}), [
+		e,
+		c,
+		l
+	]);
+	d.forEach((e) => {
+		rt(e), et(e, u, c.getQueryCache().get(e.queryHash));
+	}), tt(u);
+	let [f] = t(() => new Ve(c, d, r)), [p, m, h] = f.getOptimisticResult(d, r.combine), _ = !l && r.subscribed !== !1;
+	n(i((e) => _ ? f.subscribe(I.batchCalls(e)) : g, [f, _]), () => f.getCurrentResult(), () => f.getCurrentResult()), o(() => {
+		f.setQueries(d, r);
+	}, [
+		d,
+		r,
+		f
+	]);
+	let v = p.some((e, t) => Z(d[t], e)) ? p.flatMap((e, t) => {
+		let n = d[t];
+		return n && Z(n, e) ? Q(n, new B(c, n), u) : [];
+	}) : [];
+	if (v.length > 0) throw Promise.all(v);
+	let y = p.find((e, t) => {
+		let n = d[t];
+		return n && nt({
+			result: e,
+			errorResetBoundary: u,
+			throwOnError: n.throwOnError,
+			query: c.getQueryCache().get(n.queryHash),
+			suspense: n.suspense
+		});
+	});
+	if (y?.error) throw y.error;
+	return m(h());
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+r();
+function $(e, r, a) {
+	let s = J(), c = Y(), l = q(a), u = l.defaultQueryOptions(e);
+	l.getDefaultOptions().queries?._experimental_beforeQuery?.(u);
+	let d = l.getQueryCache().get(u.queryHash);
+	u._optimisticResults = s ? "isRestoring" : "optimistic", rt(u), et(u, c, d), tt(c);
+	let f = !l.getQueryCache().get(u.queryHash), [p] = t(() => new r(l, u)), m = p.getOptimisticResult(u), h = !s && e.subscribed !== !1;
+	if (n(i((e) => {
+		let t = h ? p.subscribe(I.batchCalls(e)) : g;
+		return p.updateResult(), t;
+	}, [p, h]), () => p.getCurrentResult(), () => p.getCurrentResult()), o(() => {
+		p.setOptions(u);
+	}, [u, p]), Z(u, m)) throw Q(u, p, c);
+	if (nt({
+		result: m,
+		errorResetBoundary: c,
+		throwOnError: u.throwOnError,
+		query: d,
+		suspense: u.suspense
+	})) throw m.error;
+	return l.getDefaultOptions().queries?._experimental_afterQuery?.(u, m), u.experimental_prefetchInRender && !N.isServer() && it(m, s) && (f ? Q(u, p, c) : d?.promise)?.catch(g).finally(() => {
+		p.updateResult();
+	}), u.notifyOnChangeProps ? m : p.trackResult(m);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useQuery.js
+function ot(e, t) {
+	return $(e, B, t);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useSuspenseQuery.js
+function st(e, t) {
+	return $({
+		...e,
+		enabled: !0,
+		suspense: !0,
+		throwOnError: X,
+		placeholderData: void 0
+	}, B, t);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useSuspenseInfiniteQuery.js
+function ct(e, t) {
+	return $({
+		...e,
+		enabled: !0,
+		suspense: !0,
+		throwOnError: X
+	}, W, t);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useSuspenseQueries.js
+function lt(e, t) {
+	return at({
+		...e,
+		queries: e.queries.map((e) => ({
+			...e,
+			suspense: !0,
+			throwOnError: X,
+			enabled: !0,
+			placeholderData: void 0
+		}))
+	}, t);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/usePrefetchQuery.js
+function ut(e, t) {
+	let n = q(t);
+	n.getQueryState(e.queryKey) || n.prefetchQuery(e);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/usePrefetchInfiniteQuery.js
+function dt(e, t) {
+	let n = q(t);
+	n.getQueryState(e.queryKey) || n.prefetchInfiniteQuery(e);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/queryOptions.js
+function ft(e) {
+	return e;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/infiniteQueryOptions.js
+function pt(e) {
+	return e;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/HydrationBoundary.js
+r();
+var mt = ({ children: e, options: t = {}, state: n, queryClient: r }) => {
+	let i = q(r), s = c(t);
+	o(() => {
+		s.current = t;
+	});
+	let l = a(() => {
+		if (n) {
+			if (typeof n != "object") return;
+			let e = i.getQueryCache(), t = n.queries || [], r = [], a = [];
+			for (let n of t) {
+				let t = e.get(n.queryHash);
+				t ? (n.state.dataUpdatedAt > t.state.dataUpdatedAt || n.promise && t.state.status !== "pending" && t.state.fetchStatus !== "fetching" && n.dehydratedAt !== void 0 && n.dehydratedAt > t.state.dataUpdatedAt) && a.push(n) : r.push(n);
+			}
+			if (r.length > 0 && F(i, { queries: r }, s.current), a.length > 0) return a;
+		}
+	}, [i, n]);
+	return o(() => {
+		l && F(i, { queries: l }, s.current);
+	}, [i, l]), e;
+};
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useIsFetching.js
+r();
+function ht(e, t) {
+	let r = q(t), a = r.getQueryCache();
+	return n(i((e) => a.subscribe(I.batchCalls(e)), [a]), () => r.isFetching(e), () => r.isFetching(e));
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useMutationState.js
+r();
+function gt(e, t) {
+	let n = q(t);
+	return vt({ filters: {
+		...e,
+		status: "pending"
+	} }, n).length;
+}
+function _t(e, t) {
+	return e.findAll(t.filters).map((e) => t.select ? t.select(e) : e.state);
+}
+function vt(e = {}, t) {
+	let r = q(t).getMutationCache(), a = c(e), s = c(null);
+	return s.current === null && (s.current = _t(r, e)), o(() => {
+		a.current = e;
+	}), n(i((e) => r.subscribe(() => {
+		let t = D(s.current, _t(r, a.current));
+		s.current !== t && (s.current = t, I.schedule(e));
+	}), [r]), () => s.current, () => s.current);
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useMutation.js
+r();
+function yt(e, r) {
+	let a = q(r), [s] = t(() => new Re(a, e));
+	o(() => {
+		s.setOptions(e);
+	}, [s, e]);
+	let c = n(i((e) => s.subscribe(I.batchCalls(e)), [s]), () => s.getCurrentResult(), () => s.getCurrentResult()), l = i((e, t) => {
+		s.mutate(e, t).catch(g);
+	}, [s]);
+	if (c.error && M(s.options.throwOnError, [c.error])) throw c.error;
+	return {
+		...c,
+		mutate: l,
+		mutateAsync: c.mutate
+	};
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/mutationOptions.js
+function bt(e) {
+	return e;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js
+function xt(e, t) {
+	return $(e, W, t);
+}
+//#endregion
+export { R as CancelledError, mt as HydrationBoundary, W as InfiniteQueryObserver, Xe as IsRestoringProvider, Fe as Mutation, Le as MutationCache, Re as MutationObserver, Ve as QueriesObserver, Oe as Query, He as QueryCache, Ue as QueryClient, K as QueryClientContext, Je as QueryClientProvider, $e as QueryErrorResetBoundary, B as QueryObserver, Ke as dataTagErrorSymbol, Ge as dataTagSymbol, _e as defaultScheduler, pe as defaultShouldDehydrateMutation, me as defaultShouldDehydrateQuery, ge as dehydrate, N as environmentManager, We as experimental_streamedQuery, d as focusManager, T as hashKey, F as hydrate, pt as infiniteQueryOptions, xe as isCancelledError, h as isServer, ie as keepPreviousData, C as matchMutation, S as matchQuery, bt as mutationOptions, g as noop, I as notifyManager, L as onlineManager, E as partialMatchKey, ft as queryOptions, D as replaceEqualDeep, M as shouldThrowError, j as skipToken, p as timeoutManager, qe as unsetMarker, xt as useInfiniteQuery, ht as useIsFetching, gt as useIsMutating, J as useIsRestoring, yt as useMutation, vt as useMutationState, dt as usePrefetchInfiniteQuery, ut as usePrefetchQuery, at as useQueries, ot as useQuery, q as useQueryClient, Y as useQueryErrorResetBoundary, ct as useSuspenseInfiniteQuery, lt as useSuspenseQueries, st as useSuspenseQuery };