@nanoforge-dev/editor 0.0.1 → 0.0.2-beta.8c768e4

package/dist/server/chunks/loader-circle-zqx69BdD.js

@@ -0,0 +1,1592 @@
+import { D as ensure_array_like, E as element, P as getContext, R as hasContext, ct as setContext, dt as spread_props, h as attributes, ot as run, r as on, w as derived, y as clsx$1 } from "./events-DeYJGjCt.js";
+//#region .svelte-kit/adapter-bun/chunks/loader-circle.js
+var Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		this.onSubscribe();
+		return () => {
+			this.listeners.delete(listener);
+			this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+};
+var FocusManager = class extends Subscribable {
+	#focused;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onFocus) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const listener = () => onFocus();
+				window.addEventListener("visibilitychange", listener, false);
+				return () => {
+					window.removeEventListener("visibilitychange", listener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup((focused) => {
+			if (typeof focused === "boolean") this.setFocused(focused);
+			else this.onFocus();
+		});
+	}
+	setFocused(focused) {
+		if (this.#focused !== focused) {
+			this.#focused = focused;
+			this.onFocus();
+		}
+	}
+	onFocus() {
+		const isFocused = this.isFocused();
+		this.listeners.forEach((listener) => {
+			listener(isFocused);
+		});
+	}
+	isFocused() {
+		if (typeof this.#focused === "boolean") return this.#focused;
+		return globalThis.document?.visibilityState !== "hidden";
+	}
+};
+var focusManager = new FocusManager();
+var defaultTimeoutProvider = {
+	setTimeout: (callback, delay) => setTimeout(callback, delay),
+	clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+	setInterval: (callback, delay) => setInterval(callback, delay),
+	clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+	#provider = defaultTimeoutProvider;
+	#providerCalled = false;
+	setTimeoutProvider(provider) {
+		if (this.#providerCalled && provider !== this.#provider) console.error(`[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`, {
+			previous: this.#provider,
+			provider
+		});
+		this.#provider = provider;
+		this.#providerCalled = false;
+	}
+	setTimeout(callback, delay) {
+		this.#providerCalled = true;
+		return this.#provider.setTimeout(callback, delay);
+	}
+	clearTimeout(timeoutId) {
+		this.#provider.clearTimeout(timeoutId);
+	}
+	setInterval(callback, delay) {
+		this.#providerCalled = true;
+		return this.#provider.setInterval(callback, delay);
+	}
+	clearInterval(intervalId) {
+		this.#provider.clearInterval(intervalId);
+	}
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+	setTimeout(callback, 0);
+}
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {}
+function functionalUpdate(updater, input) {
+	return typeof updater === "function" ? updater(input) : updater;
+}
+function isValidTimeout(value) {
+	return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+	return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+	return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveQueryBoolean(option, query) {
+	return typeof option === "function" ? option(query) : option;
+}
+function matchQuery(filters, query) {
+	const { type = "all", exact, fetchStatus, predicate, queryKey, stale } = filters;
+	if (queryKey) {
+		if (exact) {
+			if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) return false;
+		} else if (!partialMatchKey(query.queryKey, queryKey)) return false;
+	}
+	if (type !== "all") {
+		const isActive = query.isActive();
+		if (type === "active" && !isActive) return false;
+		if (type === "inactive" && isActive) return false;
+	}
+	if (typeof stale === "boolean" && query.isStale() !== stale) return false;
+	if (fetchStatus && fetchStatus !== query.state.fetchStatus) return false;
+	if (predicate && !predicate(query)) return false;
+	return true;
+}
+function matchMutation(filters, mutation) {
+	const { exact, status, predicate, mutationKey } = filters;
+	if (mutationKey) {
+		if (!mutation.options.mutationKey) return false;
+		if (exact) {
+			if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) return false;
+		} else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) return false;
+	}
+	if (status && mutation.state.status !== status) return false;
+	if (predicate && !predicate(mutation)) return false;
+	return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+	return (options?.queryKeyHashFn || hashKey)(queryKey);
+}
+function hashKey(queryKey) {
+	return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+		result[key] = val[key];
+		return result;
+	}, {}) : val);
+}
+function partialMatchKey(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a && b && typeof a === "object" && typeof b === "object") return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
+	return false;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b, depth = 0) {
+	if (a === b) return a;
+	if (depth > 500) return b;
+	const array = isPlainArray(a) && isPlainArray(b);
+	if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+	const aSize = (array ? a : Object.keys(a)).length;
+	const bItems = array ? b : Object.keys(b);
+	const bSize = bItems.length;
+	const copy = array ? new Array(bSize) : {};
+	let equalItems = 0;
+	for (let i = 0; i < bSize; i++) {
+		const key = array ? i : bItems[i];
+		const aItem = a[key];
+		const bItem = b[key];
+		if (aItem === bItem) {
+			copy[key] = aItem;
+			if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+			continue;
+		}
+		if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+			copy[key] = bItem;
+			continue;
+		}
+		const v = replaceEqualDeep(aItem, bItem, depth + 1);
+		copy[key] = v;
+		if (v === aItem) equalItems++;
+	}
+	return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+	if (!b || Object.keys(a).length !== Object.keys(b).length) return false;
+	for (const key in a) if (a[key] !== b[key]) return false;
+	return true;
+}
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+	if (!hasObjectPrototype(o)) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (!hasObjectPrototype(prot)) return false;
+	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+	if (Object.getPrototypeOf(o) !== Object.prototype) return false;
+	return true;
+}
+function hasObjectPrototype(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+function sleep(timeout) {
+	return new Promise((resolve) => {
+		timeoutManager.setTimeout(resolve, timeout);
+	});
+}
+function replaceData(prevData, data, options) {
+	if (typeof options.structuralSharing === "function") return options.structuralSharing(prevData, data);
+	else if (options.structuralSharing !== false) {
+		try {
+			return replaceEqualDeep(prevData, data);
+		} catch (error) {
+			console.error(`Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`);
+			throw error;
+		}
+		return replaceEqualDeep(prevData, data);
+	}
+	return data;
+}
+function addToEnd(items, item, max = 0) {
+	const newItems = [...items, item];
+	return max && newItems.length > max ? newItems.slice(1) : newItems;
+}
+function addToStart(items, item, max = 0) {
+	const newItems = [item, ...items];
+	return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+}
+var skipToken = /* @__PURE__ */ Symbol();
+function ensureQueryFn(options, fetchOptions) {
+	if (options.queryFn === skipToken) console.error(`Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`);
+	if (!options.queryFn && fetchOptions?.initialPromise) return () => fetchOptions.initialPromise;
+	if (!options.queryFn || options.queryFn === skipToken) return () => Promise.reject(/* @__PURE__ */ new Error(`Missing queryFn: '${options.queryHash}'`));
+	return options.queryFn;
+}
+function addConsumeAwareSignal(object, getSignal, onCancelled) {
+	let consumed = false;
+	let signal;
+	Object.defineProperty(object, "signal", {
+		enumerable: true,
+		get: () => {
+			signal ??= getSignal();
+			if (consumed) return signal;
+			consumed = true;
+			if (signal.aborted) onCancelled();
+			else signal.addEventListener("abort", onCancelled, { once: true });
+			return signal;
+		}
+	});
+	return object;
+}
+var environmentManager = /* @__PURE__ */ (() => {
+	let isServerFn = () => isServer;
+	return {
+		/**
+		* Returns whether the current runtime should be treated as a server environment.
+		*/
+		isServer() {
+			return isServerFn();
+		},
+		/**
+		* Overrides the server check globally.
+		*/
+		setIsServer(isServerValue) {
+			isServerFn = isServerValue;
+		}
+	};
+})();
+function pendingThenable() {
+	let resolve;
+	let reject;
+	const thenable = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	thenable.status = "pending";
+	thenable.catch(() => {});
+	function finalize(data) {
+		Object.assign(thenable, data);
+		delete thenable.resolve;
+		delete thenable.reject;
+	}
+	thenable.resolve = (value) => {
+		finalize({
+			status: "fulfilled",
+			value
+		});
+		resolve(value);
+	};
+	thenable.reject = (reason) => {
+		finalize({
+			status: "rejected",
+			reason
+		});
+		reject(reason);
+	};
+	return thenable;
+}
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+	let queue = [];
+	let transactions = 0;
+	let notifyFn = (callback) => {
+		callback();
+	};
+	let batchNotifyFn = (callback) => {
+		callback();
+	};
+	let scheduleFn = defaultScheduler;
+	const schedule = (callback) => {
+		if (transactions) queue.push(callback);
+		else scheduleFn(() => {
+			notifyFn(callback);
+		});
+	};
+	const flush = () => {
+		const originalQueue = queue;
+		queue = [];
+		if (originalQueue.length) scheduleFn(() => {
+			batchNotifyFn(() => {
+				originalQueue.forEach((callback) => {
+					notifyFn(callback);
+				});
+			});
+		});
+	};
+	return {
+		batch: (callback) => {
+			let result;
+			transactions++;
+			try {
+				result = callback();
+			} finally {
+				transactions--;
+				if (!transactions) flush();
+			}
+			return result;
+		},
+		/**
+		* All calls to the wrapped function will be batched.
+		*/
+		batchCalls: (callback) => {
+			return (...args) => {
+				schedule(() => {
+					callback(...args);
+				});
+			};
+		},
+		schedule,
+		/**
+		* Use this method to set a custom notify function.
+		* This can be used to for example wrap notifications with `React.act` while running tests.
+		*/
+		setNotifyFunction: (fn) => {
+			notifyFn = fn;
+		},
+		/**
+		* Use this method to set a custom function to batch notifications together into a single tick.
+		* By default React Query will use the batch function provided by ReactDOM or React Native.
+		*/
+		setBatchNotifyFunction: (fn) => {
+			batchNotifyFn = fn;
+		},
+		setScheduler: (fn) => {
+			scheduleFn = fn;
+		}
+	};
+}
+var notifyManager = createNotifyManager();
+var OnlineManager = class extends Subscribable {
+	#online = true;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onOnline) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const onlineListener = () => onOnline(true);
+				const offlineListener = () => onOnline(false);
+				window.addEventListener("online", onlineListener, false);
+				window.addEventListener("offline", offlineListener, false);
+				return () => {
+					window.removeEventListener("online", onlineListener);
+					window.removeEventListener("offline", offlineListener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup(this.setOnline.bind(this));
+	}
+	setOnline(online) {
+		if (this.#online !== online) {
+			this.#online = online;
+			this.listeners.forEach((listener) => {
+				listener(online);
+			});
+		}
+	}
+	isOnline() {
+		return this.#online;
+	}
+};
+var onlineManager = new OnlineManager();
+function defaultRetryDelay(failureCount) {
+	return Math.min(1e3 * 2 ** failureCount, 3e4);
+}
+function canFetch(networkMode) {
+	return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+var CancelledError = class extends Error {
+	constructor(options) {
+		super("CancelledError");
+		this.revert = options?.revert;
+		this.silent = options?.silent;
+	}
+};
+function createRetryer(config) {
+	let isRetryCancelled = false;
+	let failureCount = 0;
+	let continueFn;
+	const thenable = pendingThenable();
+	const isResolved = () => thenable.status !== "pending";
+	const cancel = (cancelOptions) => {
+		if (!isResolved()) {
+			const error = new CancelledError(cancelOptions);
+			reject(error);
+			config.onCancel?.(error);
+		}
+	};
+	const cancelRetry = () => {
+		isRetryCancelled = true;
+	};
+	const continueRetry = () => {
+		isRetryCancelled = false;
+	};
+	const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
+	const canStart = () => canFetch(config.networkMode) && config.canRun();
+	const resolve = (value) => {
+		if (!isResolved()) {
+			continueFn?.();
+			thenable.resolve(value);
+		}
+	};
+	const reject = (value) => {
+		if (!isResolved()) {
+			continueFn?.();
+			thenable.reject(value);
+		}
+	};
+	const pause = () => {
+		return new Promise((continueResolve) => {
+			continueFn = (value) => {
+				if (isResolved() || canContinue()) continueResolve(value);
+			};
+			config.onPause?.();
+		}).then(() => {
+			continueFn = void 0;
+			if (!isResolved()) config.onContinue?.();
+		});
+	};
+	const run = () => {
+		if (isResolved()) return;
+		let promiseOrValue;
+		const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+		try {
+			promiseOrValue = initialPromise ?? config.fn();
+		} catch (error) {
+			promiseOrValue = Promise.reject(error);
+		}
+		Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
+			if (isResolved()) return;
+			const retry = config.retry ?? (environmentManager.isServer() ? 0 : 3);
+			const retryDelay = config.retryDelay ?? defaultRetryDelay;
+			const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
+			const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
+			if (isRetryCancelled || !shouldRetry) {
+				reject(error);
+				return;
+			}
+			failureCount++;
+			config.onFail?.(failureCount, error);
+			sleep(delay).then(() => {
+				return canContinue() ? void 0 : pause();
+			}).then(() => {
+				if (isRetryCancelled) reject(error);
+				else run();
+			});
+		});
+	};
+	return {
+		promise: thenable,
+		status: () => thenable.status,
+		cancel,
+		continue: () => {
+			continueFn?.();
+			return thenable;
+		},
+		cancelRetry,
+		continueRetry,
+		canStart,
+		start: () => {
+			if (canStart()) run();
+			else pause().then(run);
+			return thenable;
+		}
+	};
+}
+var Removable = class {
+	#gcTimeout;
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout();
+		if (isValidTimeout(this.gcTime)) this.#gcTimeout = timeoutManager.setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime);
+	}
+	updateGcTime(newGcTime) {
+		this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? (environmentManager.isServer() ? Infinity : 300 * 1e3));
+	}
+	clearGcTimeout() {
+		if (this.#gcTimeout !== void 0) {
+			timeoutManager.clearTimeout(this.#gcTimeout);
+			this.#gcTimeout = void 0;
+		}
+	}
+};
+function infiniteQueryBehavior(pages) {
+	return { onFetch: (context, query) => {
+		const options = context.options;
+		const direction = context.fetchOptions?.meta?.fetchMore?.direction;
+		const oldPages = context.state.data?.pages || [];
+		const oldPageParams = context.state.data?.pageParams || [];
+		let result = {
+			pages: [],
+			pageParams: []
+		};
+		let currentPage = 0;
+		const fetchFn = async () => {
+			let cancelled = false;
+			const addSignalProperty = (object) => {
+				addConsumeAwareSignal(object, () => context.signal, () => cancelled = true);
+			};
+			const queryFn = ensureQueryFn(context.options, context.fetchOptions);
+			const fetchPage = async (data, param, previous) => {
+				if (cancelled) return Promise.reject(context.signal.reason);
+				if (param == null && data.pages.length) return Promise.resolve(data);
+				const createQueryFnContext = () => {
+					const queryFnContext2 = {
+						client: context.client,
+						queryKey: context.queryKey,
+						pageParam: param,
+						direction: previous ? "backward" : "forward",
+						meta: context.options.meta
+					};
+					addSignalProperty(queryFnContext2);
+					return queryFnContext2;
+				};
+				const page = await queryFn(createQueryFnContext());
+				const { maxPages } = context.options;
+				const addTo = previous ? addToStart : addToEnd;
+				return {
+					pages: addTo(data.pages, page, maxPages),
+					pageParams: addTo(data.pageParams, param, maxPages)
+				};
+			};
+			if (direction && oldPages.length) {
+				const previous = direction === "backward";
+				const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+				const oldData = {
+					pages: oldPages,
+					pageParams: oldPageParams
+				};
+				result = await fetchPage(oldData, pageParamFn(options, oldData), previous);
+			} else {
+				const remainingPages = pages ?? oldPages.length;
+				do {
+					const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);
+					if (currentPage > 0 && param == null) break;
+					result = await fetchPage(result, param);
+					currentPage++;
+				} while (currentPage < remainingPages);
+			}
+			return result;
+		};
+		if (context.options.persister) context.fetchFn = () => {
+			return context.options.persister?.(fetchFn, {
+				client: context.client,
+				queryKey: context.queryKey,
+				meta: context.options.meta,
+				signal: context.signal
+			}, query);
+		};
+		else context.fetchFn = fetchFn;
+	} };
+}
+function getNextPageParam(options, { pages, pageParams }) {
+	const lastIndex = pages.length - 1;
+	return pages.length > 0 ? options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams) : void 0;
+}
+function getPreviousPageParam(options, { pages, pageParams }) {
+	return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;
+}
+var Query = class extends Removable {
+	#queryType;
+	#initialState;
+	#revertState;
+	#cache;
+	#client;
+	#retryer;
+	#defaultOptions;
+	#abortSignalConsumed;
+	constructor(config) {
+		super();
+		this.#abortSignalConsumed = false;
+		this.#defaultOptions = config.defaultOptions;
+		this.setOptions(config.options);
+		this.observers = [];
+		this.#client = config.client;
+		this.#cache = this.#client.getQueryCache();
+		this.queryKey = config.queryKey;
+		this.queryHash = config.queryHash;
+		this.#initialState = getDefaultState(this.options);
+		this.state = config.state ?? this.#initialState;
+		this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get queryType() {
+		return this.#queryType;
+	}
+	get promise() {
+		return this.#retryer?.promise;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.#defaultOptions,
+			...options
+		};
+		if (options?._type) this.#queryType = options._type;
+		this.updateGcTime(this.options.gcTime);
+		if (this.state && this.state.data === void 0) {
+			const defaultState = getDefaultState(this.options);
+			if (defaultState.data !== void 0) {
+				this.setState(successState(defaultState.data, defaultState.dataUpdatedAt));
+				this.#initialState = defaultState;
+			}
+		}
+	}
+	optionalRemove() {
+		if (!this.observers.length && this.state.fetchStatus === "idle") this.#cache.remove(this);
+	}
+	setData(newData, options) {
+		const data = replaceData(this.state.data, newData, this.options);
+		this.#dispatch({
+			data,
+			type: "success",
+			dataUpdatedAt: options?.updatedAt,
+			manual: options?.manual
+		});
+		return data;
+	}
+	setState(state) {
+		this.#dispatch({
+			type: "setState",
+			state
+		});
+	}
+	cancel(options) {
+		const promise = this.#retryer?.promise;
+		this.#retryer?.cancel(options);
+		return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy();
+		this.cancel({ silent: true });
+	}
+	get resetState() {
+		return this.#initialState;
+	}
+	reset() {
+		this.destroy();
+		this.setState(this.resetState);
+	}
+	isActive() {
+		return this.observers.some((observer) => resolveQueryBoolean(observer.options.enabled, this) !== false);
+	}
+	isDisabled() {
+		if (this.getObserversCount() > 0) return !this.isActive();
+		return this.options.queryFn === skipToken || !this.isFetched();
+	}
+	isFetched() {
+		return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+	}
+	isStatic() {
+		if (this.getObserversCount() > 0) return this.observers.some((observer) => resolveStaleTime(observer.options.staleTime, this) === "static");
+		return false;
+	}
+	isStale() {
+		if (this.getObserversCount() > 0) return this.observers.some((observer) => observer.getCurrentResult().isStale);
+		return this.state.data === void 0 || this.state.isInvalidated;
+	}
+	isStaleByTime(staleTime = 0) {
+		if (this.state.data === void 0) return true;
+		if (staleTime === "static") return false;
+		if (this.state.isInvalidated) return true;
+		return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+	}
+	onFocus() {
+		this.observers.find((x) => x.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: false });
+		this.#retryer?.continue();
+	}
+	onOnline() {
+		this.observers.find((x) => x.shouldFetchOnReconnect())?.refetch({ cancelRefetch: false });
+		this.#retryer?.continue();
+	}
+	addObserver(observer) {
+		if (!this.observers.includes(observer)) {
+			this.observers.push(observer);
+			this.clearGcTimeout();
+			this.#cache.notify({
+				type: "observerAdded",
+				query: this,
+				observer
+			});
+		}
+	}
+	removeObserver(observer) {
+		if (this.observers.includes(observer)) {
+			this.observers = this.observers.filter((x) => x !== observer);
+			if (!this.observers.length) {
+				if (this.#retryer) if (this.#abortSignalConsumed || this.#isInitialPausedFetch()) this.#retryer.cancel({ revert: true });
+				else this.#retryer.cancelRetry();
+				this.scheduleGc();
+			}
+			this.#cache.notify({
+				type: "observerRemoved",
+				query: this,
+				observer
+			});
+		}
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	#isInitialPausedFetch() {
+		return this.state.fetchStatus === "paused" && this.state.status === "pending";
+	}
+	invalidate() {
+		if (!this.state.isInvalidated) this.#dispatch({ type: "invalidate" });
+	}
+	async fetch(options, fetchOptions) {
+		if (this.state.fetchStatus !== "idle" && this.#retryer?.status() !== "rejected") {
+			if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) this.cancel({ silent: true });
+			else if (this.#retryer) {
+				this.#retryer.continueRetry();
+				return this.#retryer.promise;
+			}
+		}
+		if (options) this.setOptions(options);
+		if (!this.options.queryFn) {
+			const observer = this.observers.find((x) => x.options.queryFn);
+			if (observer) this.setOptions(observer.options);
+		}
+		if (!Array.isArray(this.options.queryKey)) console.error(`As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`);
+		const abortController = new AbortController();
+		const addSignalProperty = (object) => {
+			Object.defineProperty(object, "signal", {
+				enumerable: true,
+				get: () => {
+					this.#abortSignalConsumed = true;
+					return abortController.signal;
+				}
+			});
+		};
+		const fetchFn = () => {
+			const queryFn = ensureQueryFn(this.options, fetchOptions);
+			const createQueryFnContext = () => {
+				const queryFnContext2 = {
+					client: this.#client,
+					queryKey: this.queryKey,
+					meta: this.meta
+				};
+				addSignalProperty(queryFnContext2);
+				return queryFnContext2;
+			};
+			const queryFnContext = createQueryFnContext();
+			this.#abortSignalConsumed = false;
+			if (this.options.persister) return this.options.persister(queryFn, queryFnContext, this);
+			return queryFn(queryFnContext);
+		};
+		const createFetchContext = () => {
+			const context2 = {
+				fetchOptions,
+				options: this.options,
+				queryKey: this.queryKey,
+				client: this.#client,
+				state: this.state,
+				fetchFn
+			};
+			addSignalProperty(context2);
+			return context2;
+		};
+		const context = createFetchContext();
+		(this.#queryType === "infinite" ? infiniteQueryBehavior(this.options.pages) : this.options.behavior)?.onFetch(context, this);
+		this.#revertState = this.state;
+		if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) this.#dispatch({
+			type: "fetch",
+			meta: context.fetchOptions?.meta
+		});
+		this.#retryer = createRetryer({
+			initialPromise: fetchOptions?.initialPromise,
+			fn: context.fetchFn,
+			onCancel: (error) => {
+				if (error instanceof CancelledError && error.revert) this.setState({
+					...this.#revertState,
+					fetchStatus: "idle"
+				});
+				abortController.abort();
+			},
+			onFail: (failureCount, error) => {
+				this.#dispatch({
+					type: "failed",
+					failureCount,
+					error
+				});
+			},
+			onPause: () => {
+				this.#dispatch({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#dispatch({ type: "continue" });
+			},
+			retry: context.options.retry,
+			retryDelay: context.options.retryDelay,
+			networkMode: context.options.networkMode,
+			canRun: () => true
+		});
+		try {
+			const data = await this.#retryer.start();
+			if (data === void 0) {
+				console.error(`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`);
+				throw new Error(`${this.queryHash} data is undefined`);
+			}
+			this.setData(data);
+			this.#cache.config.onSuccess?.(data, this);
+			this.#cache.config.onSettled?.(data, this.state.error, this);
+			return data;
+		} catch (error) {
+			if (error instanceof CancelledError) {
+				if (error.silent) return this.#retryer.promise;
+				else if (error.revert) {
+					if (this.state.data === void 0) throw error;
+					return this.state.data;
+				}
+			}
+			this.#dispatch({
+				type: "error",
+				error
+			});
+			this.#cache.config.onError?.(error, this);
+			this.#cache.config.onSettled?.(this.state.data, error, this);
+			throw error;
+		} finally {
+			this.scheduleGc();
+		}
+	}
+	#dispatch(action) {
+		const reducer = (state) => {
+			switch (action.type) {
+				case "failed": return {
+					...state,
+					fetchFailureCount: action.failureCount,
+					fetchFailureReason: action.error
+				};
+				case "pause": return {
+					...state,
+					fetchStatus: "paused"
+				};
+				case "continue": return {
+					...state,
+					fetchStatus: "fetching"
+				};
+				case "fetch": return {
+					...state,
+					...fetchState(state.data, this.options),
+					fetchMeta: action.meta ?? null
+				};
+				case "success":
+					const newState = {
+						...state,
+						...successState(action.data, action.dataUpdatedAt),
+						dataUpdateCount: state.dataUpdateCount + 1,
+						...!action.manual && {
+							fetchStatus: "idle",
+							fetchFailureCount: 0,
+							fetchFailureReason: null
+						}
+					};
+					this.#revertState = action.manual ? newState : void 0;
+					return newState;
+				case "error":
+					const error = action.error;
+					return {
+						...state,
+						error,
+						errorUpdateCount: state.errorUpdateCount + 1,
+						errorUpdatedAt: Date.now(),
+						fetchFailureCount: state.fetchFailureCount + 1,
+						fetchFailureReason: error,
+						fetchStatus: "idle",
+						status: "error",
+						isInvalidated: true
+					};
+				case "invalidate": return {
+					...state,
+					isInvalidated: true
+				};
+				case "setState": return {
+					...state,
+					...action.state
+				};
+			}
+		};
+		this.state = reducer(this.state);
+		notifyManager.batch(() => {
+			this.observers.forEach((observer) => {
+				observer.onQueryUpdate();
+			});
+			this.#cache.notify({
+				query: this,
+				type: "updated",
+				action
+			});
+		});
+	}
+};
+function fetchState(data, options) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+		...data === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function successState(data, dataUpdatedAt) {
+	return {
+		data,
+		dataUpdatedAt: dataUpdatedAt ?? Date.now(),
+		error: null,
+		isInvalidated: false,
+		status: "success"
+	};
+}
+function getDefaultState(options) {
+	const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+	const hasData = data !== void 0;
+	const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+	return {
+		data,
+		dataUpdateCount: 0,
+		dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: false,
+		status: hasData ? "success" : "pending",
+		fetchStatus: "idle"
+	};
+}
+var _contextKey = Symbol("QueryClient");
+/** Retrieves a Client from Svelte's context */
+var getQueryClientContext = () => {
+	const client = getContext(_contextKey);
+	if (!client) throw new Error("No QueryClient was found in Svelte context. Did you forget to wrap your component with QueryClientProvider?");
+	return client;
+};
+/** Sets a QueryClient on Svelte's context */
+var setQueryClientContext = (client) => {
+	setContext(_contextKey, client);
+};
+var _isRestoringContextKey = Symbol("isRestoring");
+/** Retrieves a `isRestoring` from Svelte's context */
+var getIsRestoringContext = () => {
+	try {
+		return getContext(_isRestoringContextKey) ?? { current: false };
+	} catch (error) {
+		return { current: false };
+	}
+};
+globalThis.Date;
+var SvelteSet = globalThis.Set;
+var SvelteMap = globalThis.Map;
+globalThis.URL;
+globalThis.URLSearchParams;
+var MediaQuery = class {
+	current;
+	/**
+	* @param {string} query
+	* @param {boolean} [matches]
+	*/
+	constructor(query, matches = false) {
+		this.current = matches;
+	}
+};
+/**
+* @param {any} _
+*/
+function createSubscriber(_) {
+	return () => {};
+}
+function cn(...classes) {
+	return classes.filter(Boolean).join(" ");
+}
+var isBrowser = typeof document !== "undefined";
+var defaultWindow = void 0;
+/**
+* Handles getting the active element in a document or shadow root.
+* If the active element is within a shadow root, it will traverse the shadow root
+* to find the active element.
+* If not, it will return the active element in the document.
+*
+* @param document A document or shadow root to get the active element from.
+* @returns The active element in the document or shadow root.
+*/
+function getActiveElement(document) {
+	let activeElement = document.activeElement;
+	while (activeElement?.shadowRoot) {
+		const node = activeElement.shadowRoot.activeElement;
+		if (node === activeElement) break;
+		else activeElement = node;
+	}
+	return activeElement;
+}
+var ActiveElement = class {
+	#document;
+	#subscribe;
+	constructor(options = {}) {
+		const { window = defaultWindow, document = window?.document } = options;
+		if (window === void 0) return;
+		this.#document = document;
+		this.#subscribe = createSubscriber((update) => {
+			const cleanupFocusIn = on(window, "focusin", update);
+			const cleanupFocusOut = on(window, "focusout", update);
+			return () => {
+				cleanupFocusIn();
+				cleanupFocusOut();
+			};
+		});
+	}
+	get current() {
+		this.#subscribe?.();
+		if (!this.#document) return null;
+		return getActiveElement(this.#document);
+	}
+};
+new ActiveElement();
+var Context = class {
+	#name;
+	#key;
+	/**
+	* @param name The name of the context.
+	* This is used for generating the context key and error messages.
+	*/
+	constructor(name) {
+		this.#name = name;
+		this.#key = Symbol(name);
+	}
+	/**
+	* The key used to get and set the context.
+	*
+	* It is not recommended to use this value directly.
+	* Instead, use the methods provided by this class.
+	*/
+	get key() {
+		return this.#key;
+	}
+	/**
+	* Checks whether this has been set in the context of a parent component.
+	*
+	* Must be called during component initialisation.
+	*/
+	exists() {
+		return hasContext(this.#key);
+	}
+	/**
+	* Retrieves the context that belongs to the closest parent component.
+	*
+	* Must be called during component initialisation.
+	*
+	* @throws An error if the context does not exist.
+	*/
+	get() {
+		const context = getContext(this.#key);
+		if (context === void 0) throw new Error(`Context "${this.#name}" not found`);
+		return context;
+	}
+	/**
+	* Retrieves the context that belongs to the closest parent component,
+	* or the given fallback value if the context does not exist.
+	*
+	* Must be called during component initialisation.
+	*/
+	getOr(fallback) {
+		const context = getContext(this.#key);
+		if (context === void 0) return fallback;
+		return context;
+	}
+	/**
+	* Associates the given value with the current component and returns it.
+	*
+	* Must be called during component initialisation.
+	*/
+	set(context) {
+		return setContext(this.#key, context);
+	}
+};
+function runWatcher(sources, flush, effect, options = {}) {
+	const { lazy = false } = options;
+}
+function watch(sources, effect, options) {
+	runWatcher(sources, "post", effect, options);
+}
+function watchPre(sources, effect, options) {
+	runWatcher(sources, "pre", effect, options);
+}
+watch.pre = watchPre;
+function watchOnce(source, effect) {}
+function watchOncePre(source, effect) {}
+watchOnce.pre = watchOncePre;
+function debounce(fn, delay) {
+	let timeoutId;
+	let lastResolve = null;
+	return (...args) => {
+		return new Promise((resolve) => {
+			if (lastResolve) lastResolve(void 0);
+			lastResolve = resolve;
+			clearTimeout(timeoutId);
+			timeoutId = setTimeout(async () => {
+				const result = await fn(...args);
+				if (lastResolve) {
+					lastResolve(result);
+					lastResolve = null;
+				}
+			}, delay);
+		});
+	};
+}
+function throttle(fn, delay) {
+	let lastRun = 0;
+	let lastPromise = null;
+	return (...args) => {
+		const now = Date.now();
+		if (lastRun && now - lastRun < delay) return lastPromise ?? Promise.resolve(void 0);
+		lastRun = now;
+		lastPromise = fn(...args);
+		return lastPromise;
+	};
+}
+function runResource(source, fetcher, options = {}, effectFn) {
+	const { lazy = false, once = false, initialValue, debounce: debounceTime, throttle: throttleTime } = options;
+	let current = initialValue;
+	let loading = false;
+	let error = void 0;
+	let cleanupFns = [];
+	const runCleanup = () => {
+		cleanupFns.forEach((fn) => fn());
+		cleanupFns = [];
+	};
+	const onCleanup = (fn) => {
+		cleanupFns = [...cleanupFns, fn];
+	};
+	const baseFetcher = async (value, previousValue, refetching = false) => {
+		try {
+			loading = true;
+			error = void 0;
+			runCleanup();
+			const controller = new AbortController();
+			onCleanup(() => controller.abort());
+			const result = await fetcher(value, previousValue, {
+				data: current,
+				refetching,
+				onCleanup,
+				signal: controller.signal
+			});
+			current = result;
+			return result;
+		} catch (e) {
+			if (!(e instanceof DOMException && e.name === "AbortError")) error = e;
+			return;
+		} finally {
+			loading = false;
+		}
+	};
+	const runFetcher = debounceTime ? debounce(baseFetcher, debounceTime) : throttleTime ? throttle(baseFetcher, throttleTime) : baseFetcher;
+	const sources = Array.isArray(source) ? source : [source];
+	let prevValues;
+	effectFn((values, previousValues) => {
+		if (once && prevValues) return;
+		prevValues = values;
+		runFetcher(Array.isArray(source) ? values : values[0], Array.isArray(source) ? previousValues : previousValues?.[0]);
+	}, { lazy });
+	return {
+		get current() {
+			return current;
+		},
+		get loading() {
+			return loading;
+		},
+		get error() {
+			return error;
+		},
+		mutate: (value) => {
+			current = value;
+		},
+		refetch: (info) => {
+			const values = sources.map((s) => s());
+			return runFetcher(Array.isArray(source) ? values : values[0], Array.isArray(source) ? values : values[0], info ?? true);
+		}
+	};
+}
+function resource(source, fetcher, options) {
+	return runResource(source, fetcher, options, (fn, options) => {
+		const sources = Array.isArray(source) ? source : [source];
+		const getters = () => sources.map((s) => s());
+		watch(getters, (values, previousValues) => {
+			fn(values, previousValues ?? []);
+		}, options);
+	});
+}
+function resourcePre(source, fetcher, options) {
+	return runResource(source, fetcher, options, (fn, options) => {
+		const sources = Array.isArray(source) ? source : [source];
+		const getter = () => sources.map((s) => s());
+		watch.pre(getter, (values, previousValues) => {
+			fn(values, previousValues ?? []);
+		}, options);
+	});
+}
+resource.pre = resourcePre;
+new Context("richColorsContext");
+var sonnerContext = new Context("<Toaster/>");
+var toastsCounter = 0;
+var ToastState = class {
+	toasts = [];
+	heights = [];
+	#findToastIdx = (id) => {
+		const idx = this.toasts.findIndex((toast) => toast.id === id);
+		if (idx === -1) return null;
+		return idx;
+	};
+	addToast = (data) => {
+		if (!isBrowser) return;
+		this.toasts.unshift(data);
+	};
+	updateToast = ({ id, data, type, message }) => {
+		const toastIdx = this.toasts.findIndex((toast) => toast.id === id);
+		const toastToUpdate = this.toasts[toastIdx];
+		this.toasts[toastIdx] = {
+			...toastToUpdate,
+			...data,
+			id,
+			title: message,
+			type,
+			updated: true
+		};
+	};
+	create = (data) => {
+		const { message, ...rest } = data;
+		const id = typeof data?.id === "number" || data.id && data.id?.length > 0 ? data.id : toastsCounter++;
+		const dismissible = data.dismissible !== void 0 ? data.dismissible : data.dismissable !== void 0 ? data.dismissable : true;
+		const type = data.type === void 0 ? "default" : data.type;
+		run(() => {
+			if (this.toasts.find((toast) => toast.id === id)) this.updateToast({
+				id,
+				data,
+				type,
+				message,
+				dismissible
+			});
+			else this.addToast({
+				...rest,
+				id,
+				title: message,
+				dismissible,
+				type
+			});
+		});
+		return id;
+	};
+	dismiss = (id) => {
+		run(() => {
+			if (id === void 0) {
+				this.toasts = this.toasts.map((toast) => ({
+					...toast,
+					dismiss: true
+				}));
+				return;
+			}
+			const toastIdx = this.toasts.findIndex((toast) => toast.id === id);
+			if (this.toasts[toastIdx]) this.toasts[toastIdx] = {
+				...this.toasts[toastIdx],
+				dismiss: true
+			};
+		});
+		return id;
+	};
+	remove = (id) => {
+		if (id === void 0) {
+			this.toasts = [];
+			return;
+		}
+		const toastIdx = this.#findToastIdx(id);
+		if (toastIdx === null) return;
+		this.toasts.splice(toastIdx, 1);
+		return id;
+	};
+	message = (message, data) => {
+		return this.create({
+			...data,
+			type: "default",
+			message
+		});
+	};
+	error = (message, data) => {
+		return this.create({
+			...data,
+			type: "error",
+			message
+		});
+	};
+	success = (message, data) => {
+		return this.create({
+			...data,
+			type: "success",
+			message
+		});
+	};
+	info = (message, data) => {
+		return this.create({
+			...data,
+			type: "info",
+			message
+		});
+	};
+	warning = (message, data) => {
+		return this.create({
+			...data,
+			type: "warning",
+			message
+		});
+	};
+	loading = (message, data) => {
+		return this.create({
+			...data,
+			type: "loading",
+			message
+		});
+	};
+	promise = (promise, data) => {
+		if (!data) return;
+		let id = void 0;
+		if (data.loading !== void 0) id = this.create({
+			...data,
+			promise,
+			type: "loading",
+			message: typeof data.loading === "string" ? data.loading : data.loading()
+		});
+		const p = promise instanceof Promise ? promise : promise();
+		let shouldDismiss = id !== void 0;
+		p.then((response) => {
+			if (typeof response === "object" && response && "ok" in response && typeof response.ok === "boolean" && !response.ok) {
+				shouldDismiss = false;
+				const message = constructPromiseErrorMessage(response);
+				this.create({
+					id,
+					type: "error",
+					message
+				});
+			} else if (data.success !== void 0) {
+				shouldDismiss = false;
+				const message = typeof data.success === "function" ? data.success(response) : data.success;
+				this.create({
+					id,
+					type: "success",
+					message
+				});
+			}
+		}).catch((error) => {
+			if (data.error !== void 0) {
+				shouldDismiss = false;
+				const message = typeof data.error === "function" ? data.error(error) : data.error;
+				this.create({
+					id,
+					type: "error",
+					message
+				});
+			}
+		}).finally(() => {
+			if (shouldDismiss) {
+				this.dismiss(id);
+				id = void 0;
+			}
+			data.finally?.();
+		});
+		return id;
+	};
+	custom = (component, data) => {
+		const id = data?.id || toastsCounter++;
+		this.create({
+			component,
+			id,
+			...data
+		});
+		return id;
+	};
+	removeHeight = (id) => {
+		this.heights = this.heights.filter((height) => height.toastId !== id);
+	};
+	setHeight = (data) => {
+		const toastIdx = this.#findToastIdx(data.toastId);
+		if (toastIdx === null) {
+			this.heights.push(data);
+			return;
+		}
+		this.heights[toastIdx] = data;
+	};
+	reset = () => {
+		this.toasts = [];
+		this.heights = [];
+	};
+};
+function constructPromiseErrorMessage(response) {
+	if (response && typeof response === "object" && "status" in response) return `HTTP error! Status: ${response.status}`;
+	return `Error! ${response}`;
+}
+var toastState = new ToastState();
+function toastFunction(message, data) {
+	return toastState.create({
+		message,
+		...data
+	});
+}
+var SonnerState = class {
+	/**
+	* A derived state of the toasts that are not dismissed.
+	*/
+	#activeToasts = derived(() => toastState.toasts.filter((toast) => !toast.dismiss));
+	get toasts() {
+		return this.#activeToasts();
+	}
+};
+var toast = Object.assign(toastFunction, {
+	success: toastState.success,
+	info: toastState.info,
+	warning: toastState.warning,
+	error: toastState.error,
+	custom: toastState.custom,
+	message: toastState.message,
+	promise: toastState.promise,
+	dismiss: toastState.dismiss,
+	loading: toastState.loading,
+	getActiveToasts: () => {
+		return toastState.toasts.filter((toast) => !toast.dismiss);
+	}
+});
+/**
+* @file
+* @license @lucide/svelte v1.17.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+var defaultAttributes = {
+	xmlns: "http://www.w3.org/2000/svg",
+	width: 24,
+	height: 24,
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	"stroke-width": 2,
+	"stroke-linecap": "round",
+	"stroke-linejoin": "round"
+};
+/**
+* @file
+* @license @lucide/svelte v1.17.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+/**
+* Check if a component has an accessibility prop
+*
+* @param {object} props
+* @returns {boolean} Whether the component has an accessibility prop
+*/
+var hasA11yProp = (props) => {
+	for (const prop in props) if (prop.startsWith("aria-") || prop === "role" || prop === "title") return true;
+	return false;
+};
+/**
+* @file
+* @license @lucide/svelte v1.17.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+var LucideContext = Symbol("lucide-context");
+var getLucideContext = () => getContext(LucideContext);
+function Icon($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const globalProps = getLucideContext() ?? {};
+		const { name, color = globalProps.color ?? "currentColor", size = globalProps.size ?? 24, strokeWidth = globalProps.strokeWidth ?? 2, absoluteStrokeWidth = globalProps.absoluteStrokeWidth ?? false, iconNode = [], children, $$slots, $$events, ...props } = $$props;
+		const calculatedStrokeWidth = derived(() => absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth);
+		$$renderer.push(`<svg${attributes({
+			...defaultAttributes,
+			...!children && !hasA11yProp(props) && { "aria-hidden": "true" },
+			...props,
+			width: size,
+			height: size,
+			stroke: color,
+			"stroke-width": calculatedStrokeWidth(),
+			class: clsx$1([
+				"lucide-icon lucide",
+				globalProps.class,
+				name && `lucide-${name}`,
+				props.class
+			])
+		}, void 0, void 0, void 0, 3)}><!--[-->`);
+		const each_array = ensure_array_like(iconNode);
+		for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+			let [tag, attrs] = each_array[$$index];
+			element($$renderer, tag, () => {
+				$$renderer.push(`${attributes({ ...attrs }, void 0, void 0, void 0, 3)}`);
+			});
+		}
+		$$renderer.push(`<!--]-->`);
+		children?.($$renderer);
+		$$renderer.push(`<!----></svg>`);
+	});
+}
+function Loader_circle($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Icon($$renderer, spread_props([
+		{ name: "loader-circle" },
+		props,
+		{ iconNode: [["path", { "d": "M21 12a9 9 0 1 1-6.219-8.56" }]] }
+	]));
+}
+//#endregion
+export { resolveQueryBoolean as A, matchQuery as C, partialMatchKey as D, onlineManager as E, sonnerContext as F, timeUntilStale as I, timeoutManager as L, setQueryClientContext as M, shallowEqualObjects as N, pendingThenable as O, skipToken as P, toast as R, matchMutation as S, notifyManager as T, getIsRestoringContext as _, Removable as a, hashQueryKeyByOptions as b, SvelteMap as c, createRetryer as d, createSubscriber as f, functionalUpdate as g, focusManager as h, Query as i, resolveStaleTime as j, replaceData as k, SvelteSet as l, fetchState as m, Loader_circle as n, SonnerState as o, environmentManager as p, MediaQuery as r, Subscribable as s, Icon as t, cn as u, getQueryClientContext as v, noop as w, isValidTimeout as x, hashKey as y, toastState as z };
+
+//# sourceMappingURL=loader-circle-zqx69BdD.js.map