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

package/dist/server/chunks/_layout.svelte-CP4jFwsK.js

@@ -0,0 +1,1944 @@
+import { $ as onDestroy, D as ensure_array_like, dt as spread_props, f as attr, h as attributes, k as escape_html, m as attr_style, ot as run, p as attr_class, pt as stringify, r as on, w as derived, y as clsx$1 } from "./events-DeYJGjCt.js";
+import { C as matchQuery, D as partialMatchKey, E as onlineManager, F as sonnerContext, M as setQueryClientContext, P as skipToken, S as matchMutation, T as notifyManager, a as Removable, b as hashQueryKeyByOptions, d as createRetryer, f as createSubscriber, g as functionalUpdate, h as focusManager, i as Query, j as resolveStaleTime, n as Loader_circle, o as SonnerState, r as MediaQuery, s as Subscribable, t as Icon, u as cn, w as noop, y as hashKey, z as toastState } from "./loader-circle-zqx69BdD.js";
+//#region .svelte-kit/adapter-bun/entries/pages/_layout.svelte.js
+var Mutation = class extends Removable {
+	#client;
+	#observers;
+	#mutationCache;
+	#retryer;
+	constructor(config) {
+		super();
+		this.#client = config.client;
+		this.mutationId = config.mutationId;
+		this.#mutationCache = config.mutationCache;
+		this.#observers = [];
+		this.state = config.state || getDefaultState();
+		this.setOptions(config.options);
+		this.scheduleGc();
+	}
+	setOptions(options) {
+		this.options = options;
+		this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(observer) {
+		if (!this.#observers.includes(observer)) {
+			this.#observers.push(observer);
+			this.clearGcTimeout();
+			this.#mutationCache.notify({
+				type: "observerAdded",
+				mutation: this,
+				observer
+			});
+		}
+	}
+	removeObserver(observer) {
+		this.#observers = this.#observers.filter((x) => x !== observer);
+		this.scheduleGc();
+		this.#mutationCache.notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer
+		});
+	}
+	optionalRemove() {
+		if (!this.#observers.length) if (this.state.status === "pending") this.scheduleGc();
+		else this.#mutationCache.remove(this);
+	}
+	continue() {
+		return this.#retryer?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(variables) {
+		const onContinue = () => {
+			this.#dispatch({ type: "continue" });
+		};
+		const mutationFnContext = {
+			client: this.#client,
+			meta: this.options.meta,
+			mutationKey: this.options.mutationKey
+		};
+		this.#retryer = createRetryer({
+			fn: () => {
+				if (!this.options.mutationFn) return Promise.reject(/* @__PURE__ */ new Error("No mutationFn found"));
+				return this.options.mutationFn(variables, mutationFnContext);
+			},
+			onFail: (failureCount, error) => {
+				this.#dispatch({
+					type: "failed",
+					failureCount,
+					error
+				});
+			},
+			onPause: () => {
+				this.#dispatch({ type: "pause" });
+			},
+			onContinue,
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => this.#mutationCache.canRun(this)
+		});
+		const restored = this.state.status === "pending";
+		const isPaused = !this.#retryer.canStart();
+		try {
+			if (restored) onContinue();
+			else {
+				this.#dispatch({
+					type: "pending",
+					variables,
+					isPaused
+				});
+				if (this.#mutationCache.config.onMutate) await this.#mutationCache.config.onMutate(variables, this, mutationFnContext);
+				const context = await this.options.onMutate?.(variables, mutationFnContext);
+				if (context !== this.state.context) this.#dispatch({
+					type: "pending",
+					context,
+					variables,
+					isPaused
+				});
+			}
+			const data = await this.#retryer.start();
+			await this.#mutationCache.config.onSuccess?.(data, variables, this.state.context, this, mutationFnContext);
+			await this.options.onSuccess?.(data, variables, this.state.context, mutationFnContext);
+			await this.#mutationCache.config.onSettled?.(data, null, this.state.variables, this.state.context, this, mutationFnContext);
+			await this.options.onSettled?.(data, null, variables, this.state.context, mutationFnContext);
+			this.#dispatch({
+				type: "success",
+				data
+			});
+			return data;
+		} catch (error) {
+			try {
+				await this.#mutationCache.config.onError?.(error, variables, this.state.context, this, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.options.onError?.(error, variables, this.state.context, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.#mutationCache.config.onSettled?.(void 0, error, this.state.variables, this.state.context, this, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.options.onSettled?.(void 0, error, variables, this.state.context, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			this.#dispatch({
+				type: "error",
+				error
+			});
+			throw error;
+		} finally {
+			this.#mutationCache.runNext(this);
+		}
+	}
+	#dispatch(action) {
+		const reducer = (state) => {
+			switch (action.type) {
+				case "failed": return {
+					...state,
+					failureCount: action.failureCount,
+					failureReason: action.error
+				};
+				case "pause": return {
+					...state,
+					isPaused: true
+				};
+				case "continue": return {
+					...state,
+					isPaused: false
+				};
+				case "pending": return {
+					...state,
+					context: action.context,
+					data: void 0,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					isPaused: action.isPaused,
+					status: "pending",
+					variables: action.variables,
+					submittedAt: Date.now()
+				};
+				case "success": return {
+					...state,
+					data: action.data,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					status: "success",
+					isPaused: false
+				};
+				case "error": return {
+					...state,
+					data: void 0,
+					error: action.error,
+					failureCount: state.failureCount + 1,
+					failureReason: action.error,
+					isPaused: false,
+					status: "error"
+				};
+			}
+		};
+		this.state = reducer(this.state);
+		notifyManager.batch(() => {
+			this.#observers.forEach((observer) => {
+				observer.onMutationUpdate(action);
+			});
+			this.#mutationCache.notify({
+				mutation: this,
+				type: "updated",
+				action
+			});
+		});
+	}
+};
+function getDefaultState() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: false,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+var MutationCache = class extends Subscribable {
+	constructor(config = {}) {
+		super();
+		this.config = config;
+		this.#mutations = /* @__PURE__ */ new Set();
+		this.#scopes = /* @__PURE__ */ new Map();
+		this.#mutationId = 0;
+	}
+	#mutations;
+	#scopes;
+	#mutationId;
+	build(client, options, state) {
+		const mutation = new Mutation({
+			client,
+			mutationCache: this,
+			mutationId: ++this.#mutationId,
+			options: client.defaultMutationOptions(options),
+			state
+		});
+		this.add(mutation);
+		return mutation;
+	}
+	add(mutation) {
+		this.#mutations.add(mutation);
+		const scope = scopeFor(mutation);
+		if (typeof scope === "string") {
+			const scopedMutations = this.#scopes.get(scope);
+			if (scopedMutations) scopedMutations.push(mutation);
+			else this.#scopes.set(scope, [mutation]);
+		}
+		this.notify({
+			type: "added",
+			mutation
+		});
+	}
+	remove(mutation) {
+		if (this.#mutations.delete(mutation)) {
+			const scope = scopeFor(mutation);
+			if (typeof scope === "string") {
+				const scopedMutations = this.#scopes.get(scope);
+				if (scopedMutations) {
+					if (scopedMutations.length > 1) {
+						const index = scopedMutations.indexOf(mutation);
+						if (index !== -1) scopedMutations.splice(index, 1);
+					} else if (scopedMutations[0] === mutation) this.#scopes.delete(scope);
+				}
+			}
+		}
+		this.notify({
+			type: "removed",
+			mutation
+		});
+	}
+	canRun(mutation) {
+		const scope = scopeFor(mutation);
+		if (typeof scope === "string") {
+			const firstPendingMutation = this.#scopes.get(scope)?.find((m) => m.state.status === "pending");
+			return !firstPendingMutation || firstPendingMutation === mutation;
+		} else return true;
+	}
+	runNext(mutation) {
+		const scope = scopeFor(mutation);
+		if (typeof scope === "string") return (this.#scopes.get(scope)?.find((m) => m !== mutation && m.state.isPaused))?.continue() ?? Promise.resolve();
+		else return Promise.resolve();
+	}
+	clear() {
+		notifyManager.batch(() => {
+			this.#mutations.forEach((mutation) => {
+				this.notify({
+					type: "removed",
+					mutation
+				});
+			});
+			this.#mutations.clear();
+			this.#scopes.clear();
+		});
+	}
+	getAll() {
+		return Array.from(this.#mutations);
+	}
+	find(filters) {
+		const defaultedFilters = {
+			exact: true,
+			...filters
+		};
+		return this.getAll().find((mutation) => matchMutation(defaultedFilters, mutation));
+	}
+	findAll(filters = {}) {
+		return this.getAll().filter((mutation) => matchMutation(filters, mutation));
+	}
+	notify(event) {
+		notifyManager.batch(() => {
+			this.listeners.forEach((listener) => {
+				listener(event);
+			});
+		});
+	}
+	resumePausedMutations() {
+		const pausedMutations = this.getAll().filter((x) => x.state.isPaused);
+		return notifyManager.batch(() => Promise.all(pausedMutations.map((mutation) => mutation.continue().catch(noop))));
+	}
+};
+function scopeFor(mutation) {
+	return mutation.options.scope?.id;
+}
+var QueryCache = class extends Subscribable {
+	constructor(config = {}) {
+		super();
+		this.config = config;
+		this.#queries = /* @__PURE__ */ new Map();
+	}
+	#queries;
+	build(client, options, state) {
+		const queryKey = options.queryKey;
+		const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
+		let query = this.get(queryHash);
+		if (!query) {
+			query = new Query({
+				client,
+				queryKey,
+				queryHash,
+				options: client.defaultQueryOptions(options),
+				state,
+				defaultOptions: client.getQueryDefaults(queryKey)
+			});
+			this.add(query);
+		}
+		return query;
+	}
+	add(query) {
+		if (!this.#queries.has(query.queryHash)) {
+			this.#queries.set(query.queryHash, query);
+			this.notify({
+				type: "added",
+				query
+			});
+		}
+	}
+	remove(query) {
+		const queryInMap = this.#queries.get(query.queryHash);
+		if (queryInMap) {
+			query.destroy();
+			if (queryInMap === query) this.#queries.delete(query.queryHash);
+			this.notify({
+				type: "removed",
+				query
+			});
+		}
+	}
+	clear() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((query) => {
+				this.remove(query);
+			});
+		});
+	}
+	get(queryHash) {
+		return this.#queries.get(queryHash);
+	}
+	getAll() {
+		return [...this.#queries.values()];
+	}
+	find(filters) {
+		const defaultedFilters = {
+			exact: true,
+			...filters
+		};
+		return this.getAll().find((query) => matchQuery(defaultedFilters, query));
+	}
+	findAll(filters = {}) {
+		const queries = this.getAll();
+		return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
+	}
+	notify(event) {
+		notifyManager.batch(() => {
+			this.listeners.forEach((listener) => {
+				listener(event);
+			});
+		});
+	}
+	onFocus() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((query) => {
+				query.onFocus();
+			});
+		});
+	}
+	onOnline() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((query) => {
+				query.onOnline();
+			});
+		});
+	}
+};
+var QueryClient = class {
+	#queryCache;
+	#mutationCache;
+	#defaultOptions;
+	#queryDefaults;
+	#mutationDefaults;
+	#mountCount;
+	#unsubscribeFocus;
+	#unsubscribeOnline;
+	constructor(config = {}) {
+		this.#queryCache = config.queryCache || new QueryCache();
+		this.#mutationCache = config.mutationCache || new MutationCache();
+		this.#defaultOptions = config.defaultOptions || {};
+		this.#queryDefaults = /* @__PURE__ */ new Map();
+		this.#mutationDefaults = /* @__PURE__ */ new Map();
+		this.#mountCount = 0;
+	}
+	mount() {
+		this.#mountCount++;
+		if (this.#mountCount !== 1) return;
+		this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {
+			if (focused) {
+				await this.resumePausedMutations();
+				this.#queryCache.onFocus();
+			}
+		});
+		this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {
+			if (online) {
+				await this.resumePausedMutations();
+				this.#queryCache.onOnline();
+			}
+		});
+	}
+	unmount() {
+		this.#mountCount--;
+		if (this.#mountCount !== 0) return;
+		this.#unsubscribeFocus?.();
+		this.#unsubscribeFocus = void 0;
+		this.#unsubscribeOnline?.();
+		this.#unsubscribeOnline = void 0;
+	}
+	isFetching(filters) {
+		return this.#queryCache.findAll({
+			...filters,
+			fetchStatus: "fetching"
+		}).length;
+	}
+	isMutating(filters) {
+		return this.#mutationCache.findAll({
+			...filters,
+			status: "pending"
+		}).length;
+	}
+	/**
+	* Imperative (non-reactive) way to retrieve data for a QueryKey.
+	* Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+	*
+	* Hint: Do not use this function inside a component, because it won't receive updates.
+	* Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+	*/
+	getQueryData(queryKey) {
+		const options = this.defaultQueryOptions({ queryKey });
+		return this.#queryCache.get(options.queryHash)?.state.data;
+	}
+	ensureQueryData(options) {
+		const defaultedOptions = this.defaultQueryOptions(options);
+		const query = this.#queryCache.build(this, defaultedOptions);
+		const cachedData = query.state.data;
+		if (cachedData === void 0) return this.fetchQuery(options);
+		if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) this.prefetchQuery(defaultedOptions);
+		return Promise.resolve(cachedData);
+	}
+	getQueriesData(filters) {
+		return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {
+			return [queryKey, state.data];
+		});
+	}
+	setQueryData(queryKey, updater, options) {
+		const defaultedOptions = this.defaultQueryOptions({ queryKey });
+		const prevData = this.#queryCache.get(defaultedOptions.queryHash)?.state.data;
+		const data = functionalUpdate(updater, prevData);
+		if (data === void 0) return;
+		return this.#queryCache.build(this, defaultedOptions).setData(data, {
+			...options,
+			manual: true
+		});
+	}
+	setQueriesData(filters, updater, options) {
+		return notifyManager.batch(() => this.#queryCache.findAll(filters).map(({ queryKey }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
+	}
+	getQueryState(queryKey) {
+		const options = this.defaultQueryOptions({ queryKey });
+		return this.#queryCache.get(options.queryHash)?.state;
+	}
+	removeQueries(filters) {
+		const queryCache = this.#queryCache;
+		notifyManager.batch(() => {
+			queryCache.findAll(filters).forEach((query) => {
+				queryCache.remove(query);
+			});
+		});
+	}
+	resetQueries(filters, options) {
+		const queryCache = this.#queryCache;
+		return notifyManager.batch(() => {
+			queryCache.findAll(filters).forEach((query) => {
+				query.reset();
+			});
+			return this.refetchQueries({
+				type: "active",
+				...filters
+			}, options);
+		});
+	}
+	cancelQueries(filters, cancelOptions = {}) {
+		const defaultedCancelOptions = {
+			revert: true,
+			...cancelOptions
+		};
+		const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)));
+		return Promise.all(promises).then(noop).catch(noop);
+	}
+	invalidateQueries(filters, options = {}) {
+		return notifyManager.batch(() => {
+			this.#queryCache.findAll(filters).forEach((query) => {
+				query.invalidate();
+			});
+			if (filters?.refetchType === "none") return Promise.resolve();
+			return this.refetchQueries({
+				...filters,
+				type: filters?.refetchType ?? filters?.type ?? "active"
+			}, options);
+		});
+	}
+	refetchQueries(filters, options = {}) {
+		const fetchOptions = {
+			...options,
+			cancelRefetch: options.cancelRefetch ?? true
+		};
+		const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => {
+			let promise = query.fetch(void 0, fetchOptions);
+			if (!fetchOptions.throwOnError) promise = promise.catch(noop);
+			return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
+		}));
+		return Promise.all(promises).then(noop);
+	}
+	fetchQuery(options) {
+		const defaultedOptions = this.defaultQueryOptions(options);
+		if (defaultedOptions.retry === void 0) defaultedOptions.retry = false;
+		const query = this.#queryCache.build(this, defaultedOptions);
+		return query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query)) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+	}
+	prefetchQuery(options) {
+		return this.fetchQuery(options).then(noop).catch(noop);
+	}
+	fetchInfiniteQuery(options) {
+		options._type = "infinite";
+		return this.fetchQuery(options);
+	}
+	prefetchInfiniteQuery(options) {
+		return this.fetchInfiniteQuery(options).then(noop).catch(noop);
+	}
+	ensureInfiniteQueryData(options) {
+		options._type = "infinite";
+		return this.ensureQueryData(options);
+	}
+	resumePausedMutations() {
+		if (onlineManager.isOnline()) return this.#mutationCache.resumePausedMutations();
+		return Promise.resolve();
+	}
+	getQueryCache() {
+		return this.#queryCache;
+	}
+	getMutationCache() {
+		return this.#mutationCache;
+	}
+	getDefaultOptions() {
+		return this.#defaultOptions;
+	}
+	setDefaultOptions(options) {
+		this.#defaultOptions = options;
+	}
+	setQueryDefaults(queryKey, options) {
+		this.#queryDefaults.set(hashKey(queryKey), {
+			queryKey,
+			defaultOptions: options
+		});
+	}
+	getQueryDefaults(queryKey) {
+		const defaults = [...this.#queryDefaults.values()];
+		const result = {};
+		defaults.forEach((queryDefault) => {
+			if (partialMatchKey(queryKey, queryDefault.queryKey)) Object.assign(result, queryDefault.defaultOptions);
+		});
+		return result;
+	}
+	setMutationDefaults(mutationKey, options) {
+		this.#mutationDefaults.set(hashKey(mutationKey), {
+			mutationKey,
+			defaultOptions: options
+		});
+	}
+	getMutationDefaults(mutationKey) {
+		const defaults = [...this.#mutationDefaults.values()];
+		const result = {};
+		defaults.forEach((queryDefault) => {
+			if (partialMatchKey(mutationKey, queryDefault.mutationKey)) Object.assign(result, queryDefault.defaultOptions);
+		});
+		return result;
+	}
+	defaultQueryOptions(options) {
+		if (options._defaulted) return options;
+		const defaultedOptions = {
+			...this.#defaultOptions.queries,
+			...this.getQueryDefaults(options.queryKey),
+			...options,
+			_defaulted: true
+		};
+		if (!defaultedOptions.queryHash) defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
+		if (defaultedOptions.refetchOnReconnect === void 0) defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
+		if (defaultedOptions.throwOnError === void 0) defaultedOptions.throwOnError = !!defaultedOptions.suspense;
+		if (!defaultedOptions.networkMode && defaultedOptions.persister) defaultedOptions.networkMode = "offlineFirst";
+		if (defaultedOptions.queryFn === skipToken) defaultedOptions.enabled = false;
+		return defaultedOptions;
+	}
+	defaultMutationOptions(options) {
+		if (options?._defaulted) return options;
+		return {
+			...this.#defaultOptions.mutations,
+			...options?.mutationKey && this.getMutationDefaults(options.mutationKey),
+			...options,
+			_defaulted: true
+		};
+	}
+	clear() {
+		this.#queryCache.clear();
+		this.#mutationCache.clear();
+	}
+};
+function QueryClientProvider($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const { client = new QueryClient(), children } = $$props;
+		setQueryClientContext(client);
+		onDestroy(() => {
+			client.unmount();
+		});
+		children($$renderer);
+		$$renderer.push(`<!---->`);
+	});
+}
+var bars = Array(12).fill(0);
+function Loader($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		"use strict";
+		let { visible, class: className } = $$props;
+		$$renderer.push(`<div${attr_class(clsx$1(["sonner-loading-wrapper", className].filter(Boolean).join(" ")))}${attr("data-visible", visible)}><div class="sonner-spinner"><!--[-->`);
+		const each_array = ensure_array_like(bars);
+		for (let i = 0, $$length = each_array.length; i < $$length; i++) {
+			each_array[i];
+			$$renderer.push(`<div class="sonner-loading-bar"></div>`);
+		}
+		$$renderer.push(`<!--]--></div></div>`);
+	});
+}
+function isAction(action) {
+	return action.label !== void 0;
+}
+function useDocumentHidden() {
+	let current = typeof document !== "undefined" ? document.hidden : false;
+	return { get current() {
+		return current;
+	} };
+}
+var TOAST_LIFETIME$1 = 4e3;
+var GAP$1 = 14;
+var TIME_BEFORE_UNMOUNT = 200;
+var DEFAULT_TOAST_CLASSES = {
+	toast: "",
+	title: "",
+	description: "",
+	loader: "",
+	closeButton: "",
+	cancelButton: "",
+	actionButton: "",
+	action: "",
+	warning: "",
+	error: "",
+	success: "",
+	default: "",
+	info: "",
+	loading: ""
+};
+function Toast($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { toast, index, expanded, invert: invertFromToaster, position, visibleToasts, expandByDefault, closeButton: closeButtonFromToaster, interacting, cancelButtonStyle = "", actionButtonStyle = "", duration: durationFromToaster, descriptionClass = "", classes: classesProp, unstyled = false, loadingIcon, successIcon, errorIcon, warningIcon, closeIcon, infoIcon, defaultRichColors = false, swipeDirections: swipeDirectionsProp, closeButtonAriaLabel, pauseWhenPageIsHidden, $$slots, $$events, ...restProps } = $$props;
+		const defaultClasses = { ...DEFAULT_TOAST_CLASSES };
+		let mounted = false;
+		let removed = false;
+		let swiping = false;
+		let swipeOut = false;
+		let isSwiped = false;
+		let offsetBeforeRemove = 0;
+		let initialHeight = 0;
+		toast.duration;
+		let swipeOutDirection = null;
+		const isFront = derived(() => index === 0);
+		const isVisible = derived(() => index + 1 <= visibleToasts);
+		const toastType = derived(() => toast.type);
+		const dismissible = derived(() => toast.dismissible !== void 0 ? toast.dismissible !== false : toast.dismissable !== false);
+		const toastClass = derived(() => toast.class || "");
+		const toastDescriptionClass = derived(() => toast.descriptionClass || "");
+		const heightIndex = derived(() => toastState.heights.findIndex((height) => height.toastId === toast.id) || 0);
+		const closeButton = derived(() => toast.closeButton ?? closeButtonFromToaster);
+		derived(() => toast.duration ?? durationFromToaster ?? TOAST_LIFETIME$1);
+		const coords = derived(() => position.split("-"));
+		const toastsHeightBefore = derived(() => toastState.heights.reduce((prev, curr, reducerIndex) => {
+			if (reducerIndex >= heightIndex()) return prev;
+			return prev + curr.height;
+		}, 0));
+		useDocumentHidden();
+		const invert = derived(() => toast.invert || invertFromToaster);
+		const disabled = derived(() => toastType() === "loading");
+		const classes = derived(() => ({
+			...defaultClasses,
+			...classesProp
+		}));
+		derived(() => toast.title);
+		derived(() => toast.description);
+		const offset = derived(() => Math.round(heightIndex() * GAP$1 + toastsHeightBefore()));
+		function deleteToast() {
+			removed = true;
+			offsetBeforeRemove = offset();
+			toastState.removeHeight(toast.id);
+			setTimeout(() => {
+				toastState.remove(toast.id);
+			}, TIME_BEFORE_UNMOUNT);
+		}
+		derived(() => toast.promise && toastType() === "loading" || toast.duration === Number.POSITIVE_INFINITY);
+		const icon = derived(() => {
+			if (toast.icon) return toast.icon;
+			if (toastType() === "success") return successIcon;
+			if (toastType() === "error") return errorIcon;
+			if (toastType() === "warning") return warningIcon;
+			if (toastType() === "info") return infoIcon;
+			if (toastType() === "loading") return loadingIcon;
+			return null;
+		});
+		function LoadingIcon($$renderer) {
+			if (loadingIcon) {
+				$$renderer.push("<!--[0-->");
+				$$renderer.push(`<div${attr_class(clsx$1(cn(classes()?.loader, toast?.classes?.loader, "sonner-loader")))}${attr("data-visible", toastType() === "loading")}>`);
+				loadingIcon($$renderer);
+				$$renderer.push(`<!----></div>`);
+			} else {
+				$$renderer.push("<!--[-1-->");
+				Loader($$renderer, {
+					class: cn(classes()?.loader, toast.classes?.loader),
+					visible: toastType() === "loading"
+				});
+			}
+			$$renderer.push(`<!--]-->`);
+		}
+		$$renderer.push(`<li${attr("tabindex", 0)}${attr_class(clsx$1(cn(restProps.class, toastClass(), classes()?.toast, toast?.classes?.toast, classes()?.[toastType()], toast?.classes?.[toastType()])))}${attr("aria-live", toast.important ? "assertive" : "polite")} aria-atomic="true" data-sonner-toast=""${attr("data-rich-colors", toast.richColors ?? defaultRichColors)}${attr("data-styled", !(toast.component || toast.unstyled || unstyled))}${attr("data-mounted", mounted)}${attr("data-promise", Boolean(toast.promise))}${attr("data-swiped", isSwiped)}${attr("data-removed", removed)}${attr("data-visible", isVisible())}${attr("data-y-position", coords()[0])}${attr("data-x-position", coords()[1])}${attr("data-index", index)}${attr("data-front", isFront())}${attr("data-swiping", swiping)}${attr("data-dismissible", dismissible())}${attr("data-type", toastType())}${attr("data-invert", invert())}${attr("data-swipe-out", swipeOut)}${attr("data-swipe-direction", swipeOutDirection)}${attr("data-expanded", Boolean(expanded || expandByDefault && mounted))}${attr_style(`${restProps.style} ${toast.style}`, {
+			"--index": index,
+			"--toasts-before": index,
+			"--z-index": toastState.toasts.length - index,
+			"--offset": `${removed ? offsetBeforeRemove : offset()}px`,
+			"--initial-height": expandByDefault ? "auto" : `${initialHeight}px`
+		})}>`);
+		if (closeButton() && !toast.component && toastType() !== "loading" && closeIcon !== null) {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<button${attr("aria-label", closeButtonAriaLabel)}${attr("data-disabled", disabled())} data-close-button=""${attr_class(clsx$1(cn(classes()?.closeButton, toast?.classes?.closeButton)))}>`);
+			closeIcon?.($$renderer);
+			$$renderer.push(`<!----></button>`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]--> `);
+		if (toast.component) {
+			$$renderer.push("<!--[0-->");
+			const Component = toast.component;
+			if (Component) {
+				$$renderer.push("<!--[-->");
+				Component($$renderer, spread_props([toast.componentProps, { closeToast: deleteToast }]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		} else {
+			$$renderer.push("<!--[-1-->");
+			if (toastType() || toast.icon || toast.promise && toast.icon !== null && icon() !== null || toast.icon) {
+				$$renderer.push("<!--[0-->");
+				$$renderer.push(`<div data-icon=""${attr_class(clsx$1(cn(classes()?.icon, toast?.classes?.icon)))}>`);
+				if (toast.promise || toastType() === "loading") {
+					$$renderer.push("<!--[0-->");
+					if (toast.icon) {
+						$$renderer.push("<!--[0-->");
+						if (toast.icon) {
+							$$renderer.push("<!--[-->");
+							toast.icon($$renderer, {});
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+					} else {
+						$$renderer.push("<!--[-1-->");
+						LoadingIcon($$renderer);
+					}
+					$$renderer.push(`<!--]-->`);
+				} else $$renderer.push("<!--[-1-->");
+				$$renderer.push(`<!--]--> `);
+				if (toast.type !== "loading") {
+					$$renderer.push("<!--[0-->");
+					if (toast.icon) {
+						$$renderer.push("<!--[0-->");
+						if (toast.icon) {
+							$$renderer.push("<!--[-->");
+							toast.icon($$renderer, {});
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+					} else if (toastType() === "success") {
+						$$renderer.push("<!--[1-->");
+						successIcon?.($$renderer);
+						$$renderer.push(`<!---->`);
+					} else if (toastType() === "error") {
+						$$renderer.push("<!--[2-->");
+						errorIcon?.($$renderer);
+						$$renderer.push(`<!---->`);
+					} else if (toastType() === "warning") {
+						$$renderer.push("<!--[3-->");
+						warningIcon?.($$renderer);
+						$$renderer.push(`<!---->`);
+					} else if (toastType() === "info") {
+						$$renderer.push("<!--[4-->");
+						infoIcon?.($$renderer);
+						$$renderer.push(`<!---->`);
+					} else $$renderer.push("<!--[-1-->");
+					$$renderer.push(`<!--]-->`);
+				} else $$renderer.push("<!--[-1-->");
+				$$renderer.push(`<!--]--></div>`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]--> <div data-content=""${attr_class(clsx$1(cn(classes()?.content, toast?.classes?.content)))}><div data-title=""${attr_class(clsx$1(cn(classes()?.title, toast?.classes?.title)))}>`);
+			if (toast.title) {
+				$$renderer.push("<!--[0-->");
+				if (typeof toast.title !== "string") {
+					$$renderer.push("<!--[0-->");
+					const Title = toast.title;
+					if (Title) {
+						$$renderer.push("<!--[-->");
+						Title($$renderer, spread_props([toast.componentProps]));
+						$$renderer.push("<!--]-->");
+					} else {
+						$$renderer.push("<!--[!-->");
+						$$renderer.push("<!--]-->");
+					}
+				} else {
+					$$renderer.push("<!--[-1-->");
+					$$renderer.push(`${escape_html(toast.title)}`);
+				}
+				$$renderer.push(`<!--]-->`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]--></div> `);
+			if (toast.description) {
+				$$renderer.push("<!--[0-->");
+				$$renderer.push(`<div data-description=""${attr_class(clsx$1(cn(descriptionClass, toastDescriptionClass(), classes()?.description, toast.classes?.description)))}>`);
+				if (typeof toast.description !== "string") {
+					$$renderer.push("<!--[0-->");
+					const Description = toast.description;
+					if (Description) {
+						$$renderer.push("<!--[-->");
+						Description($$renderer, spread_props([toast.componentProps]));
+						$$renderer.push("<!--]-->");
+					} else {
+						$$renderer.push("<!--[!-->");
+						$$renderer.push("<!--]-->");
+					}
+				} else {
+					$$renderer.push("<!--[-1-->");
+					$$renderer.push(`${escape_html(toast.description)}`);
+				}
+				$$renderer.push(`<!--]--></div>`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]--></div> `);
+			if (toast.cancel) {
+				$$renderer.push("<!--[0-->");
+				if (typeof toast.cancel === "function") {
+					$$renderer.push("<!--[0-->");
+					if (toast.cancel) {
+						$$renderer.push("<!--[-->");
+						toast.cancel($$renderer, {});
+						$$renderer.push("<!--]-->");
+					} else {
+						$$renderer.push("<!--[!-->");
+						$$renderer.push("<!--]-->");
+					}
+				} else if (isAction(toast.cancel)) {
+					$$renderer.push("<!--[1-->");
+					$$renderer.push(`<button data-button="" data-cancel=""${attr_style(toast.cancelButtonStyle ?? cancelButtonStyle)}${attr_class(clsx$1(cn(classes()?.cancelButton, toast?.classes?.cancelButton)))}>${escape_html(toast.cancel.label)}</button>`);
+				} else $$renderer.push("<!--[-1-->");
+				$$renderer.push(`<!--]-->`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]--> `);
+			if (toast.action) {
+				$$renderer.push("<!--[0-->");
+				if (typeof toast.action === "function") {
+					$$renderer.push("<!--[0-->");
+					if (toast.action) {
+						$$renderer.push("<!--[-->");
+						toast.action($$renderer, {});
+						$$renderer.push("<!--]-->");
+					} else {
+						$$renderer.push("<!--[!-->");
+						$$renderer.push("<!--]-->");
+					}
+				} else if (isAction(toast.action)) {
+					$$renderer.push("<!--[1-->");
+					$$renderer.push(`<button data-button=""${attr_style(toast.actionButtonStyle ?? actionButtonStyle)}${attr_class(clsx$1(cn(classes()?.actionButton, toast?.classes?.actionButton)))}>${escape_html(toast.action.label)}</button>`);
+				} else $$renderer.push("<!--[-1-->");
+				$$renderer.push(`<!--]-->`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]-->`);
+		}
+		$$renderer.push(`<!--]--></li>`);
+	});
+}
+function SuccessIcon($$renderer) {
+	$$renderer.push(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" height="20" width="20" data-sonner-success-icon=""><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.857-9.809a.75.75 0 00-1.214-.882l-3.483 4.79-1.88-1.88a.75.75 0 10-1.06 1.061l2.5 2.5a.75.75 0 001.137-.089l4-5.5z" clip-rule="evenodd"></path></svg>`);
+}
+function ErrorIcon($$renderer) {
+	$$renderer.push(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" height="20" width="20" data-sonner-error-icon=""><path fill-rule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-8-5a.75.75 0 01.75.75v4.5a.75.75 0 01-1.5 0v-4.5A.75.75 0 0110 5zm0 10a1 1 0 100-2 1 1 0 000 2z" clip-rule="evenodd"></path></svg>`);
+}
+function WarningIcon($$renderer) {
+	$$renderer.push(`<svg viewBox="0 0 64 64" fill="currentColor" height="20" width="20" data-sonner-warning-icon="" xmlns="http://www.w3.org/2000/svg"><path d="M32.427,7.987c2.183,0.124 4,1.165 5.096,3.281l17.936,36.208c1.739,3.66 -0.954,8.585 -5.373,8.656l-36.119,0c-4.022,-0.064 -7.322,-4.631 -5.352,-8.696l18.271,-36.207c0.342,-0.65 0.498,-0.838 0.793,-1.179c1.186,-1.375 2.483,-2.111 4.748,-2.063Zm-0.295,3.997c-0.687,0.034 -1.316,0.419 -1.659,1.017c-6.312,11.979 -12.397,24.081 -18.301,36.267c-0.546,1.225 0.391,2.797 1.762,2.863c12.06,0.195 24.125,0.195 36.185,0c1.325,-0.064 2.321,-1.584 1.769,-2.85c-5.793,-12.184 -11.765,-24.286 -17.966,-36.267c-0.366,-0.651 -0.903,-1.042 -1.79,-1.03Z"></path><path d="M33.631,40.581l-3.348,0l-0.368,-16.449l4.1,0l-0.384,16.449Zm-3.828,5.03c0,-0.609 0.197,-1.113 0.592,-1.514c0.396,-0.4 0.935,-0.601 1.618,-0.601c0.684,0 1.223,0.201 1.618,0.601c0.395,0.401 0.593,0.905 0.593,1.514c0,0.587 -0.193,1.078 -0.577,1.473c-0.385,0.395 -0.929,0.593 -1.634,0.593c-0.705,0 -1.249,-0.198 -1.634,-0.593c-0.384,-0.395 -0.576,-0.886 -0.576,-1.473Z"></path></svg>`);
+}
+function InfoIcon($$renderer) {
+	$$renderer.push(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" height="20" width="20" data-sonner-info-icon=""><path fill-rule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a.75.75 0 000 1.5h.253a.25.25 0 01.244.304l-.459 2.066A1.75 1.75 0 0010.747 15H11a.75.75 0 000-1.5h-.253a.25.25 0 01-.244-.304l.459-2.066A1.75 1.75 0 009.253 9H9z" clip-rule="evenodd"></path></svg>`);
+}
+function CloseIcon($$renderer) {
+	$$renderer.push(`<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" data-sonner-close-icon=""><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>`);
+}
+var VISIBLE_TOASTS_AMOUNT = 3;
+var VIEWPORT_OFFSET = "24px";
+var MOBILE_VIEWPORT_OFFSET = "16px";
+var TOAST_LIFETIME = 4e3;
+var TOAST_WIDTH = 356;
+var GAP = 14;
+var DARK = "dark";
+var LIGHT = "light";
+function getOffsetObject(defaultOffset, mobileOffset) {
+	const styles = {};
+	[defaultOffset, mobileOffset].forEach((offset, index) => {
+		const isMobile = index === 1;
+		const prefix = isMobile ? "--mobile-offset" : "--offset";
+		const defaultValue = isMobile ? MOBILE_VIEWPORT_OFFSET : VIEWPORT_OFFSET;
+		function assignAll(offset) {
+			[
+				"top",
+				"right",
+				"bottom",
+				"left"
+			].forEach((key) => {
+				styles[`${prefix}-${key}`] = typeof offset === "number" ? `${offset}px` : offset;
+			});
+		}
+		if (typeof offset === "number" || typeof offset === "string") assignAll(offset);
+		else if (typeof offset === "object") [
+			"top",
+			"right",
+			"bottom",
+			"left"
+		].forEach((key) => {
+			const value = offset[key];
+			if (value === void 0) styles[`${prefix}-${key}`] = defaultValue;
+			else styles[`${prefix}-${key}`] = typeof value === "number" ? `${value}px` : value;
+		});
+		else assignAll(defaultValue);
+	});
+	return styles;
+}
+function Toaster($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		function getInitialTheme(t) {
+			if (t !== "system") return t;
+			if (typeof window !== "undefined") {
+				if (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) return DARK;
+				return LIGHT;
+			}
+			return LIGHT;
+		}
+		let { invert = false, position = "bottom-right", hotkey = ["altKey", "KeyT"], expand = false, closeButton = false, offset = VIEWPORT_OFFSET, mobileOffset = MOBILE_VIEWPORT_OFFSET, theme = "light", richColors = false, duration = TOAST_LIFETIME, visibleToasts = VISIBLE_TOASTS_AMOUNT, toastOptions = {}, dir = "auto", gap = GAP, pauseWhenPageIsHidden = false, loadingIcon: loadingIconProp, successIcon: successIconProp, errorIcon: errorIconProp, warningIcon: warningIconProp, closeIcon: closeIconProp, infoIcon: infoIconProp, containerAriaLabel = "Notifications", class: className, closeButtonAriaLabel = "Close toast", onblur, onfocus, onmouseenter, onmousemove, onmouseleave, ondragend, onpointerdown, onpointerup, $$slots, $$events, ...restProps } = $$props;
+		function getDocumentDirection() {
+			if (dir !== "auto") return dir;
+			if (typeof window === "undefined") return "ltr";
+			if (typeof document === "undefined") return "ltr";
+			const dirAttribute = document.documentElement.getAttribute("dir");
+			if (dirAttribute === "auto" || !dirAttribute) {
+				run(() => dir = window.getComputedStyle(document.documentElement).direction ?? "ltr");
+				return dir;
+			}
+			run(() => dir = dirAttribute);
+			return dirAttribute;
+		}
+		const possiblePositions = derived(() => Array.from(new Set([position, ...toastState.toasts.filter((toast) => toast.position).map((toast) => toast.position)].filter(Boolean))));
+		let expanded = false;
+		let interacting = false;
+		let actualTheme = getInitialTheme(theme);
+		const hotkeyLabel = derived(() => hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, ""));
+		sonnerContext.set(new SonnerState());
+		$$renderer.push(`<section${attr("aria-label", `${stringify(containerAriaLabel)} ${stringify(hotkeyLabel())}`)}${attr("tabindex", -1)} aria-live="polite" aria-relevant="additions text" aria-atomic="false" class="svelte-1tz765t">`);
+		if (toastState.toasts.length > 0) {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<!--[-->`);
+			const each_array = ensure_array_like(possiblePositions());
+			for (let index = 0, $$length = each_array.length; index < $$length; index++) {
+				let position = each_array[index];
+				const [y, x] = position.split("-");
+				const offsetObject = getOffsetObject(offset, mobileOffset);
+				$$renderer.push(`<ol${attributes({
+					tabindex: -1,
+					dir: getDocumentDirection(),
+					class: clsx$1(className),
+					"data-sonner-toaster": true,
+					"data-sonner-theme": actualTheme,
+					"data-y-position": y,
+					"data-x-position": x,
+					style: restProps.style,
+					...restProps
+				}, "svelte-1tz765t", void 0, {
+					"--front-toast-height": `${toastState.heights[0]?.height}px`,
+					"--width": `${TOAST_WIDTH}px`,
+					"--gap": `${gap}px`,
+					"--offset-top": offsetObject["--offset-top"],
+					"--offset-right": offsetObject["--offset-right"],
+					"--offset-bottom": offsetObject["--offset-bottom"],
+					"--offset-left": offsetObject["--offset-left"],
+					"--mobile-offset-top": offsetObject["--mobile-offset-top"],
+					"--mobile-offset-right": offsetObject["--mobile-offset-right"],
+					"--mobile-offset-bottom": offsetObject["--mobile-offset-bottom"],
+					"--mobile-offset-left": offsetObject["--mobile-offset-left"]
+				})}><!--[-->`);
+				const each_array_1 = ensure_array_like(toastState.toasts.filter((toast) => !toast.position && index === 0 || toast.position === position));
+				for (let index = 0, $$length = each_array_1.length; index < $$length; index++) {
+					let toast = each_array_1[index];
+					{
+						function successIcon($$renderer) {
+							if (successIconProp) {
+								$$renderer.push("<!--[0-->");
+								successIconProp?.($$renderer);
+								$$renderer.push(`<!---->`);
+							} else if (successIconProp !== null) {
+								$$renderer.push("<!--[1-->");
+								SuccessIcon($$renderer, {});
+							} else $$renderer.push("<!--[-1-->");
+							$$renderer.push(`<!--]-->`);
+						}
+						function errorIcon($$renderer) {
+							if (errorIconProp) {
+								$$renderer.push("<!--[0-->");
+								errorIconProp?.($$renderer);
+								$$renderer.push(`<!---->`);
+							} else if (errorIconProp !== null) {
+								$$renderer.push("<!--[1-->");
+								ErrorIcon($$renderer, {});
+							} else $$renderer.push("<!--[-1-->");
+							$$renderer.push(`<!--]-->`);
+						}
+						function warningIcon($$renderer) {
+							if (warningIconProp) {
+								$$renderer.push("<!--[0-->");
+								warningIconProp?.($$renderer);
+								$$renderer.push(`<!---->`);
+							} else if (warningIconProp !== null) {
+								$$renderer.push("<!--[1-->");
+								WarningIcon($$renderer, {});
+							} else $$renderer.push("<!--[-1-->");
+							$$renderer.push(`<!--]-->`);
+						}
+						function infoIcon($$renderer) {
+							if (infoIconProp) {
+								$$renderer.push("<!--[0-->");
+								infoIconProp?.($$renderer);
+								$$renderer.push(`<!---->`);
+							} else if (infoIconProp !== null) {
+								$$renderer.push("<!--[1-->");
+								InfoIcon($$renderer, {});
+							} else $$renderer.push("<!--[-1-->");
+							$$renderer.push(`<!--]-->`);
+						}
+						function closeIcon($$renderer) {
+							if (closeIconProp) {
+								$$renderer.push("<!--[0-->");
+								closeIconProp?.($$renderer);
+								$$renderer.push(`<!---->`);
+							} else if (closeIconProp !== null) {
+								$$renderer.push("<!--[1-->");
+								CloseIcon($$renderer, {});
+							} else $$renderer.push("<!--[-1-->");
+							$$renderer.push(`<!--]-->`);
+						}
+						Toast($$renderer, {
+							index,
+							toast,
+							defaultRichColors: richColors,
+							duration: toastOptions?.duration ?? duration,
+							class: toastOptions?.class ?? "",
+							descriptionClass: toastOptions?.descriptionClass || "",
+							invert,
+							visibleToasts,
+							closeButton,
+							interacting,
+							position,
+							style: toastOptions?.style ?? "",
+							classes: toastOptions.classes || {},
+							unstyled: toastOptions.unstyled ?? false,
+							cancelButtonStyle: toastOptions?.cancelButtonStyle ?? "",
+							actionButtonStyle: toastOptions?.actionButtonStyle ?? "",
+							closeButtonAriaLabel: toastOptions?.closeButtonAriaLabel ?? closeButtonAriaLabel,
+							expandByDefault: expand,
+							expanded,
+							pauseWhenPageIsHidden,
+							loadingIcon: loadingIconProp,
+							successIcon,
+							errorIcon,
+							warningIcon,
+							infoIcon,
+							closeIcon,
+							$$slots: {
+								successIcon: true,
+								errorIcon: true,
+								warningIcon: true,
+								infoIcon: true,
+								closeIcon: true
+							}
+						});
+					}
+				}
+				$$renderer.push(`<!--]--></ol>`);
+			}
+			$$renderer.push(`<!--]-->`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]--></section>`);
+	});
+}
+var defaultWindow$1 = 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$1(document) {
+	let activeElement = document.activeElement;
+	while (activeElement?.shadowRoot) {
+		const node = activeElement.shadowRoot.activeElement;
+		if (node === activeElement) break;
+		else activeElement = node;
+	}
+	return activeElement;
+}
+var ActiveElement$1 = class {
+	#document;
+	#subscribe;
+	constructor(options = {}) {
+		const { window = defaultWindow$1, 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$1(this.#document);
+	}
+};
+new ActiveElement$1();
+function runWatcher$1(sources, flush, effect, options = {}) {
+	const { lazy = false } = options;
+}
+function watch$1(sources, effect, options) {
+	runWatcher$1(sources, "post", effect, options);
+}
+function watchPre$1(sources, effect, options) {
+	runWatcher$1(sources, "pre", effect, options);
+}
+watch$1.pre = watchPre$1;
+function watchOnce$1(source, effect) {}
+function watchOncePre$1(source, effect) {}
+watchOnce$1.pre = watchOncePre$1;
+function getStorage(storageType, window) {
+	switch (storageType) {
+		case "local": return window.localStorage;
+		case "session": return window.sessionStorage;
+	}
+}
+/**
+* Creates reactive state that is persisted and synchronized across browser sessions and tabs using Web Storage.
+* @param key The unique key used to store the state in the storage.
+* @param initialValue The initial value of the state if not already present in the storage.
+* @param options Configuration options including storage type, serializer for complex data types, and whether to sync state changes across tabs.
+*
+* @see {@link https://runed.dev/docs/utilities/persisted-state}
+*/
+var PersistedState = class {
+	#current;
+	#key;
+	#serializer;
+	#storage;
+	#subscribe;
+	#version = 0;
+	constructor(key, initialValue, options = {}) {
+		const { storage: storageType = "local", serializer = {
+			serialize: JSON.stringify,
+			deserialize: JSON.parse
+		}, syncTabs = true, window = defaultWindow$1 } = options;
+		this.#current = initialValue;
+		this.#key = key;
+		this.#serializer = serializer;
+		if (window === void 0) return;
+		const storage = getStorage(storageType, window);
+		this.#storage = storage;
+		const existingValue = storage.getItem(key);
+		if (existingValue !== null) this.#current = this.#deserialize(existingValue);
+		else this.#serialize(initialValue);
+		if (syncTabs && storageType === "local") this.#subscribe = createSubscriber(() => {
+			return on(window, "storage", this.#handleStorageEvent);
+		});
+	}
+	get current() {
+		this.#subscribe?.();
+		this.#version;
+		const root = this.#deserialize(this.#storage?.getItem(this.#key)) ?? this.#current;
+		const proxies = /* @__PURE__ */ new WeakMap();
+		const proxy = (value) => {
+			if (value === null || value?.constructor.name === "Date" || typeof value !== "object") return value;
+			let p = proxies.get(value);
+			if (!p) {
+				p = new Proxy(value, {
+					get: (target, property) => {
+						this.#version;
+						return proxy(Reflect.get(target, property));
+					},
+					set: (target, property, value) => {
+						this.#version += 1;
+						Reflect.set(target, property, value);
+						this.#serialize(root);
+						return true;
+					}
+				});
+				proxies.set(value, p);
+			}
+			return p;
+		};
+		return proxy(root);
+	}
+	set current(newValue) {
+		this.#serialize(newValue);
+		this.#version += 1;
+	}
+	#handleStorageEvent = (event) => {
+		if (event.key !== this.#key || event.newValue === null) return;
+		this.#current = this.#deserialize(event.newValue);
+		this.#version += 1;
+	};
+	#deserialize(value) {
+		try {
+			return this.#serializer.deserialize(value);
+		} catch (error) {
+			console.error(`Error when parsing "${value}" from persisted store "${this.#key}"`, error);
+			return;
+		}
+	}
+	#serialize(value) {
+		try {
+			if (value != void 0) this.#storage?.setItem(this.#key, this.#serializer.serialize(value));
+		} catch (error) {
+			console.error(`Error when writing value from persisted store "${this.#key}" to ${this.#storage}`, error);
+		}
+	}
+};
+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;
+		if (prevValues && JSON.stringify(values) === JSON.stringify(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$1(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$1.pre(getter, (values, previousValues) => {
+			fn(values, previousValues ?? []);
+		}, options);
+	});
+}
+resource.pre = resourcePre;
+/**
+* Sanitizes an array of classnames by removing any empty strings.
+*/
+function sanitizeClassNames(classNames) {
+	return classNames.filter((className) => className.length > 0);
+}
+var noopStorage = {
+	getItem: (_key) => null,
+	setItem: (_key, _value) => {}
+};
+var isBrowser = typeof document !== "undefined";
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+var BoxSymbol = Symbol("box");
+var isWritableSymbol = Symbol("is-writable");
+function isBox(value) {
+	return isObject(value) && BoxSymbol in value;
+}
+/**
+* @returns Whether the value is a WritableBox
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function isWritableBox(value) {
+	return box.isBox(value) && isWritableSymbol in value;
+}
+function box(initialValue) {
+	let current = initialValue;
+	return {
+		[BoxSymbol]: true,
+		[isWritableSymbol]: true,
+		get current() {
+			return current;
+		},
+		set current(v) {
+			current = v;
+		}
+	};
+}
+function boxWith(getter, setter) {
+	const derived$1 = derived(getter);
+	if (setter) return {
+		[BoxSymbol]: true,
+		[isWritableSymbol]: true,
+		get current() {
+			return derived$1();
+		},
+		set current(v) {
+			setter(v);
+		}
+	};
+	return {
+		[BoxSymbol]: true,
+		get current() {
+			return getter();
+		}
+	};
+}
+function boxFrom(value) {
+	if (box.isBox(value)) return value;
+	if (isFunction(value)) return box.with(value);
+	return box(value);
+}
+/**
+* Function that gets an object of boxes, and returns an object of reactive values
+*
+* @example
+* const count = box(0)
+* const flat = box.flatten({ count, double: box.with(() => count.current) })
+* // type of flat is { count: number, readonly double: number }
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function boxFlatten(boxes) {
+	return Object.entries(boxes).reduce((acc, [key, b]) => {
+		if (!box.isBox(b)) return Object.assign(acc, { [key]: b });
+		if (box.isWritableBox(b)) Object.defineProperty(acc, key, {
+			get() {
+				return b.current;
+			},
+			set(v) {
+				b.current = v;
+			}
+		});
+		else Object.defineProperty(acc, key, { get() {
+			return b.current;
+		} });
+		return acc;
+	}, {});
+}
+/**
+* Function that converts a box to a readonly box.
+*
+* @example
+* const count = box(0) // WritableBox<number>
+* const countReadonly = box.readonly(count) // ReadableBox<number>
+*
+* @see {@link https://runed.dev/docs/functions/box}
+*/
+function toReadonlyBox(b) {
+	if (!box.isWritableBox(b)) return b;
+	return {
+		[BoxSymbol]: true,
+		get current() {
+			return b.current;
+		}
+	};
+}
+box.from = boxFrom;
+box.with = boxWith;
+box.flatten = boxFlatten;
+box.readonly = toReadonlyBox;
+box.isBox = isBox;
+box.isWritableBox = isWritableBox;
+function createParser(matcher, replacer) {
+	const regex = RegExp(matcher, "g");
+	return (str) => {
+		if (typeof str !== "string") throw new TypeError(`expected an argument of type string, but got ${typeof str}`);
+		if (!str.match(regex)) return str;
+		return str.replace(regex, replacer);
+	};
+}
+var camelToKebab = createParser(/[A-Z]/, (match) => `-${match.toLowerCase()}`);
+function styleToCSS(styleObj) {
+	if (!styleObj || typeof styleObj !== "object" || Array.isArray(styleObj)) throw new TypeError(`expected an argument of type object, but got ${typeof styleObj}`);
+	return Object.keys(styleObj).map((property) => `${camelToKebab(property)}: ${styleObj[property]};`).join("\n");
+}
+function styleToString(style = {}) {
+	return styleToCSS(style).replace("\n", " ");
+}
+styleToString({
+	position: "absolute",
+	width: "1px",
+	height: "1px",
+	padding: "0",
+	margin: "-1px",
+	overflow: "hidden",
+	clip: "rect(0, 0, 0, 0)",
+	whiteSpace: "nowrap",
+	borderWidth: "0",
+	transform: "translateX(-100%)"
+});
+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();
+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;
+var modeStorageKey = box("mode-watcher-mode");
+var themeStorageKey = box("mode-watcher-theme");
+/**
+* the modes that are supported, used for validation & type
+* derivation
+*/
+var modes = [
+	"dark",
+	"light",
+	"system"
+];
+function isValidMode(value) {
+	if (typeof value !== "string") return false;
+	return modes.includes(value);
+}
+var UserPrefersMode = class {
+	#defaultValue = "system";
+	#storage = isBrowser ? localStorage : noopStorage;
+	#initialValue = this.#storage.getItem(modeStorageKey.current);
+	#value = isValidMode(this.#initialValue) ? this.#initialValue : this.#defaultValue;
+	#persisted = this.#makePersisted();
+	#makePersisted(value = this.#value) {
+		return new PersistedState(modeStorageKey.current, value, { serializer: {
+			serialize: (v) => v,
+			deserialize: (v) => {
+				if (isValidMode(v)) return v;
+				return this.#defaultValue;
+			}
+		} });
+	}
+	constructor() {}
+	get current() {
+		return this.#persisted.current;
+	}
+	set current(newValue) {
+		this.#persisted.current = newValue;
+	}
+};
+var SystemPrefersMode = class {
+	#defaultValue = void 0;
+	#track = true;
+	#current = this.#defaultValue;
+	#mediaQueryState = typeof window !== "undefined" && typeof window.matchMedia === "function" ? new MediaQuery("prefers-color-scheme: light") : { current: false };
+	query() {
+		if (!isBrowser) return;
+		this.#current = this.#mediaQueryState.current ? "light" : "dark";
+	}
+	tracking(active) {
+		this.#track = active;
+	}
+	constructor() {
+		this.query = this.query.bind(this);
+		this.tracking = this.tracking.bind(this);
+	}
+	get current() {
+		return this.#current;
+	}
+};
+/**
+* Writable state that represents the user's preferred mode
+* (`"dark"`, `"light"` or `"system"`)
+*/
+var userPrefersMode = new UserPrefersMode();
+/**
+* Readable store that represents the system's preferred mode (`"dark"`, `"light"` or `undefined`)
+*/
+var systemPrefersMode = new SystemPrefersMode();
+var CustomTheme = class {
+	#storage = isBrowser ? localStorage : noopStorage;
+	#initialValue = this.#storage.getItem(themeStorageKey.current);
+	#value = this.#initialValue === null || this.#initialValue === void 0 ? "" : this.#initialValue;
+	#persisted = this.#makePersisted();
+	#makePersisted(value = this.#value) {
+		return new PersistedState(themeStorageKey.current, value, { serializer: {
+			serialize: (v) => {
+				if (typeof v !== "string") return "";
+				return v;
+			},
+			deserialize: (v) => v
+		} });
+	}
+	constructor() {}
+	/**
+	* The current theme.
+	* @returns The current theme.
+	*/
+	get current() {
+		return this.#persisted.current;
+	}
+	/**
+	* Set the current theme.
+	* @param newValue The new theme to set.
+	*/
+	set current(newValue) {
+		this.#persisted.current = newValue;
+	}
+};
+/**
+* A custom theme to apply and persist to the root `html` element.
+*/
+var customTheme = new CustomTheme();
+var timeoutAction;
+var timeoutEnable;
+/**
+* Whether this is the first time the function has been
+* called, which will be true for the initial load, where
+* we shouldn't need to disable any transitions, as there
+* is nothing to transition from.
+*/
+var hasLoaded = false;
+var styleElement = null;
+function getStyleElement() {
+	if (styleElement) return styleElement;
+	styleElement = document.createElement("style");
+	styleElement.appendChild(document.createTextNode(`* {
+		-webkit-transition: none !important;
+		-moz-transition: none !important;
+		-o-transition: none !important;
+		-ms-transition: none !important;
+		transition: none !important;
+	}`));
+	return styleElement;
+}
+function withoutTransition(action, synchronous = false) {
+	if (typeof document === "undefined") return;
+	if (!hasLoaded) {
+		hasLoaded = true;
+		action();
+		return;
+	}
+	if (typeof window !== "undefined" && window.__vitest_worker__) {
+		action();
+		return;
+	}
+	clearTimeout(timeoutAction);
+	clearTimeout(timeoutEnable);
+	const style = getStyleElement();
+	const disable = () => document.head.appendChild(style);
+	const enable = () => {
+		if (style.parentNode) document.head.removeChild(style);
+	};
+	function executeAction() {
+		action();
+		window.requestAnimationFrame(enable);
+	}
+	if (typeof window.requestAnimationFrame !== "undefined") {
+		disable();
+		if (synchronous) executeAction();
+		else window.requestAnimationFrame(() => {
+			executeAction();
+		});
+		return;
+	}
+	disable();
+	timeoutAction = window.setTimeout(() => {
+		action();
+		timeoutEnable = window.setTimeout(enable, 16);
+	}, 16);
+}
+var themeColors = box(void 0);
+var disableTransitions = box(true);
+var synchronousModeChanges = box(false);
+var darkClassNames = box([]);
+var lightClassNames = box([]);
+function createDerivedMode() {
+	const current = derived(() => {
+		if (!isBrowser) return void 0;
+		const derivedMode = userPrefersMode.current === "system" ? systemPrefersMode.current : userPrefersMode.current;
+		const sanitizedDarkClassNames = sanitizeClassNames(darkClassNames.current);
+		const sanitizedLightClassNames = sanitizeClassNames(lightClassNames.current);
+		function update() {
+			const htmlEl = document.documentElement;
+			const themeColorEl = document.querySelector("meta[name=\"theme-color\"]");
+			if (derivedMode === "light") {
+				if (sanitizedDarkClassNames.length) htmlEl.classList.remove(...sanitizedDarkClassNames);
+				if (sanitizedLightClassNames.length) htmlEl.classList.add(...sanitizedLightClassNames);
+				htmlEl.style.colorScheme = "light";
+				if (themeColorEl && themeColors.current) themeColorEl.setAttribute("content", themeColors.current.light);
+			} else {
+				if (sanitizedLightClassNames.length) htmlEl.classList.remove(...sanitizedLightClassNames);
+				if (sanitizedDarkClassNames.length) htmlEl.classList.add(...sanitizedDarkClassNames);
+				htmlEl.style.colorScheme = "dark";
+				if (themeColorEl && themeColors.current) themeColorEl.setAttribute("content", themeColors.current.dark);
+			}
+		}
+		if (disableTransitions.current) withoutTransition(update, synchronousModeChanges.current);
+		else update();
+		return derivedMode;
+	});
+	return { get current() {
+		return current();
+	} };
+}
+function createDerivedTheme() {
+	const current = derived(() => {
+		customTheme.current;
+		if (!isBrowser) return void 0;
+		function update() {
+			document.documentElement.setAttribute("data-theme", customTheme.current);
+		}
+		if (disableTransitions.current) withoutTransition(update, run(() => synchronousModeChanges.current));
+		else update();
+		return customTheme.current;
+	});
+	return { get current() {
+		return current();
+	} };
+}
+/**
+* Derived store that represents the current mode (`"dark"`, `"light"` or `undefined`)
+*/
+var derivedMode = createDerivedMode();
+createDerivedTheme();
+function Circle_check($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Icon($$renderer, spread_props([
+		{ name: "circle-check" },
+		props,
+		{ iconNode: [["circle", {
+			"cx": "12",
+			"cy": "12",
+			"r": "10"
+		}], ["path", { "d": "m9 12 2 2 4-4" }]] }
+	]));
+}
+function Octagon_x($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Icon($$renderer, spread_props([
+		{ name: "octagon-x" },
+		props,
+		{ iconNode: [
+			["path", { "d": "m15 9-6 6" }],
+			["path", { "d": "M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z" }],
+			["path", { "d": "m9 9 6 6" }]
+		] }
+	]));
+}
+function Info($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Icon($$renderer, spread_props([
+		{ name: "info" },
+		props,
+		{ iconNode: [
+			["circle", {
+				"cx": "12",
+				"cy": "12",
+				"r": "10"
+			}],
+			["path", { "d": "M12 16v-4" }],
+			["path", { "d": "M12 8h.01" }]
+		] }
+	]));
+}
+function Triangle_alert($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Icon($$renderer, spread_props([
+		{ name: "triangle-alert" },
+		props,
+		{ iconNode: [
+			["path", { "d": "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3" }],
+			["path", { "d": "M12 9v4" }],
+			["path", { "d": "M12 17h.01" }]
+		] }
+	]));
+}
+function Sonner_1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { $$slots, $$events, ...restProps } = $$props;
+		{
+			function loadingIcon($$renderer) {
+				Loader_circle($$renderer, { class: "size-4 animate-spin" });
+			}
+			function successIcon($$renderer) {
+				Circle_check($$renderer, { class: "size-4" });
+			}
+			function errorIcon($$renderer) {
+				Octagon_x($$renderer, { class: "size-4" });
+			}
+			function infoIcon($$renderer) {
+				Info($$renderer, { class: "size-4" });
+			}
+			function warningIcon($$renderer) {
+				Triangle_alert($$renderer, { class: "size-4" });
+			}
+			Toaster($$renderer, spread_props([
+				{
+					theme: derivedMode.current,
+					class: "toaster group",
+					style: "--normal-bg: var(--color-popover); --normal-text: var(--color-popover-foreground); --normal-border: var(--color-border);"
+				},
+				restProps,
+				{
+					loadingIcon,
+					successIcon,
+					errorIcon,
+					infoIcon,
+					warningIcon,
+					$$slots: {
+						loadingIcon: true,
+						successIcon: true,
+						errorIcon: true,
+						infoIcon: true,
+						warningIcon: true
+					}
+				}
+			]));
+		}
+	});
+}
+function _layout($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { children } = $$props;
+		const queryClient = new QueryClient({ defaultOptions: { queries: { enabled: false } } });
+		Sonner_1($$renderer, {});
+		$$renderer.push(`<!----> `);
+		QueryClientProvider($$renderer, {
+			client: queryClient,
+			children: ($$renderer) => {
+				children($$renderer);
+				$$renderer.push(`<!---->`);
+			},
+			$$slots: { default: true }
+		});
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+export { _layout as default };
+
+//# sourceMappingURL=_layout.svelte-CP4jFwsK.js.map