@luzmo/analytics-components-kit 1.0.9-beta.1 → 1.0.9-beta.11

package/components/data-broker-DNfq_8Lg.js

@@ -0,0 +1,1695 @@
+/*! * A kit of modern Luzmo Web Components for analytics in your web application.
+ * 
+ * Copyright © 2026 Luzmo
+ * All rights reserved.
+ * Luzmo web components (“Luzmo Web Components”)
+ * must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account
+ * to use the Luzmo Web Components. This license terminates
+ * automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+import { c as e, s as t } from "./type-check-CGREdneG.js";
+//#region node_modules/@tanstack/query-core/build/modern/subscribable.js
+var n = 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() {}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/checkPrivateRedeclaration.js
+function r(e, t) {
+	if (t.has(e)) throw TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateFieldInitSpec.js
+function i(e, t, n) {
+	r(e, t), t.set(e, n);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/assertClassBrand.js
+function a(e, t, n) {
+	if (typeof e == "function" ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateFieldSet2.js
+function o(e, t, n) {
+	return e.set(a(e, t), n), n;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateFieldGet2.js
+function s(e, t) {
+	return e.get(a(e, t));
+}
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/focusManager.js
+var c, l, u, d = new (c = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap(), u = /* @__PURE__ */ new WeakMap(), class extends n {
+	constructor() {
+		super(), i(this, c, void 0), i(this, l, void 0), i(this, u, void 0), o(u, this, (e) => {
+			if (typeof window < "u" && window.addEventListener) {
+				let t = () => e();
+				return window.addEventListener("visibilitychange", t, !1), () => {
+					window.removeEventListener("visibilitychange", t);
+				};
+			}
+		});
+	}
+	onSubscribe() {
+		s(l, this) || this.setEventListener(s(u, this));
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (s(l, this)?.call(this), o(l, this, void 0));
+	}
+	setEventListener(e) {
+		o(u, this, e), s(l, this)?.call(this), o(l, this, e((e) => {
+			typeof e == "boolean" ? this.setFocused(e) : this.onFocus();
+		}));
+	}
+	setFocused(e) {
+		s(c, this) !== e && (o(c, this, e), this.onFocus());
+	}
+	onFocus() {
+		let e = this.isFocused();
+		this.listeners.forEach((t) => {
+			t(e);
+		});
+	}
+	isFocused() {
+		return typeof s(c, this) == "boolean" ? s(c, this) : globalThis.document?.visibilityState !== "hidden";
+	}
+})(), f, p, ee = {
+	setTimeout: (e, t) => setTimeout(e, t),
+	clearTimeout: (e) => clearTimeout(e),
+	setInterval: (e, t) => setInterval(e, t),
+	clearInterval: (e) => clearInterval(e)
+}, m = new (f = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new WeakMap(), class {
+	constructor() {
+		i(this, f, ee), i(this, p, !1);
+	}
+	setTimeoutProvider(e) {
+		o(f, this, e);
+	}
+	setTimeout(e, t) {
+		return s(f, this).setTimeout(e, t);
+	}
+	clearTimeout(e) {
+		s(f, this).clearTimeout(e);
+	}
+	setInterval(e, t) {
+		return s(f, this).setInterval(e, t);
+	}
+	clearInterval(e) {
+		s(f, this).clearInterval(e);
+	}
+})();
+function te(e) {
+	setTimeout(e, 0);
+}
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/utils.js
+var ne = typeof window > "u" || "Deno" in globalThis;
+function h() {}
+function re(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function ie(e) {
+	return typeof e == "number" && e >= 0 && e !== Infinity;
+}
+function ae(e, t) {
+	return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function oe(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function se(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function ce(e, t) {
+	let { type: n = "all", exact: r, fetchStatus: i, predicate: a, queryKey: o, stale: s } = e;
+	if (o) {
+		if (r) {
+			if (t.queryHash !== ue(o, t.options)) return !1;
+		} else if (!_(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 le(e, t) {
+	let { exact: n, status: r, predicate: i, mutationKey: a } = e;
+	if (a) {
+		if (!t.options.mutationKey) return !1;
+		if (n) {
+			if (g(t.options.mutationKey) !== g(a)) return !1;
+		} else if (!_(t.options.mutationKey, a)) return !1;
+	}
+	return !(r && t.state.status !== r || i && !i(t));
+}
+function ue(e, t) {
+	return (t?.queryKeyHashFn || g)(e);
+}
+function g(e) {
+	return JSON.stringify(e, (e, t) => me(t) ? Object.keys(t).sort().reduce((e, n) => (e[n] = t[n], e), {}) : t);
+}
+function _(e, t) {
+	return e === t ? !0 : typeof e == typeof t && e && t && typeof e == "object" && typeof t == "object" ? Object.keys(t).every((n) => _(e[n], t[n])) : !1;
+}
+var de = Object.prototype.hasOwnProperty;
+function fe(e, t, n = 0) {
+	if (e === t) return e;
+	if (n > 500) return t;
+	let r = pe(e) && pe(t);
+	if (!r && !(me(e) && me(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 : de.call(e, o)) && c++;
+			continue;
+		}
+		if (u === null || d === null || typeof u != "object" || typeof d != "object") {
+			s[o] = d;
+			continue;
+		}
+		let f = fe(u, d, n + 1);
+		s[o] = f, f === u && c++;
+	}
+	return i === o && c === i ? e : s;
+}
+function pe(e) {
+	return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function me(e) {
+	if (!he(e)) return !1;
+	let t = e.constructor;
+	if (t === void 0) return !0;
+	let n = t.prototype;
+	return !(!he(n) || !n.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function he(e) {
+	return Object.prototype.toString.call(e) === "[object Object]";
+}
+function ge(e) {
+	return new Promise((t) => {
+		m.setTimeout(t, e);
+	});
+}
+function _e(e, t, n) {
+	return typeof n.structuralSharing == "function" ? n.structuralSharing(e, t) : n.structuralSharing === !1 ? t : fe(e, t);
+}
+function ve(e, t, n = 0) {
+	let r = [...e, t];
+	return n && r.length > n ? r.slice(1) : r;
+}
+function ye(e, t, n = 0) {
+	let r = [t, ...e];
+	return n && r.length > n ? r.slice(0, -1) : r;
+}
+var v = /* @__PURE__ */ Symbol();
+function be(e, t) {
+	return !e.queryFn && t?.initialPromise ? () => t.initialPromise : !e.queryFn || e.queryFn === v ? () => Promise.reject(/* @__PURE__ */ Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function xe(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 Se = /* @__PURE__ */ (() => {
+	let e = () => ne;
+	return {
+		isServer() {
+			return e();
+		},
+		setIsServer(t) {
+			e = t;
+		}
+	};
+})();
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/thenable.js
+function Ce() {
+	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;
+}
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var we = te;
+function Te() {
+	let e = [], t = 0, n = (e) => {
+		e();
+	}, r = (e) => {
+		e();
+	}, i = we, 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 y = Te(), b, x, S, C = new (b = /* @__PURE__ */ new WeakMap(), x = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new WeakMap(), class extends n {
+	constructor() {
+		super(), i(this, b, !0), i(this, x, void 0), i(this, S, void 0), o(S, this, (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() {
+		s(x, this) || this.setEventListener(s(S, this));
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (s(x, this)?.call(this), o(x, this, void 0));
+	}
+	setEventListener(e) {
+		o(S, this, e), s(x, this)?.call(this), o(x, this, e(this.setOnline.bind(this)));
+	}
+	setOnline(e) {
+		s(b, this) !== e && (o(b, this, e), this.listeners.forEach((t) => {
+			t(e);
+		}));
+	}
+	isOnline() {
+		return s(b, this);
+	}
+})();
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/retryer.js
+function Ee(e) {
+	return Math.min(1e3 * 2 ** e, 3e4);
+}
+function De(e) {
+	return (e ?? "online") !== "online" || C.isOnline();
+}
+var Oe = class extends Error {
+	constructor(e) {
+		super("CancelledError"), this.revert = e?.revert, this.silent = e?.silent;
+	}
+};
+function ke(e) {
+	let t = !1, n = 0, r, i = Ce(), a = () => i.status !== "pending", o = (t) => {
+		if (!a()) {
+			let n = new Oe(t);
+			p(n), e.onCancel?.(n);
+		}
+	}, s = () => {
+		t = !0;
+	}, c = () => {
+		t = !1;
+	}, l = () => d.isFocused() && (e.networkMode === "always" || C.isOnline()) && e.canRun(), u = () => De(e.networkMode) && e.canRun(), f = (e) => {
+		a() || (r?.(), i.resolve(e));
+	}, p = (e) => {
+		a() || (r?.(), i.reject(e));
+	}, ee = () => new Promise((t) => {
+		r = (e) => {
+			(a() || l()) && t(e);
+		}, e.onPause?.();
+	}).then(() => {
+		r = void 0, a() || e.onContinue?.();
+	}), m = () => {
+		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 ?? (Se.isServer() ? 0 : 3), o = e.retryDelay ?? Ee, 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), ge(s).then(() => l() ? void 0 : ee()).then(() => {
+				t ? p(r) : m();
+			});
+		});
+	};
+	return {
+		promise: i,
+		status: () => i.status,
+		cancel: o,
+		continue: () => (r?.(), i),
+		cancelRetry: s,
+		continueRetry: c,
+		canStart: u,
+		start: () => (u() ? m() : ee().then(m), i)
+	};
+}
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/removable.js
+var w, Ae = (w = /* @__PURE__ */ new WeakMap(), class {
+	constructor() {
+		i(this, w, void 0);
+	}
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout(), ie(this.gcTime) && o(w, this, m.setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime));
+	}
+	updateGcTime(e) {
+		this.gcTime = Math.max(this.gcTime || 0, e ?? (Se.isServer() ? Infinity : 300 * 1e3));
+	}
+	clearGcTimeout() {
+		s(w, this) !== void 0 && (m.clearTimeout(s(w, this)), o(w, this, void 0));
+	}
+});
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+function je(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) => {
+				xe(e, () => t.signal, () => n = !0);
+			}, u = be(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 = (() => {
+					let e = {
+						client: t.client,
+						queryKey: t.queryKey,
+						pageParam: r,
+						direction: i ? "backward" : "forward",
+						meta: t.options.meta
+					};
+					return l(e), e;
+				})(), o = await u(a), { maxPages: s } = t.options, c = i ? ye : ve;
+				return {
+					pages: c(e.pages, o, s),
+					pageParams: c(e.pageParams, r, s)
+				};
+			};
+			if (i && a.length) {
+				let e = i === "backward", t = e ? Ne : Me, 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 : Me(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 Me(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 Ne(e, { pages: t, pageParams: n }) {
+	return t.length > 0 ? e.getPreviousPageParam?.(t[0], t, n[0], n) : void 0;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/classPrivateMethodInitSpec.js
+function Pe(e, t) {
+	r(e, t), t.add(e);
+}
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/query.js
+var T, E, D, O, k, A, j, M, N, Fe = (T = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap(), O = /* @__PURE__ */ new WeakMap(), k = /* @__PURE__ */ new WeakMap(), A = /* @__PURE__ */ new WeakMap(), j = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), N = /* @__PURE__ */ new WeakSet(), class extends Ae {
+	constructor(e) {
+		super(), Pe(this, N), i(this, T, void 0), i(this, E, void 0), i(this, D, void 0), i(this, O, void 0), i(this, k, void 0), i(this, A, void 0), i(this, j, void 0), i(this, M, void 0), o(M, this, !1), o(j, this, e.defaultOptions), this.setOptions(e.options), this.observers = [], o(k, this, e.client), o(O, this, s(k, this).getQueryCache()), this.queryKey = e.queryKey, this.queryHash = e.queryHash, o(E, this, ze(this.options)), this.state = e.state ?? s(E, this), this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get queryType() {
+		return s(T, this);
+	}
+	get promise() {
+		return s(A, this)?.promise;
+	}
+	setOptions(e) {
+		if (this.options = {
+			...s(j, this),
+			...e
+		}, e?._type && o(T, this, e._type), this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+			let e = ze(this.options);
+			e.data !== void 0 && (this.setState(Re(e.data, e.dataUpdatedAt)), o(E, this, e));
+		}
+	}
+	optionalRemove() {
+		!this.observers.length && this.state.fetchStatus === "idle" && s(O, this).remove(this);
+	}
+	setData(e, t) {
+		let n = _e(this.state.data, e, this.options);
+		return a(N, this, P).call(this, {
+			data: n,
+			type: "success",
+			dataUpdatedAt: t?.updatedAt,
+			manual: t?.manual
+		}), n;
+	}
+	setState(e) {
+		a(N, this, P).call(this, {
+			type: "setState",
+			state: e
+		});
+	}
+	cancel(e) {
+		let t = s(A, this)?.promise;
+		return s(A, this)?.cancel(e), t ? t.then(h).catch(h) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy(), this.cancel({ silent: !0 });
+	}
+	get resetState() {
+		return s(E, this);
+	}
+	reset() {
+		this.destroy(), this.setState(this.resetState);
+	}
+	isActive() {
+		return this.observers.some((e) => se(e.options.enabled, this) !== !1);
+	}
+	isDisabled() {
+		return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === v || !this.isFetched();
+	}
+	isFetched() {
+		return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+	}
+	isStatic() {
+		return this.getObserversCount() > 0 && this.observers.some((e) => oe(e.options.staleTime, this) === "static");
+	}
+	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 : !ae(this.state.dataUpdatedAt, e);
+	}
+	onFocus() {
+		this.observers.find((e) => e.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), s(A, this)?.continue();
+	}
+	onOnline() {
+		this.observers.find((e) => e.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), s(A, this)?.continue();
+	}
+	addObserver(e) {
+		this.observers.includes(e) || (this.observers.push(e), this.clearGcTimeout(), s(O, this).notify({
+			type: "observerAdded",
+			query: this,
+			observer: e
+		}));
+	}
+	removeObserver(e) {
+		this.observers.includes(e) && (this.observers = this.observers.filter((t) => t !== e), this.observers.length || (s(A, this) && (s(M, this) || a(N, this, Ie).call(this) ? s(A, this).cancel({ revert: !0 }) : s(A, this).cancelRetry()), this.scheduleGc()), s(O, this).notify({
+			type: "observerRemoved",
+			query: this,
+			observer: e
+		}));
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	invalidate() {
+		this.state.isInvalidated || a(N, this, P).call(this, { type: "invalidate" });
+	}
+	async fetch(e, t) {
+		if (this.state.fetchStatus !== "idle" && s(A, this)?.status() !== "rejected") {
+			if (this.state.data !== void 0 && t?.cancelRefetch) this.cancel({ silent: !0 });
+			else if (s(A, this)) return s(A, this).continueRetry(), s(A, this).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: () => (o(M, this, !0), n.signal)
+			});
+		}, i = () => {
+			let e = be(this.options, t), n = (() => {
+				let e = {
+					client: s(k, this),
+					queryKey: this.queryKey,
+					meta: this.meta
+				};
+				return r(e), e;
+			})();
+			return o(M, this, !1), this.options.persister ? this.options.persister(e, n, this) : e(n);
+		}, c = (() => {
+			let e = {
+				fetchOptions: t,
+				options: this.options,
+				queryKey: this.queryKey,
+				client: s(k, this),
+				state: this.state,
+				fetchFn: i
+			};
+			return r(e), e;
+		})();
+		(s(T, this) === "infinite" ? je(this.options.pages) : this.options.behavior)?.onFetch(c, this), o(D, this, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== c.fetchOptions?.meta) && a(N, this, P).call(this, {
+			type: "fetch",
+			meta: c.fetchOptions?.meta
+		}), o(A, this, ke({
+			initialPromise: t?.initialPromise,
+			fn: c.fetchFn,
+			onCancel: (e) => {
+				e instanceof Oe && e.revert && this.setState({
+					...s(D, this),
+					fetchStatus: "idle"
+				}), n.abort();
+			},
+			onFail: (e, t) => {
+				a(N, this, P).call(this, {
+					type: "failed",
+					failureCount: e,
+					error: t
+				});
+			},
+			onPause: () => {
+				a(N, this, P).call(this, { type: "pause" });
+			},
+			onContinue: () => {
+				a(N, this, P).call(this, { type: "continue" });
+			},
+			retry: c.options.retry,
+			retryDelay: c.options.retryDelay,
+			networkMode: c.options.networkMode,
+			canRun: () => !0
+		}));
+		try {
+			let e = await s(A, this).start();
+			if (e === void 0) throw Error(`${this.queryHash} data is undefined`);
+			return this.setData(e), s(O, this).config.onSuccess?.(e, this), s(O, this).config.onSettled?.(e, this.state.error, this), e;
+		} catch (e) {
+			if (e instanceof Oe) {
+				if (e.silent) return s(A, this).promise;
+				if (e.revert) {
+					if (this.state.data === void 0) throw e;
+					return this.state.data;
+				}
+			}
+			throw a(N, this, P).call(this, {
+				type: "error",
+				error: e
+			}), s(O, this).config.onError?.(e, this), s(O, this).config.onSettled?.(this.state.data, e, this), e;
+		} finally {
+			this.scheduleGc();
+		}
+	}
+});
+function Ie() {
+	return this.state.fetchStatus === "paused" && this.state.status === "pending";
+}
+function P(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,
+				...Le(t.data, this.options),
+				fetchMeta: e.meta ?? null
+			};
+			case "success":
+				let n = {
+					...t,
+					...Re(e.data, e.dataUpdatedAt),
+					dataUpdateCount: t.dataUpdateCount + 1,
+					...!e.manual && {
+						fetchStatus: "idle",
+						fetchFailureCount: 0,
+						fetchFailureReason: null
+					}
+				};
+				return o(D, this, 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), y.batch(() => {
+		this.observers.forEach((e) => {
+			e.onQueryUpdate();
+		}), s(O, this).notify({
+			query: this,
+			type: "updated",
+			action: e
+		});
+	});
+}
+function Le(e, t) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: De(t.networkMode) ? "fetching" : "paused",
+		...e === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function Re(e, t) {
+	return {
+		data: e,
+		dataUpdatedAt: t ?? Date.now(),
+		error: null,
+		isInvalidated: !1,
+		status: "success"
+	};
+}
+function ze(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/mutation.js
+var F, I, L, R, z, Be = (F = /* @__PURE__ */ new WeakMap(), I = /* @__PURE__ */ new WeakMap(), L = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap(), z = /* @__PURE__ */ new WeakSet(), class extends Ae {
+	constructor(e) {
+		super(), Pe(this, z), i(this, F, void 0), i(this, I, void 0), i(this, L, void 0), i(this, R, void 0), o(F, this, e.client), this.mutationId = e.mutationId, o(L, this, e.mutationCache), o(I, this, []), this.state = e.state || Ve(), this.setOptions(e.options), this.scheduleGc();
+	}
+	setOptions(e) {
+		this.options = e, this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(e) {
+		s(I, this).includes(e) || (s(I, this).push(e), this.clearGcTimeout(), s(L, this).notify({
+			type: "observerAdded",
+			mutation: this,
+			observer: e
+		}));
+	}
+	removeObserver(e) {
+		o(I, this, s(I, this).filter((t) => t !== e)), this.scheduleGc(), s(L, this).notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer: e
+		});
+	}
+	optionalRemove() {
+		s(I, this).length || (this.state.status === "pending" ? this.scheduleGc() : s(L, this).remove(this));
+	}
+	continue() {
+		return s(R, this)?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(e) {
+		let t = () => {
+			a(z, this, B).call(this, { type: "continue" });
+		}, n = {
+			client: s(F, this),
+			meta: this.options.meta,
+			mutationKey: this.options.mutationKey
+		};
+		o(R, this, ke({
+			fn: () => this.options.mutationFn ? this.options.mutationFn(e, n) : Promise.reject(/* @__PURE__ */ Error("No mutationFn found")),
+			onFail: (e, t) => {
+				a(z, this, B).call(this, {
+					type: "failed",
+					failureCount: e,
+					error: t
+				});
+			},
+			onPause: () => {
+				a(z, this, B).call(this, { type: "pause" });
+			},
+			onContinue: t,
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => s(L, this).canRun(this)
+		}));
+		let r = this.state.status === "pending", i = !s(R, this).canStart();
+		try {
+			if (r) t();
+			else {
+				a(z, this, B).call(this, {
+					type: "pending",
+					variables: e,
+					isPaused: i
+				}), s(L, this).config.onMutate && await s(L, this).config.onMutate(e, this, n);
+				let t = await this.options.onMutate?.(e, n);
+				t !== this.state.context && a(z, this, B).call(this, {
+					type: "pending",
+					context: t,
+					variables: e,
+					isPaused: i
+				});
+			}
+			let o = await s(R, this).start();
+			return await s(L, this).config.onSuccess?.(o, e, this.state.context, this, n), await this.options.onSuccess?.(o, e, this.state.context, n), await s(L, this).config.onSettled?.(o, null, this.state.variables, this.state.context, this, n), await this.options.onSettled?.(o, null, e, this.state.context, n), a(z, this, B).call(this, {
+				type: "success",
+				data: o
+			}), o;
+		} catch (t) {
+			try {
+				await s(L, this).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 s(L, this).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 a(z, this, B).call(this, {
+				type: "error",
+				error: t
+			}), t;
+		} finally {
+			s(L, this).runNext(this);
+		}
+	}
+});
+function B(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), y.batch(() => {
+		s(I, this).forEach((t) => {
+			t.onMutationUpdate(e);
+		}), s(L, this).notify({
+			mutation: this,
+			type: "updated",
+			action: e
+		});
+	});
+}
+function Ve() {
+	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 V, H, U, He = (V = /* @__PURE__ */ new WeakMap(), H = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new WeakMap(), class extends n {
+	constructor(e = {}) {
+		super(), i(this, V, void 0), i(this, H, void 0), i(this, U, void 0), this.config = e, o(V, this, /* @__PURE__ */ new Set()), o(H, this, /* @__PURE__ */ new Map()), o(U, this, 0);
+	}
+	build(e, t, n) {
+		var r;
+		let i = new Be({
+			client: e,
+			mutationCache: this,
+			mutationId: o(U, this, (r = s(U, this), ++r)),
+			options: e.defaultMutationOptions(t),
+			state: n
+		});
+		return this.add(i), i;
+	}
+	add(e) {
+		s(V, this).add(e);
+		let t = W(e);
+		if (typeof t == "string") {
+			let n = s(H, this).get(t);
+			n ? n.push(e) : s(H, this).set(t, [e]);
+		}
+		this.notify({
+			type: "added",
+			mutation: e
+		});
+	}
+	remove(e) {
+		if (s(V, this).delete(e)) {
+			let t = W(e);
+			if (typeof t == "string") {
+				let n = s(H, this).get(t);
+				if (n) if (n.length > 1) {
+					let t = n.indexOf(e);
+					t !== -1 && n.splice(t, 1);
+				} else n[0] === e && s(H, this).delete(t);
+			}
+		}
+		this.notify({
+			type: "removed",
+			mutation: e
+		});
+	}
+	canRun(e) {
+		let t = W(e);
+		if (typeof t == "string") {
+			let n = s(H, this).get(t)?.find((e) => e.state.status === "pending");
+			return !n || n === e;
+		} else return !0;
+	}
+	runNext(e) {
+		let t = W(e);
+		return typeof t == "string" ? (s(H, this).get(t)?.find((t) => t !== e && t.state.isPaused))?.continue() ?? Promise.resolve() : Promise.resolve();
+	}
+	clear() {
+		y.batch(() => {
+			s(V, this).forEach((e) => {
+				this.notify({
+					type: "removed",
+					mutation: e
+				});
+			}), s(V, this).clear(), s(H, this).clear();
+		});
+	}
+	getAll() {
+		return Array.from(s(V, this));
+	}
+	find(e) {
+		let t = {
+			exact: !0,
+			...e
+		};
+		return this.getAll().find((e) => le(t, e));
+	}
+	findAll(e = {}) {
+		return this.getAll().filter((t) => le(e, t));
+	}
+	notify(e) {
+		y.batch(() => {
+			this.listeners.forEach((t) => {
+				t(e);
+			});
+		});
+	}
+	resumePausedMutations() {
+		let e = this.getAll().filter((e) => e.state.isPaused);
+		return y.batch(() => Promise.all(e.map((e) => e.continue().catch(h))));
+	}
+});
+function W(e) {
+	return e.options.scope?.id;
+}
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/queryCache.js
+var G, Ue = (G = /* @__PURE__ */ new WeakMap(), class extends n {
+	constructor(e = {}) {
+		super(), i(this, G, void 0), this.config = e, o(G, this, /* @__PURE__ */ new Map());
+	}
+	build(e, t, n) {
+		let r = t.queryKey, i = t.queryHash ?? ue(r, t), a = this.get(i);
+		return a || (a = new Fe({
+			client: e,
+			queryKey: r,
+			queryHash: i,
+			options: e.defaultQueryOptions(t),
+			state: n,
+			defaultOptions: e.getQueryDefaults(r)
+		}), this.add(a)), a;
+	}
+	add(e) {
+		s(G, this).has(e.queryHash) || (s(G, this).set(e.queryHash, e), this.notify({
+			type: "added",
+			query: e
+		}));
+	}
+	remove(e) {
+		let t = s(G, this).get(e.queryHash);
+		t && (e.destroy(), t === e && s(G, this).delete(e.queryHash), this.notify({
+			type: "removed",
+			query: e
+		}));
+	}
+	clear() {
+		y.batch(() => {
+			this.getAll().forEach((e) => {
+				this.remove(e);
+			});
+		});
+	}
+	get(e) {
+		return s(G, this).get(e);
+	}
+	getAll() {
+		return [...s(G, this).values()];
+	}
+	find(e) {
+		let t = {
+			exact: !0,
+			...e
+		};
+		return this.getAll().find((e) => ce(t, e));
+	}
+	findAll(e = {}) {
+		let t = this.getAll();
+		return Object.keys(e).length > 0 ? t.filter((t) => ce(e, t)) : t;
+	}
+	notify(e) {
+		y.batch(() => {
+			this.listeners.forEach((t) => {
+				t(e);
+			});
+		});
+	}
+	onFocus() {
+		y.batch(() => {
+			this.getAll().forEach((e) => {
+				e.onFocus();
+			});
+		});
+	}
+	onOnline() {
+		y.batch(() => {
+			this.getAll().forEach((e) => {
+				e.onOnline();
+			});
+		});
+	}
+}), K, q, J, Y, X, Z, Q, $, We = (K = /* @__PURE__ */ new WeakMap(), q = /* @__PURE__ */ new WeakMap(), J = /* @__PURE__ */ new WeakMap(), Y = /* @__PURE__ */ new WeakMap(), X = /* @__PURE__ */ new WeakMap(), Z = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakMap(), $ = /* @__PURE__ */ new WeakMap(), class {
+	constructor(e = {}) {
+		i(this, K, void 0), i(this, q, void 0), i(this, J, void 0), i(this, Y, void 0), i(this, X, void 0), i(this, Z, void 0), i(this, Q, void 0), i(this, $, void 0), o(K, this, e.queryCache || new Ue()), o(q, this, e.mutationCache || new He()), o(J, this, e.defaultOptions || {}), o(Y, this, /* @__PURE__ */ new Map()), o(X, this, /* @__PURE__ */ new Map()), o(Z, this, 0);
+	}
+	mount() {
+		var e;
+		o(Z, this, (e = s(Z, this), e++, e)), s(Z, this) === 1 && (o(Q, this, d.subscribe(async (e) => {
+			e && (await this.resumePausedMutations(), s(K, this).onFocus());
+		})), o($, this, C.subscribe(async (e) => {
+			e && (await this.resumePausedMutations(), s(K, this).onOnline());
+		})));
+	}
+	unmount() {
+		var e;
+		o(Z, this, (e = s(Z, this), e--, e)), s(Z, this) === 0 && (s(Q, this)?.call(this), o(Q, this, void 0), s($, this)?.call(this), o($, this, void 0));
+	}
+	isFetching(e) {
+		return s(K, this).findAll({
+			...e,
+			fetchStatus: "fetching"
+		}).length;
+	}
+	isMutating(e) {
+		return s(q, this).findAll({
+			...e,
+			status: "pending"
+		}).length;
+	}
+	getQueryData(e) {
+		let t = this.defaultQueryOptions({ queryKey: e });
+		return s(K, this).get(t.queryHash)?.state.data;
+	}
+	ensureQueryData(e) {
+		let t = this.defaultQueryOptions(e), n = s(K, this).build(this, t), r = n.state.data;
+		return r === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && n.isStaleByTime(oe(t.staleTime, n)) && this.prefetchQuery(t), Promise.resolve(r));
+	}
+	getQueriesData(e) {
+		return s(K, this).findAll(e).map(({ queryKey: e, state: t }) => [e, t.data]);
+	}
+	setQueryData(e, t, n) {
+		let r = this.defaultQueryOptions({ queryKey: e }), i = s(K, this).get(r.queryHash)?.state.data, a = re(t, i);
+		if (a !== void 0) return s(K, this).build(this, r).setData(a, {
+			...n,
+			manual: !0
+		});
+	}
+	setQueriesData(e, t, n) {
+		return y.batch(() => s(K, this).findAll(e).map(({ queryKey: e }) => [e, this.setQueryData(e, t, n)]));
+	}
+	getQueryState(e) {
+		let t = this.defaultQueryOptions({ queryKey: e });
+		return s(K, this).get(t.queryHash)?.state;
+	}
+	removeQueries(e) {
+		let t = s(K, this);
+		y.batch(() => {
+			t.findAll(e).forEach((e) => {
+				t.remove(e);
+			});
+		});
+	}
+	resetQueries(e, t) {
+		let n = s(K, this);
+		return y.batch(() => (n.findAll(e).forEach((e) => {
+			e.reset();
+		}), this.refetchQueries({
+			type: "active",
+			...e
+		}, t)));
+	}
+	cancelQueries(e, t = {}) {
+		let n = {
+			revert: !0,
+			...t
+		}, r = y.batch(() => s(K, this).findAll(e).map((e) => e.cancel(n)));
+		return Promise.all(r).then(h).catch(h);
+	}
+	invalidateQueries(e, t = {}) {
+		return y.batch(() => (s(K, this).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 = y.batch(() => s(K, this).findAll(e).filter((e) => !e.isDisabled() && !e.isStatic()).map((e) => {
+			let t = e.fetch(void 0, n);
+			return n.throwOnError || (t = t.catch(h)), e.state.fetchStatus === "paused" ? Promise.resolve() : t;
+		}));
+		return Promise.all(r).then(h);
+	}
+	fetchQuery(e) {
+		let t = this.defaultQueryOptions(e);
+		t.retry === void 0 && (t.retry = !1);
+		let n = s(K, this).build(this, t);
+		return n.isStaleByTime(oe(t.staleTime, n)) ? n.fetch(t) : Promise.resolve(n.state.data);
+	}
+	prefetchQuery(e) {
+		return this.fetchQuery(e).then(h).catch(h);
+	}
+	fetchInfiniteQuery(e) {
+		return e._type = "infinite", this.fetchQuery(e);
+	}
+	prefetchInfiniteQuery(e) {
+		return this.fetchInfiniteQuery(e).then(h).catch(h);
+	}
+	ensureInfiniteQueryData(e) {
+		return e._type = "infinite", this.ensureQueryData(e);
+	}
+	resumePausedMutations() {
+		return C.isOnline() ? s(q, this).resumePausedMutations() : Promise.resolve();
+	}
+	getQueryCache() {
+		return s(K, this);
+	}
+	getMutationCache() {
+		return s(q, this);
+	}
+	getDefaultOptions() {
+		return s(J, this);
+	}
+	setDefaultOptions(e) {
+		o(J, this, e);
+	}
+	setQueryDefaults(e, t) {
+		s(Y, this).set(g(e), {
+			queryKey: e,
+			defaultOptions: t
+		});
+	}
+	getQueryDefaults(e) {
+		let t = [...s(Y, this).values()], n = {};
+		return t.forEach((t) => {
+			_(e, t.queryKey) && Object.assign(n, t.defaultOptions);
+		}), n;
+	}
+	setMutationDefaults(e, t) {
+		s(X, this).set(g(e), {
+			mutationKey: e,
+			defaultOptions: t
+		});
+	}
+	getMutationDefaults(e) {
+		let t = [...s(X, this).values()], n = {};
+		return t.forEach((t) => {
+			_(e, t.mutationKey) && Object.assign(n, t.defaultOptions);
+		}), n;
+	}
+	defaultQueryOptions(e) {
+		if (e._defaulted) return e;
+		let t = {
+			...s(J, this).queries,
+			...this.getQueryDefaults(e.queryKey),
+			...e,
+			_defaulted: !0
+		};
+		return t.queryHash ||= ue(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 === v && (t.enabled = !1), t;
+	}
+	defaultMutationOptions(e) {
+		return e?._defaulted ? e : {
+			...s(J, this).mutations,
+			...e?.mutationKey && this.getMutationDefaults(e.mutationKey),
+			...e,
+			_defaulted: !0
+		};
+	}
+	clear() {
+		s(K, this).clear(), s(q, this).clear();
+	}
+}), Ge = class n {
+	constructor(e = {}) {
+		this.availableDatasets = [], this.apiUrl = e.apiUrl || "https://api.luzmo.com", this.apiVersion = e.apiVersion || "0.1.0", this.authKey = e.authKey || "", this.authToken = e.authToken || "", this.queryClient = new We({ defaultOptions: { queries: {
+			staleTime: e.staleTime || 300 * 1e3,
+			gcTime: e.gcTime || 600 * 1e3,
+			retry: e.retry || 3,
+			retryDelay: e.retryDelay || ((e) => Math.min(1e3 * 2 ** e, 3e4))
+		} } }), e.skipNetworkListeners || this.initNetworkListeners();
+	}
+	_normalizeUrl(e) {
+		try {
+			let t = new URL(e);
+			return t.origin + t.pathname.replace(/\/$/, "");
+		} catch {
+			return e;
+		}
+	}
+	configure(e = {}) {
+		let t = e.apiUrl === void 0 ? void 0 : this._normalizeUrl(e.apiUrl), n = this._normalizeUrl(this.apiUrl), r = e.authKey !== void 0 && e.authKey !== "" && e.authKey !== this.authKey || e.authToken !== void 0 && e.authToken !== "" && e.authToken !== this.authToken || t !== void 0 && t !== n;
+		if (e.apiVersion && (this.apiVersion = e.apiVersion), e.apiUrl !== void 0 && (this.apiUrl = e.apiUrl), e.authKey !== void 0 && (this.authKey = e.authKey), e.authToken !== void 0 && (this.authToken = e.authToken), r && (this.queryClient.clear(), this.availableDatasets = []), e.staleTime || e.gcTime || e.retry) {
+			let t = {};
+			e.staleTime && (t.staleTime = e.staleTime), e.gcTime && (t.gcTime = e.gcTime), e.retry && (t.retry = e.retry), this.queryClient.setDefaultOptions({ queries: {
+				...this.queryClient.getDefaultOptions().queries,
+				...t
+			} });
+		}
+	}
+	clearLocalCache() {
+		this.queryClient.clear(), this.availableDatasets = [];
+	}
+	initNetworkListeners() {
+		typeof window < "u" && window.addEventListener("online", () => {
+			console.warn("Network connection restored, refreshing data..."), this.refreshAll();
+		});
+	}
+	getHeaders(e = {}) {
+		return {
+			"Content-Type": "application/json",
+			...e
+		};
+	}
+	async fetchApi(e, t, n = {}) {
+		let r = `${this.apiUrl}/${this.apiVersion}${e}`, i = {
+			method: n.method || "POST",
+			headers: this.getHeaders(n.headers),
+			mode: "cors",
+			...n
+		};
+		t !== void 0 && (t.key = this.authKey, t.token = this.authToken, i.body = JSON.stringify(t));
+		try {
+			let t = await fetch(r, i);
+			if (!t.ok) {
+				let n = await t.json().catch(() => null);
+				throw t.status === 401 || t.status === 403 ? Error("Authentication failed. Please check your API token.") : t.status === 404 ? Error(`Resource not found: ${e}`) : t.status === 429 ? Error("Rate limit exceeded. Please try again later.") : Error(n?.message || `API request failed with status ${t.status}`);
+			}
+			return await t.json();
+		} catch (t) {
+			throw console.error(`API request to ${e} failed:`, t), t instanceof Error && (t.endpoint = e, t.timestamp = (/* @__PURE__ */ new Date()).toISOString()), t;
+		}
+	}
+	async fetchAllDatasets(e = {}) {
+		let t = e.offset || 0, n = e.limit || 50, r = [
+			"datasets",
+			t,
+			n
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: r,
+			queryFn: async () => {
+				let e = {
+					action: "get",
+					version: this.apiVersion,
+					find: {
+						where: { type: "dataset" },
+						attributes: [
+							"id",
+							"name",
+							"description"
+						],
+						limit: n,
+						offset: t
+					}
+				}, r = await this.fetchApi("/securable", e);
+				return {
+					data: r?.rows ?? [],
+					pagination: {
+						offset: t,
+						limit: n,
+						total: r?.count ?? 0,
+						pages: Math.ceil((r?.count ?? 0) / n)
+					}
+				};
+			}
+		});
+	}
+	async searchDatasets(e, t) {
+		if (!e) return { data: [] };
+		let n = [
+			"datasets",
+			"search",
+			e,
+			t
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: n,
+			queryFn: async () => {
+				let n = {
+					action: "get",
+					version: this.apiVersion,
+					find: { where: { type: "dataset" } }
+				};
+				e?.length > 0 && (n.find.search = {
+					match_types: ["name"],
+					keyphrase: e
+				}), t?.offset && (n.find.offset = t?.offset), t?.limit && (n.find.limit = t?.limit);
+				let r = await this.fetchApi("/securable", n), i = { data: r?.rows ?? [] };
+				return t?.limit && (i.pagination = {
+					offset: t?.offset ?? 0,
+					limit: t?.limit,
+					total: r?.count ?? 0,
+					pages: Math.ceil((r?.count ?? 0) / t?.limit)
+				}), i;
+			}
+		});
+	}
+	async fetchDatasetNames(t) {
+		if (!t || t.length === 0) throw Error("At least one dataset ID is required");
+		let { valid: n, invalid: r } = e(t);
+		if (r.length > 0 && console.warn(`[DataBroker] Invalid dataset IDs provided (not valid UUIDs): ${r.join(", ")}. These will be skipped.`), n.length === 0) throw Error("No valid dataset IDs provided. Dataset IDs must be valid UUIDs.");
+		let i = [
+			"dataset-names",
+			n,
+			this.authKey,
+			this.authToken
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: i,
+			queryFn: async () => {
+				let e = {
+					action: "get",
+					version: this.apiVersion,
+					find: {
+						where: {
+							type: "dataset",
+							id: { in: n }
+						},
+						attributes: [
+							"name",
+							"id",
+							"description"
+						]
+					}
+				};
+				return (await this.fetchApi("/securable", e))?.rows ?? [];
+			}
+		});
+	}
+	async fetchDatasetsWithColumnsAndFormulas(t) {
+		if (!t || t.length === 0) throw Error("At least one dataset ID is required");
+		let { valid: n, invalid: r } = e(t);
+		if (r.length > 0 && console.warn(`[DataBroker] Invalid dataset IDs provided (not valid UUIDs): ${r.join(", ")}. These will be skipped.`), n.length === 0) throw Error("No valid dataset IDs provided. Dataset IDs must be valid UUIDs.");
+		let i = [
+			"datasets",
+			n,
+			this.authKey,
+			this.authToken
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: i,
+			queryFn: async () => {
+				let e = {
+					action: "get",
+					version: this.apiVersion,
+					find: {
+						where: {
+							type: "dataset",
+							id: { in: n }
+						},
+						attributes: [
+							"name",
+							"id",
+							"description"
+						],
+						include: [{
+							model: "Column",
+							attributes: [
+								"id",
+								"name",
+								"description",
+								"type",
+								"subtype",
+								"format",
+								"hidden",
+								"lowestLevel",
+								"expression",
+								"duration_levels",
+								"duration_format"
+							],
+							separate: !0,
+							order: [["order", "asc"]],
+							include: [
+								{
+									model: "Column",
+									attributes: [
+										"id",
+										"securable_id",
+										"hierarchy_enabled",
+										"currency_id"
+									],
+									as: "Joins"
+								},
+								{
+									model: "HierarchyLevel",
+									attributes: [
+										"id",
+										"level",
+										"name"
+									],
+									as: "HierarchyLevels"
+								},
+								{
+									model: "Currency",
+									attributes: [
+										"id",
+										"name",
+										"symbol"
+									],
+									as: "Currency"
+								}
+							]
+						}, {
+							model: "Formula",
+							attributes: [
+								"id",
+								"name",
+								"description",
+								"type",
+								"subtype",
+								"format",
+								"hidden",
+								"lowestLevel",
+								"expression",
+								"duration_levels",
+								"duration_format"
+							],
+							include: [{
+								model: "Currency",
+								attributes: [
+									"id",
+									"name",
+									"symbol"
+								],
+								as: "Currency"
+							}]
+						}]
+					}
+				};
+				return (await this.fetchApi("/securable", e))?.rows ?? [];
+			}
+		});
+	}
+	async fetchData(e) {
+		if (!e) throw Error("Query is required");
+		let t = ["data", e];
+		return await this.queryClient.fetchQuery({
+			queryKey: t,
+			queryFn: async () => {
+				let t = {
+					action: "get",
+					version: this.apiVersion,
+					find: { queries: [e] }
+				}, n = await this.fetchApi("/data", t);
+				return {
+					data: n?.data || [],
+					performance: n?.performance || {}
+				};
+			}
+		});
+	}
+	getCachedData(e) {
+		let t = ["data", e], n = this.queryClient.getQueryState(t), r = this.queryClient.getDefaultOptions().queries?.staleTime;
+		if (!(!n?.data || n.isInvalidated || typeof r != "number") && !(r !== Infinity && Date.now() - n.dataUpdatedAt > r)) return n.data;
+	}
+	async validate(e, t) {
+		if (!t?.expression) return { valid: !1 };
+		let n = {
+			action: "validate",
+			version: this.apiVersion,
+			properties: t
+		}, r = await this.fetchApi(`/${e}`, n);
+		return {
+			valid: !!r?.valid,
+			reason: r?.reason ?? r?.error,
+			explanation: r?.explanation,
+			type: r?.type
+		};
+	}
+	async fetchTheme(e) {
+		if (!e) throw Error("Theme ID is required");
+		let t = ["theme", e];
+		return await this.queryClient.fetchQuery({
+			queryKey: t,
+			queryFn: async () => (await this.fetchApi("/theme", {
+				action: "get",
+				version: this.apiVersion,
+				find: { where: { id: e } }
+			}))?.rows?.[0]
+		});
+	}
+	refreshAll() {
+		this.queryClient.refetchQueries();
+	}
+	invalidateDatasetData(e) {
+		e ? (this.queryClient.invalidateQueries({ queryKey: ["dataset", e] }), this.queryClient.invalidateQueries({ queryKey: ["columns", e] })) : this.queryClient.invalidateQueries({ queryKey: ["datasets"] });
+	}
+	invalidateAll() {
+		this.queryClient.clear();
+	}
+	static getInstance(e = {}) {
+		return n.instance ? Object.keys(e).length > 0 && n.instance.configure(e) : n.instance = new n(e), n.instance;
+	}
+	async fetchDatasetsRecursive(n) {
+		if (!n || n.length === 0) throw Error("At least one dataset ID is required");
+		let { valid: r, invalid: i } = e(n);
+		if (i.length > 0 && console.warn(`[DataBroker] Invalid dataset IDs provided (not valid UUIDs): ${i.join(", ")}. These will be skipped.`), r.length === 0) throw Error("No valid dataset IDs provided. Dataset IDs must be valid UUIDs.");
+		let a = [...new Set(r)], o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map(), c = (e) => {
+			e && t(e) && !o.has(e) && !a.includes(e) && a.push(e);
+		};
+		for (; a.length > 0;) {
+			let e = [];
+			for (; a.length > 0 && e.length < 50;) {
+				let t = a.shift();
+				o.has(t) || e.push(t);
+			}
+			if (e.length !== 0) try {
+				(await this.fetchDatasetsWithColumnsAndFormulas(e)).forEach((e) => {
+					let t = this.postProcessDatasetMetadata(e);
+					o.add(t.id), this.queryClient.setQueryData(["dataset", t.id], t), (t.outgoingJoins ?? []).map((e) => e.securable_id).filter((e) => !!e && e !== t.id).forEach((e) => {
+						c(e);
+					}), s.set(t.id, t), this.availableDatasets.some((e) => e.id === t.id) || this.availableDatasets.push({
+						id: t.id,
+						name: t.name,
+						columns: t.columns
+					});
+				});
+			} catch (e) {
+				console.error("Error fetching datasets recursively:", e);
+			}
+		}
+		return [...s.values()];
+	}
+	postProcessDatasetMetadata(e) {
+		let t = [], n = (e.columns ?? []).map((e) => {
+			let n = e.joins ?? (Array.isArray(e.joins) ? e.joins : []);
+			Array.isArray(n) && n.length > 0 && t.push(...n);
+			let { joins: r, ...i } = e;
+			return {
+				...i,
+				joins: n
+			};
+		});
+		return {
+			...e,
+			columns: n,
+			formulas: e.formulas ?? [],
+			outgoingJoins: t,
+			dateLoaded: /* @__PURE__ */ new Date()
+		};
+	}
+	getAvailableDatasets() {
+		return this.availableDatasets;
+	}
+	getLinkedDatasetsIds(e) {
+		let t = this.queryClient.getQueryData(["dataset", e]);
+		return t ? (t.outgoingJoins ?? []).map((e) => e.securable_id).filter((t) => !!t && t !== e) : [];
+	}
+}, Ke = Ge.getInstance();
+//#endregion
+export { Ke as n, Ge as t };