@selvajs/selva 4.17.1 → 4.18.0

package/build/server/chunks/chunks/scroll-lock.js-DCKuvkpD.js

@@ -0,0 +1,1894 @@
+import { t as tick, m as mount, u as unmount } from './index-server.js-CcF535k3.js';
+import { h as hasContext, g as getContext, a as setContext, b as getAllContexts, ae as derived, r as run } from './server.js-DAQXUDN9.js';
+import { o as on } from './events.js-CVsvj0NP.js';
+import { c as createSubscriber, S as SvelteMap } from './index-server2.js-siA98IdX.js';
+import { b as boxWith, s as simpleBox, e as executeCallbacks, i as isObject } from './create-id.js-BmrVbPtx.js';
+
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/internal/configurable-globals.js
+var defaultWindow = void 0;
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/internal/utils/dom.js
+/**
+* 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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/active-element/active-element.svelte.js
+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();
+	}
+	get current() {
+		this.#subscribe?.();
+		if (!this.#document) return null;
+		return getActiveElement$1(this.#document);
+	}
+};
+new ActiveElement();
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/internal/utils/is.js
+function isFunction(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/extract/extract.svelte.js
+function extract(value, defaultValue) {
+	if (isFunction(value)) {
+		const gotten = value();
+		if (gotten === void 0) return defaultValue;
+		return gotten;
+	}
+	return value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/context/context.js
+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);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/use-debounce/use-debounce.svelte.js
+function useDebounce(callback, wait) {
+	let context = null;
+	const wait$ = derived(() => extract(wait, 250));
+	function debounced(...args) {
+		if (context) {
+			if (context.timeout) clearTimeout(context.timeout);
+		} else {
+			let resolve;
+			let reject;
+			context = {
+				timeout: null,
+				runner: null,
+				promise: new Promise((res, rej) => {
+					resolve = res;
+					reject = rej;
+				}),
+				resolve,
+				reject
+			};
+		}
+		context.runner = async () => {
+			if (!context) return;
+			const ctx = context;
+			context = null;
+			try {
+				ctx.resolve(await callback.apply(this, args));
+			} catch (error) {
+				ctx.reject(error);
+			}
+		};
+		context.timeout = setTimeout(context.runner, wait$());
+		return context.promise;
+	}
+	debounced.cancel = async () => {
+		if (!context || context.timeout === null) {
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			if (!context || context.timeout === null) return;
+		}
+		clearTimeout(context.timeout);
+		context.reject("Cancelled");
+		context = null;
+	};
+	debounced.runScheduledNow = async () => {
+		if (!context || !context.timeout) {
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			if (!context || !context.timeout) return;
+		}
+		clearTimeout(context.timeout);
+		context.timeout = null;
+		await context.runner?.();
+	};
+	Object.defineProperty(debounced, "pending", {
+		enumerable: true,
+		get() {
+			return !!context?.timeout;
+		}
+	});
+	return debounced;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/watch/watch.svelte.js
+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;
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/internal/utils/get.js
+function get(value) {
+	if (isFunction(value)) return value();
+	return value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/element-size/element-size.svelte.js
+var ElementSize = class {
+	#size = {
+		width: 0,
+		height: 0
+	};
+	#observed = false;
+	#options;
+	#node;
+	#window;
+	#width = derived(() => {
+		this.#subscribe()?.();
+		return this.getSize().width;
+	});
+	#height = derived(() => {
+		this.#subscribe()?.();
+		return this.getSize().height;
+	});
+	#subscribe = derived(() => {
+		const node$ = get(this.#node);
+		if (!node$) return;
+		return createSubscriber();
+	});
+	constructor(node, options = { box: "border-box" }) {
+		this.#window = options.window ?? defaultWindow;
+		this.#options = options;
+		this.#node = node;
+		this.#size = {
+			width: 0,
+			height: 0
+		};
+	}
+	calculateSize() {
+		const element = get(this.#node);
+		if (!element || !this.#window) return;
+		const offsetWidth = element.offsetWidth;
+		const offsetHeight = element.offsetHeight;
+		if (this.#options.box === "border-box") return {
+			width: offsetWidth,
+			height: offsetHeight
+		};
+		const style = this.#window.getComputedStyle(element);
+		const paddingWidth = parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+		const paddingHeight = parseFloat(style.paddingTop) + parseFloat(style.paddingBottom);
+		const borderWidth = parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
+		const borderHeight = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
+		return {
+			width: offsetWidth - paddingWidth - borderWidth,
+			height: offsetHeight - paddingHeight - borderHeight
+		};
+	}
+	getSize() {
+		return this.#observed ? this.#size : this.calculateSize() ?? this.#size;
+	}
+	get current() {
+		this.#subscribe()?.();
+		return this.getSize();
+	}
+	get width() {
+		return this.#width();
+	}
+	get height() {
+		return this.#height();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/is-mounted/is-mounted.svelte.js
+var IsMounted = class {
+	#isMounted = false;
+	constructor() {}
+	get current() {
+		return this.#isMounted;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/runed@0.35.1_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte_ccb98f91f4ce0b9f84559c7b420149d6/node_modules/runed/dist/utilities/previous/previous.svelte.js
+var Previous = class {
+	#previousCallback = () => void 0;
+	#previous = derived(() => this.#previousCallback());
+	constructor(getter, initialValue) {
+		let actualPrevious = void 0;
+		if (initialValue !== void 0) actualPrevious = initialValue;
+		this.#previousCallback = () => {
+			try {
+				return actualPrevious;
+			} finally {
+				actualPrevious = getter();
+			}
+		};
+	}
+	get current() {
+		return this.#previous();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/after-tick.js
+function afterTick(fn) {
+	(/* @__PURE__ */ tick()).then(fn);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/dom.js
+var ELEMENT_NODE = 1;
+var DOCUMENT_NODE = 9;
+var DOCUMENT_FRAGMENT_NODE = 11;
+function isHTMLElement$1(node) {
+	return isObject(node) && node.nodeType === ELEMENT_NODE && typeof node.nodeName === "string";
+}
+function isDocument(node) {
+	return isObject(node) && node.nodeType === DOCUMENT_NODE;
+}
+function isWindow(node) {
+	return isObject(node) && node.constructor?.name === "VisualViewport";
+}
+function isNode(node) {
+	return isObject(node) && node.nodeType !== void 0;
+}
+function isShadowRoot(node) {
+	return isNode(node) && node.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in node;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	if (!isHTMLElement$1(parent) || !isHTMLElement$1(child)) return false;
+	const rootNode = child.getRootNode?.();
+	if (parent === child) return true;
+	if (parent.contains(child)) return true;
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getDocument(node) {
+	if (isDocument(node)) return node;
+	if (isWindow(node)) return node.document;
+	return node?.ownerDocument ?? document;
+}
+function getWindow(node) {
+	if (isShadowRoot(node)) return getWindow(node.host);
+	if (isDocument(node)) return node.defaultView ?? window;
+	if (isHTMLElement$1(node)) return node.ownerDocument?.defaultView ?? window;
+	return window;
+}
+function getActiveElement(rootNode) {
+	let activeElement = rootNode.activeElement;
+	while (activeElement?.shadowRoot) {
+		const el = activeElement.shadowRoot.activeElement;
+		if (el === activeElement) break;
+		else activeElement = el;
+	}
+	return activeElement;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sveltejs+kit@2.70.3_@opentelemetry+api@1.9.1_@sveltejs+vite-plu_085b9b59d7b885361e92fe917f00c285/node_modules/svelte-toolbelt/dist/utils/dom-context.svelte.js
+var DOMContext = class {
+	element;
+	#root = derived(() => {
+		if (!this.element.current) return document;
+		return this.element.current.getRootNode() ?? document;
+	});
+	get root() {
+		return this.#root();
+	}
+	set root($$value) {
+		return this.#root($$value);
+	}
+	constructor(element) {
+		if (typeof element === "function") this.element = boxWith(element);
+		else this.element = element;
+	}
+	getDocument = () => {
+		return getDocument(this.root);
+	};
+	getWindow = () => {
+		return this.getDocument().defaultView ?? window;
+	};
+	getActiveElement = () => {
+		return getActiveElement(this.root);
+	};
+	isActiveElement = (node) => {
+		return node === this.getActiveElement();
+	};
+	getElementById(id) {
+		return this.root.getElementById(id);
+	}
+	querySelector = (selector) => {
+		if (!this.root) return null;
+		return this.root.querySelector(selector);
+	};
+	querySelectorAll = (selector) => {
+		if (!this.root) return [];
+		return this.root.querySelectorAll(selector);
+	};
+	setTimeout = (callback, delay) => {
+		return this.getWindow().setTimeout(callback, delay);
+	};
+	clearTimeout = (timeoutId) => {
+		return this.getWindow().clearTimeout(timeoutId);
+	};
+};
+var ARROW_DOWN = "ArrowDown";
+var ARROW_LEFT = "ArrowLeft";
+var ARROW_RIGHT = "ArrowRight";
+var ARROW_UP = "ArrowUp";
+var ENTER = "Enter";
+var HOME = "Home";
+var PAGE_DOWN = "PageDown";
+var PAGE_UP = "PageUp";
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/is.js
+var isBrowser = typeof document !== "undefined";
+var isIOS = getIsIOS();
+function getIsIOS() {
+	return isBrowser && window?.navigator?.userAgent && (/iP(ad|hone|od)/.test(window.navigator.userAgent) || window?.navigator?.maxTouchPoints > 2 && /iPad|Macintosh/.test(window?.navigator.userAgent));
+}
+function isHTMLElement(element) {
+	return element instanceof HTMLElement;
+}
+function isElement(element) {
+	return element instanceof Element;
+}
+function isElementOrSVGElement(element) {
+	return element instanceof Element || element instanceof SVGElement;
+}
+function isNotNull(value) {
+	return value !== null;
+}
+/**
+* Determines if the provided object is a valid `HTMLInputElement` with
+* a `select` method available.
+*/
+function isSelectableInput(element) {
+	return element instanceof HTMLInputElement && "select" in element;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/animations-complete.js
+var AnimationsComplete = class {
+	#opts;
+	#currentFrame = null;
+	#observer = null;
+	#runId = 0;
+	constructor(opts) {
+		this.#opts = opts;
+	}
+	#cleanup() {
+		if (this.#currentFrame !== null) {
+			window.cancelAnimationFrame(this.#currentFrame);
+			this.#currentFrame = null;
+		}
+		this.#observer?.disconnect();
+		this.#observer = null;
+		this.#runId++;
+	}
+	run(fn) {
+		this.#cleanup();
+		const node = this.#opts.ref.current;
+		if (!node) return;
+		if (typeof node.getAnimations !== "function") {
+			this.#executeCallback(fn);
+			return;
+		}
+		const runId = this.#runId;
+		const executeIfCurrent = () => {
+			if (runId !== this.#runId) return;
+			this.#executeCallback(fn);
+		};
+		const waitForAnimations = () => {
+			if (runId !== this.#runId) return;
+			const animations = node.getAnimations();
+			if (animations.length === 0) {
+				executeIfCurrent();
+				return;
+			}
+			Promise.all(animations.map((animation) => animation.finished)).then(() => {
+				executeIfCurrent();
+			}).catch(() => {
+				if (runId !== this.#runId) return;
+				if (node.getAnimations().some((animation) => animation.pending || animation.playState !== "finished")) {
+					waitForAnimations();
+					return;
+				}
+				executeIfCurrent();
+			});
+		};
+		const requestWaitForAnimations = () => {
+			this.#currentFrame = window.requestAnimationFrame(() => {
+				this.#currentFrame = null;
+				waitForAnimations();
+			});
+		};
+		if (!this.#opts.afterTick.current) {
+			requestWaitForAnimations();
+			return;
+		}
+		this.#currentFrame = window.requestAnimationFrame(() => {
+			this.#currentFrame = null;
+			const startingStyleAttr = "data-starting-style";
+			if (!node.hasAttribute(startingStyleAttr)) {
+				requestWaitForAnimations();
+				return;
+			}
+			this.#observer = new MutationObserver(() => {
+				if (runId !== this.#runId) return;
+				if (node.hasAttribute(startingStyleAttr)) return;
+				this.#observer?.disconnect();
+				this.#observer = null;
+				requestWaitForAnimations();
+			});
+			this.#observer.observe(node, {
+				attributes: true,
+				attributeFilter: [startingStyleAttr]
+			});
+		});
+	}
+	#executeCallback(fn) {
+		const execute = () => {
+			fn();
+		};
+		if (this.#opts.afterTick) afterTick(execute);
+		else execute();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/presence-manager.svelte.js
+var PresenceManager = class {
+	#opts;
+	#enabled;
+	#afterAnimations;
+	#shouldRender = false;
+	#transitionStatus = void 0;
+	#hasMounted = false;
+	#transitionFrame = null;
+	constructor(opts) {
+		this.#opts = opts;
+		this.#shouldRender = opts.open.current;
+		this.#enabled = opts.enabled ?? true;
+		this.#afterAnimations = new AnimationsComplete({
+			ref: this.#opts.ref,
+			afterTick: this.#opts.open
+		});
+		watch(() => this.#opts.open.current, (isOpen) => {
+			if (!this.#hasMounted) {
+				this.#hasMounted = true;
+				return;
+			}
+			this.#clearTransitionFrame();
+			if (!isOpen && this.#opts.shouldSkipExitAnimation?.()) {
+				this.#shouldRender = false;
+				this.#transitionStatus = void 0;
+				this.#opts.onComplete?.();
+				return;
+			}
+			if (isOpen) this.#shouldRender = true;
+			this.#transitionStatus = isOpen ? "starting" : "ending";
+			if (isOpen) this.#transitionFrame = window.requestAnimationFrame(() => {
+				this.#transitionFrame = null;
+				if (this.#opts.open.current) this.#transitionStatus = void 0;
+			});
+			if (!this.#enabled) {
+				if (!isOpen) this.#shouldRender = false;
+				this.#transitionStatus = void 0;
+				this.#opts.onComplete?.();
+				return;
+			}
+			this.#afterAnimations.run(() => {
+				if (isOpen === this.#opts.open.current) {
+					if (!this.#opts.open.current) this.#shouldRender = false;
+					this.#transitionStatus = void 0;
+					this.#opts.onComplete?.();
+				}
+			});
+		});
+	}
+	get shouldRender() {
+		return this.#shouldRender;
+	}
+	get transitionStatus() {
+		return this.#transitionStatus;
+	}
+	#clearTransitionFrame() {
+		if (this.#transitionFrame === null) return;
+		window.cancelAnimationFrame(this.#transitionFrame);
+		this.#transitionFrame = null;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/noop.js
+/**
+* A no operation function (does nothing)
+*/
+function noop() {}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/config/bits-config.js
+var BitsConfigContext = new Context("BitsConfig");
+/**
+* Gets the current Bits UI configuration state from the context.
+*
+* Returns a default configuration (where all values are `undefined`) if no configuration is found.
+*/
+function getBitsConfig() {
+	const fallback = new BitsConfigState(null, {});
+	return BitsConfigContext.getOr(fallback).opts;
+}
+/**
+* Configuration state that inherits from parent configurations.
+*
+* @example
+* Config resolution:
+* ```
+* Level 1: { defaultPortalTo: "#some-element", theme: "dark" }
+* Level 2: { spacing: "large" } // inherits defaultPortalTo="#some-element", theme="dark"
+* Level 3: { theme: "light" }   // inherits defaultPortalTo="#some-element", spacing="large", overrides theme="light"
+* ```
+*/
+var BitsConfigState = class {
+	opts;
+	constructor(parent, opts) {
+		const resolveConfigOption = createConfigResolver(parent, opts);
+		this.opts = {
+			defaultPortalTo: resolveConfigOption((config) => config.defaultPortalTo),
+			defaultLocale: resolveConfigOption((config) => config.defaultLocale)
+		};
+	}
+};
+/**
+* Returns a config resolver that resolves a given config option's value.
+*
+* The resolver creates reactive boxes that resolve config option values using this priority:
+* 1. Current level's value (if defined)
+* 2. Parent level's value (if defined and current is undefined)
+* 3. `undefined` (if no value is found in either parent or child)
+*
+* @param parent - Parent configuration state (null if this is root level)
+* @param currentOpts - Current level's configuration options
+*
+* @example
+* ```typescript
+* // Given this hierarchy:
+* // Root: { defaultPortalTo: "#some-element" }
+* // Child: { someOtherProp: "value" } // no defaultPortalTo specified
+*
+* const resolveConfigOption = createConfigResolver(parent, opts);
+* const portalTo = resolveConfigOption(config => config.defaultPortalTo);
+*
+* // portalTo.current === "#some-element" (inherited from parent)
+* // even when child didn't specify `defaultPortalTo`
+* ```
+*/
+function createConfigResolver(parent, currentOpts) {
+	return (getter) => {
+		return boxWith(() => {
+			const value = getter(currentOpts)?.current;
+			if (value !== void 0) return value;
+			if (parent === null) return void 0;
+			return getter(parent.opts)?.current;
+		});
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/config/prop-resolvers.js
+/**
+* Creates a generic prop resolver that follows a standard priority chain:
+* 1. The getter's prop value (if defined)
+* 2. The config default value (if no getter prop value is defined)
+* 3. The fallback value (if no config value found)
+*/
+function createPropResolver(configOption, fallback) {
+	return (getProp) => {
+		const config = getBitsConfig();
+		return boxWith(() => {
+			const propValue = getProp();
+			if (propValue !== void 0) return propValue;
+			const option = configOption(config).current;
+			if (option !== void 0) return option;
+			return fallback;
+		});
+	};
+}
+/**
+* Resolves a portal's `to` value using the prop, the config default, or a fallback.
+*
+* Default value: `"body"`
+*/
+var resolvePortalToProp = createPropResolver((config) => config.defaultPortalTo, "body");
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/portal/portal.svelte
+function Portal($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { to: toProp, children, disabled } = $$props;
+		const to = resolvePortalToProp(() => toProp);
+		getAllContexts();
+		let target = derived(getTarget);
+		function getTarget() {
+			if (!isBrowser || disabled) return null;
+			let localTarget = null;
+			if (typeof to.current === "string") localTarget = document.querySelector(to.current);
+			else localTarget = to.current;
+			return localTarget;
+		}
+		let instance;
+		function unmountInstance() {
+			if (instance) {
+				unmount();
+				instance = null;
+			}
+		}
+		watch([() => target(), () => disabled], ([target, disabled]) => {
+			if (!target || disabled) {
+				unmountInstance();
+				return;
+			}
+			instance = mount();
+			return () => {
+				unmountInstance();
+			};
+		});
+		if (disabled) {
+			$$renderer.push("<!--[0-->");
+			children?.($$renderer);
+			$$renderer.push(`<!---->`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/debounce.js
+function debounce(fn, wait = 500) {
+	let timeout = null;
+	const debounced = (...args) => {
+		if (timeout !== null) clearTimeout(timeout);
+		timeout = setTimeout(() => {
+			fn(...args);
+		}, wait);
+	};
+	debounced.destroy = () => {
+		if (timeout !== null) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+	};
+	return debounced;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/elements.js
+function isOrContainsTarget(node, target) {
+	return node === target || node.contains(target);
+}
+function getOwnerDocument(el) {
+	return el?.ownerDocument ?? document;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/dom.js
+/**
+* Determines if the click event truly occurred outside the content node.
+* This was added to handle password managers and other elements that may be injected
+* into the DOM but visually appear inside the content.
+*/
+function isClickTrulyOutside(event, contentNode) {
+	const { clientX, clientY } = event;
+	const rect = contentNode.getBoundingClientRect();
+	return clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/menu/context-menu-attributes.js
+var CONTEXT_MENU_TRIGGER_ATTR = "data-context-menu-trigger";
+var CONTEXT_MENU_CONTENT_ATTR = "data-context-menu-content";
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/dismissible-layer/use-dismissable-layer.svelte.js
+globalThis.bitsDismissableLayers ??= /* @__PURE__ */ new Map();
+var DismissibleLayerState = class DismissibleLayerState {
+	static create(opts) {
+		return new DismissibleLayerState(opts);
+	}
+	opts;
+	#interactOutsideProp;
+	#behaviorType;
+	#interceptedEvents = { pointerdown: false };
+	#isResponsibleLayer = false;
+	#capturedPointerDown = null;
+	#isFocusInsideDOMTree = false;
+	#documentObj = void 0;
+	#onFocusOutside;
+	#unsubClickListener = noop;
+	/**
+	* Set once the layer is torn down. Deferred work scheduled before teardown can
+	* still run afterwards, so every such callback must short-circuit on this
+	* before reading `this.opts.ref.current` — reading a destroyed `$derived`
+	* triggers Svelte's `derived_inert` warning. A class field rather than a
+	* constructor local so the class-field handlers below can see it too.
+	*/
+	#destroyed = false;
+	constructor(opts) {
+		this.opts = opts;
+		this.#behaviorType = opts.interactOutsideBehavior;
+		this.#interactOutsideProp = opts.onInteractOutside;
+		this.#onFocusOutside = opts.onFocusOutside;
+		let unsubEvents = noop;
+		let registeredNode = null;
+		const cleanup = () => {
+			registeredNode = null;
+			this.#resetState();
+			globalThis.bitsDismissableLayers.delete(this);
+			this.#handleInteractOutside.destroy();
+			this.#unsubClickListener();
+			unsubEvents();
+		};
+		watch([() => this.opts.enabled.current, () => this.opts.ref.current], ([enabled, node]) => {
+			const nextNode = enabled ? node : null;
+			if (registeredNode === nextNode) return;
+			cleanup();
+			if (!nextNode) return;
+			registeredNode = nextNode;
+			this.#documentObj = getOwnerDocument(nextNode);
+			globalThis.bitsDismissableLayers.set(this, this.#behaviorType);
+			unsubEvents = this.#addEventListeners();
+		});
+	}
+	#handleFocus = (event) => {
+		if (event.defaultPrevented) return;
+		if (this.#destroyed || !this.opts.ref.current) return;
+		afterTick(() => {
+			if (this.#destroyed) return;
+			if (!this.opts.ref.current || this.#isTargetWithinLayer(event.target)) return;
+			if (event.target && !this.#isFocusInsideDOMTree) this.#onFocusOutside.current?.(event);
+		});
+	};
+	#addEventListeners() {
+		const document = this.#documentObj;
+		const onPointerDownCapture = (event) => {
+			run(() => {
+				this.#markInterceptedEvent(event);
+				this.#markResponsibleLayer(event);
+			});
+		};
+		const onPointerDown = (event) => {
+			if (event.cancelBubble || event !== this.#capturedPointerDown) return;
+			this.#markNonInterceptedEvent(event);
+			this.#handleInteractOutside(event);
+		};
+		document.addEventListener("pointerdown", onPointerDownCapture, true);
+		document.addEventListener("pointerdown", onPointerDown);
+		return executeCallbacks(() => document.removeEventListener("pointerdown", onPointerDownCapture, true), () => document.removeEventListener("pointerdown", onPointerDown), on(document, "focusin", this.#handleFocus));
+	}
+	#handleDismiss = (e) => {
+		let event = e;
+		if (event.defaultPrevented) event = createWrappedEvent(e);
+		this.#interactOutsideProp.current(e);
+	};
+	#handleInteractOutside = debounce((e) => {
+		if (!this.opts.ref.current) {
+			this.#unsubClickListener();
+			return;
+		}
+		const isEventValid = this.opts.isValidEvent.current(e, this.opts.ref.current) || isValidEvent(e, this.opts.ref.current);
+		if (!this.#isResponsibleLayer || this.#isAnyEventIntercepted() || !isEventValid) {
+			this.#unsubClickListener();
+			return;
+		}
+		let event = e;
+		if (event.defaultPrevented) event = createWrappedEvent(event);
+		if (this.#behaviorType.current !== "close" && this.#behaviorType.current !== "defer-otherwise-close") {
+			this.#unsubClickListener();
+			return;
+		}
+		if (e.pointerType === "touch") {
+			this.#unsubClickListener();
+			this.#unsubClickListener = on(this.#documentObj, "click", this.#handleDismiss, { once: true });
+		} else this.#interactOutsideProp.current(event);
+	}, 10);
+	#markInterceptedEvent = (e) => {
+		this.#interceptedEvents[e.type] = true;
+	};
+	#markNonInterceptedEvent = (e) => {
+		this.#interceptedEvents[e.type] = false;
+	};
+	#markResponsibleLayer = (event) => {
+		this.#capturedPointerDown = event;
+		if (!this.opts.ref.current) return;
+		this.#isResponsibleLayer = isResponsibleLayer(this.opts.ref.current);
+	};
+	#isTargetWithinLayer = (target) => {
+		if (!this.opts.ref.current) return false;
+		return isOrContainsTarget(this.opts.ref.current, target);
+	};
+	/**
+	* Resets the per-interaction state. Must stay synchronous.
+	*
+	* This was a `debounce(..., 20)` from when it was also wired to a capture-phase
+	* interaction-end listener and had to land after the 10ms `#handleInteractOutside`
+	* debounce. That listener is gone, but the debounce stayed on the `cleanup()` path —
+	* and because `watch` runs `cleanup()` once per open (`ref` goes null -> node), every
+	* layer scheduled a reset 20ms into its own lifetime. An outside `pointerdown` landing
+	* 10-20ms after that cleanup would have its `#isResponsibleLayer` flag cleared by the
+	* stale reset in the gap before the debounced `#handleInteractOutside` ran, which then
+	* bailed and left the layer open. `cleanup()` destroys `#handleInteractOutside` anyway,
+	* so nothing is left in flight that needs to observe the pre-reset state.
+	*/
+	#resetState = () => {
+		for (const eventType in this.#interceptedEvents) this.#interceptedEvents[eventType] = false;
+		this.#isResponsibleLayer = false;
+		this.#capturedPointerDown = null;
+	};
+	#isAnyEventIntercepted() {
+		return Object.values(this.#interceptedEvents).some(Boolean);
+	}
+	#onfocuscapture = () => {
+		this.#isFocusInsideDOMTree = true;
+	};
+	#onblurcapture = () => {
+		this.#isFocusInsideDOMTree = false;
+	};
+	props = {
+		onfocuscapture: this.#onfocuscapture,
+		onblurcapture: this.#onblurcapture
+	};
+};
+function getTopMostDismissableLayer(layersArr = [...globalThis.bitsDismissableLayers]) {
+	return layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+}
+function isResponsibleLayer(node) {
+	const layersArr = [...globalThis.bitsDismissableLayers];
+	/**
+	* We first check if we can find a top layer with `close` or `ignore`.
+	* If that top layer was found and matches the provided node, then the node is
+	* responsible for the outside interaction. Otherwise, we know that all layers defer so
+	* the first layer is the responsible one.
+	*/
+	const topMostLayer = getTopMostDismissableLayer(layersArr);
+	if (topMostLayer) return topMostLayer[0].opts.ref.current === node;
+	const [firstLayerNode] = layersArr[0];
+	return firstLayerNode.opts.ref.current === node;
+}
+function isValidEvent(e, node) {
+	const target = e.target;
+	if (!isElementOrSVGElement(target)) return false;
+	const targetIsContextMenuTrigger = Boolean(target.closest(`[${CONTEXT_MENU_TRIGGER_ATTR}]`));
+	const nodeIsContextMenu = Boolean(node.closest(`[${CONTEXT_MENU_CONTENT_ATTR}]`));
+	if ("button" in e && e.button > 0 && !targetIsContextMenuTrigger) return false;
+	if ("button" in e && e.button === 0 && targetIsContextMenuTrigger && nodeIsContextMenu) return true;
+	if (targetIsContextMenuTrigger && nodeIsContextMenu) return false;
+	return getOwnerDocument(target).documentElement.contains(target) && !isOrContainsTarget(node, target) && isClickTrulyOutside(e, node);
+}
+function createWrappedEvent(e) {
+	const capturedCurrentTarget = e.currentTarget;
+	const capturedTarget = e.target;
+	let newEvent;
+	if (e instanceof PointerEvent) newEvent = new PointerEvent(e.type, e);
+	else newEvent = new PointerEvent("pointerdown", e);
+	let isPrevented = false;
+	return new Proxy(newEvent, { get: (target, prop) => {
+		if (prop === "currentTarget") return capturedCurrentTarget;
+		if (prop === "target") return capturedTarget;
+		if (prop === "preventDefault") return () => {
+			isPrevented = true;
+			if (typeof target.preventDefault === "function") target.preventDefault();
+		};
+		if (prop === "defaultPrevented") return isPrevented;
+		if (prop in target) return target[prop];
+		return e[prop];
+	} });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/dismissible-layer/dismissible-layer.svelte
+function Dismissible_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { interactOutsideBehavior = "close", onInteractOutside = noop, onFocusOutside = noop, id, children, enabled, isValidEvent = () => false, ref } = $$props;
+		const dismissibleLayerState = DismissibleLayerState.create({
+			id: boxWith(() => id),
+			interactOutsideBehavior: boxWith(() => interactOutsideBehavior),
+			onInteractOutside: boxWith(() => onInteractOutside),
+			enabled: boxWith(() => enabled),
+			onFocusOutside: boxWith(() => onFocusOutside),
+			isValidEvent: boxWith(() => isValidEvent),
+			ref
+		});
+		children?.($$renderer, { props: dismissibleLayerState.props });
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/escape-layer/use-escape-layer.svelte.js
+globalThis.bitsEscapeLayers ??= /* @__PURE__ */ new Map();
+var EscapeLayerState = class EscapeLayerState {
+	static create(opts) {
+		return new EscapeLayerState(opts);
+	}
+	opts;
+	domContext;
+	constructor(opts) {
+		this.opts = opts;
+		this.domContext = new DOMContext(this.opts.ref);
+		let unsubEvents = noop;
+		watch(() => opts.enabled.current, (enabled) => {
+			if (enabled) {
+				globalThis.bitsEscapeLayers.set(this, opts.escapeKeydownBehavior);
+				unsubEvents = this.#addEventListener();
+			}
+			return () => {
+				unsubEvents();
+				globalThis.bitsEscapeLayers.delete(this);
+			};
+		});
+	}
+	#addEventListener = () => {
+		return on(this.domContext.getDocument(), "keydown", this.#onkeydown, { passive: false });
+	};
+	#onkeydown = (e) => {
+		if (e.key !== "Escape" || !isResponsibleEscapeLayer(this)) return;
+		const clonedEvent = new KeyboardEvent(e.type, e);
+		e.preventDefault();
+		const behaviorType = this.opts.escapeKeydownBehavior.current;
+		if (behaviorType !== "close" && behaviorType !== "defer-otherwise-close") return;
+		this.opts.onEscapeKeydown.current(clonedEvent);
+	};
+};
+function isResponsibleEscapeLayer(instance) {
+	const layersArr = [...globalThis.bitsEscapeLayers];
+	/**
+	* We first check if we can find a top layer with `close` or `ignore`.
+	* If that top layer was found and matches the provided node, then the node is
+	* responsible for the escape. Otherwise, we know that all layers defer so
+	* the first layer is the responsible one.
+	*/
+	const topMostLayer = layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+	if (topMostLayer) return topMostLayer[0] === instance;
+	const [firstLayerNode] = layersArr[0];
+	return firstLayerNode === instance;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/escape-layer/escape-layer.svelte
+function Escape_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { escapeKeydownBehavior = "close", onEscapeKeydown = noop, children, enabled, ref } = $$props;
+		EscapeLayerState.create({
+			escapeKeydownBehavior: boxWith(() => escapeKeydownBehavior),
+			onEscapeKeydown: boxWith(() => onEscapeKeydown),
+			enabled: boxWith(() => enabled),
+			ref
+		});
+		children?.($$renderer);
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/focus-scope/focus-scope-manager.js
+var FocusScopeManager = class FocusScopeManager {
+	static instance;
+	#scopeStack = simpleBox([]);
+	#focusHistory = /* @__PURE__ */ new WeakMap();
+	#preFocusHistory = /* @__PURE__ */ new WeakMap();
+	static getInstance() {
+		if (!this.instance) this.instance = new FocusScopeManager();
+		return this.instance;
+	}
+	register(scope) {
+		const current = this.getActive();
+		if (current && current !== scope) current.pause();
+		const activeElement = document.activeElement;
+		if (activeElement && activeElement !== document.body) this.#preFocusHistory.set(scope, activeElement);
+		this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+		this.#scopeStack.current.unshift(scope);
+	}
+	unregister(scope) {
+		this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+		const next = this.getActive();
+		if (next) next.resume();
+	}
+	getActive() {
+		return this.#scopeStack.current[0];
+	}
+	setFocusMemory(scope, element) {
+		this.#focusHistory.set(scope, element);
+	}
+	getFocusMemory(scope) {
+		return this.#focusHistory.get(scope);
+	}
+	isActiveScope(scope) {
+		return this.getActive() === scope;
+	}
+	setPreFocusMemory(scope, element) {
+		this.#preFocusHistory.set(scope, element);
+	}
+	getPreFocusMemory(scope) {
+		return this.#preFocusHistory.get(scope);
+	}
+	clearPreFocusMemory(scope) {
+		this.#preFocusHistory.delete(scope);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tabbable@6.5.0/node_modules/tabbable/dist/index.esm.js
+/*!
+* tabbable 6.5.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var candidateSelectors = [
+	"input:not([inert]):not([inert] *)",
+	"select:not([inert]):not([inert] *)",
+	"textarea:not([inert]):not([inert] *)",
+	"a[href]:not([inert]):not([inert] *)",
+	"area[href]:not([inert]):not([inert] *)",
+	"button:not([inert]):not([inert] *)",
+	"[tabindex]:not(slot):not([inert]):not([inert] *)",
+	"audio[controls]:not([inert]):not([inert] *)",
+	"video[controls]:not([inert]):not([inert] *)",
+	"[contenteditable]:not([contenteditable=\"false\"]):not([inert]):not([inert] *)",
+	"details>summary:first-of-type:not([inert]):not([inert] *)",
+	"details:not([inert]):not([inert] *)"
+];
+var candidateSelector = /* #__PURE__ */ candidateSelectors.join(",");
+var NoElement = typeof Element === "undefined";
+var matches = NoElement ? function() {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+	var _element$getRootNode;
+	return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+} : function(element) {
+	return element === null || element === void 0 ? void 0 : element.ownerDocument;
+};
+/**
+* Determines if a node is inert or in an inert ancestor.
+* @param {Node} [node]
+* @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
+*  see if any of them are inert. If false, only `node` itself is considered.
+* @returns {boolean} True if inert itself or by way of being in an inert ancestor.
+*  False if `node` is falsy.
+*/
+var _isInert = function isInert(node, lookUp) {
+	var _node$getAttribute;
+	if (lookUp === void 0) lookUp = true;
+	var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
+	return inertAtt === "" || inertAtt === "true" || lookUp && node && (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
+};
+/**
+* Determines if a node's content is editable.
+* @param {Element} [node]
+* @returns True if it's content-editable; false if it's not or `node` is falsy.
+*/
+var isContentEditable = function isContentEditable(node) {
+	var _node$getAttribute2;
+	var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+	return attValue === "" || attValue === "true";
+};
+/**
+* @param {Element} el container to check in
+* @param {boolean} includeContainer add container to check
+* @param {(node: Element) => boolean} filter filter candidates
+* @returns {Element[]}
+*/
+var getCandidates = function getCandidates(el, includeContainer, filter) {
+	if (_isInert(el)) return [];
+	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
+	candidates = candidates.filter(filter);
+	return candidates;
+};
+/**
+* @callback GetShadowRoot
+* @param {Element} element to check for shadow root
+* @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
+*/
+/**
+* @callback ShadowRootFilter
+* @param {Element} shadowHostNode the element which contains shadow content
+* @returns {boolean} true if a shadow root could potentially contain valid candidates.
+*/
+/**
+* @typedef {Object} CandidateScope
+* @property {Element} scopeParent contains inner candidates
+* @property {Element[]} candidates list of candidates found in the scope parent
+*/
+/**
+* @typedef {Object} IterativeOptions
+* @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
+*  if a function, implies shadow support is enabled and either returns the shadow root of an element
+*  or a boolean stating if it has an undisclosed shadow root
+* @property {(node: Element) => boolean} filter filter candidates
+* @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list
+* @property {ShadowRootFilter} shadowRootFilter filter shadow roots;
+*/
+/**
+* @param {Element[]} elements list of element containers to match candidates from
+* @param {boolean} includeContainer add container list to check
+* @param {IterativeOptions} options
+* @returns {Array.<Element|CandidateScope>}
+*/
+var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+	var candidates = [];
+	var elementsToCheck = Array.from(elements);
+	while (elementsToCheck.length) {
+		var element = elementsToCheck.shift();
+		if (_isInert(element, false)) continue;
+		if (element.tagName === "SLOT") {
+			var assigned = element.assignedElements();
+			var nestedCandidates = _getCandidatesIteratively(assigned.length ? assigned : element.children, true, options);
+			if (options.flatten) candidates.push.apply(candidates, nestedCandidates);
+			else candidates.push({
+				scopeParent: element,
+				candidates: nestedCandidates
+			});
+		} else {
+			if (matches.call(element, candidateSelector) && options.filter(element) && (includeContainer || !elements.includes(element))) candidates.push(element);
+			var shadowRoot = element.shadowRoot || typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+			var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+			if (shadowRoot && validShadowRoot) {
+				var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+				if (options.flatten) candidates.push.apply(candidates, _nestedCandidates);
+				else candidates.push({
+					scopeParent: element,
+					candidates: _nestedCandidates
+				});
+			} else elementsToCheck.unshift.apply(elementsToCheck, element.children);
+		}
+	}
+	return candidates;
+};
+/**
+* @private
+* Determines if the node has an explicitly specified `tabindex` attribute.
+* @param {HTMLElement} node
+* @returns {boolean} True if so; false if not.
+*/
+var hasTabIndex = function hasTabIndex(node) {
+	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+/**
+* Determine the tab index of a given node.
+* @param {HTMLElement} node
+* @returns {number} Tab order (negative, 0, or positive number).
+* @throws {Error} If `node` is falsy.
+*/
+var getTabIndex = function getTabIndex(node) {
+	if (!node) throw new Error("No node provided");
+	if (node.tabIndex < 0) {
+		if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+};
+/**
+* Determine the tab index of a given node __for sort order purposes__.
+* @param {HTMLElement} node
+* @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,
+*  has tabIndex -1, but needs to be sorted by document order in order for its content to be
+*  inserted into the correct sort position.
+* @returns {number} Tab order (negative, 0, or positive number).
+*/
+var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {
+	var tabIndex = getTabIndex(node);
+	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
+	return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
+	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput(node) {
+	return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput(node) {
+	return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary(node) {
+	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+		return child.tagName === "SUMMARY";
+	});
+};
+var getCheckedRadio = function getCheckedRadio(nodes, form) {
+	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
+};
+var isTabbableRadio = function isTabbableRadio(node) {
+	if (!node.name) return true;
+	var radioScope = node.form || getRootNode(node);
+	var queryRadios = function queryRadios(name) {
+		return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
+	};
+	var radioSet;
+	if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") radioSet = queryRadios(window.CSS.escape(node.name));
+	else try {
+		radioSet = queryRadios(node.name);
+	} catch (err) {
+		console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+		return false;
+	}
+	var checked = getCheckedRadio(radioSet, node.form);
+	return !checked || checked === node;
+};
+var isRadio = function isRadio(node) {
+	return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio(node) {
+	return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached(node) {
+	var _nodeRoot;
+	var nodeRoot = node && getRootNode(node);
+	var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+	var attached = false;
+	if (nodeRoot && nodeRoot !== node) {
+		var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+		attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+		while (!attached && nodeRootHost) {
+			var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+			nodeRoot = getRootNode(nodeRootHost);
+			nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+			attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+		}
+	}
+	return attached;
+};
+var isZeroArea = function isZeroArea(node) {
+	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+	return width === 0 && height === 0;
+};
+var isHidden = function isHidden(node, _ref) {
+	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+	if (displayCheck === "full-native") {
+		if ("checkVisibility" in node) return !node.checkVisibility({
+			checkOpacity: false,
+			opacityProperty: false,
+			contentVisibilityAuto: true,
+			visibilityProperty: true,
+			checkVisibilityCSS: true
+		});
+	}
+	var visibility = getComputedStyle(node).visibility;
+	if (visibility === "hidden" || visibility === "collapse") return true;
+	var nodeUnderDetails = matches.call(node, "details>summary:first-of-type") ? node.parentElement : node;
+	if (matches.call(nodeUnderDetails, "details:not([open]) *")) return true;
+	if (!displayCheck || displayCheck === "full" || displayCheck === "full-native" || displayCheck === "legacy-full") {
+		if (typeof getShadowRoot === "function") {
+			var originalNode = node;
+			while (node) {
+				var parentElement = node.parentElement;
+				var rootNode = getRootNode(node);
+				if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) return isZeroArea(node);
+				else if (node.assignedSlot) node = node.assignedSlot;
+				else if (!parentElement && rootNode !== node.ownerDocument) node = rootNode.host;
+				else node = parentElement;
+			}
+			node = originalNode;
+		}
+		if (isNodeAttached(node)) return !node.getClientRects().length;
+		if (displayCheck !== "legacy-full") return true;
+	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
+	return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
+	if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+		var parentNode = node.parentElement;
+		while (parentNode) {
+			if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+				for (var i = 0; i < parentNode.children.length; i++) {
+					var child = parentNode.children.item(i);
+					if (child.tagName === "LEGEND") return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+				}
+				return true;
+			}
+			parentNode = parentNode.parentElement;
+		}
+	}
+	return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
+	if (node.disabled || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
+	return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
+	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
+	return true;
+};
+var isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {
+	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+	if (isNaN(tabIndex) || tabIndex >= 0) return true;
+	return false;
+};
+/**
+* @param {Array.<Element|CandidateScope>} candidates
+* @returns Element[]
+*/
+var _sortByOrder = function sortByOrder(candidates) {
+	var regularTabbables = [];
+	var orderedTabbables = [];
+	candidates.forEach(function(item, i) {
+		var isScope = !!item.scopeParent;
+		var element = isScope ? item.scopeParent : item;
+		var candidateTabindex = getSortOrderTabIndex(element, isScope);
+		var elements = isScope ? _sortByOrder(item.candidates) : element;
+		if (candidateTabindex === 0) isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+		else orderedTabbables.push({
+			documentOrder: i,
+			tabIndex: candidateTabindex,
+			item,
+			isScope,
+			content: elements
+		});
+	});
+	return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+		sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+		return acc;
+	}, []).concat(regularTabbables);
+};
+var tabbable = function tabbable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorTabbable.bind(null, options),
+		flatten: false,
+		getShadowRoot: options.getShadowRoot,
+		shadowRootFilter: isShadowRootTabbable
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+	return _sortByOrder(candidates);
+};
+var focusable = function focusable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorFocusable.bind(null, options),
+		flatten: true,
+		getShadowRoot: options.getShadowRoot
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+	return candidates;
+};
+var isTabbable = function isTabbable(node, options) {
+	options = options || {};
+	if (!node) throw new Error("No node provided");
+	if (matches.call(node, candidateSelector) === false) return false;
+	return isNodeMatchingSelectorTabbable(options, node);
+};
+var focusableCandidateSelector = /* #__PURE__ */ candidateSelectors.concat("iframe:not([inert]):not([inert] *)").join(",");
+var isFocusable = function isFocusable(node, options) {
+	options = options || {};
+	if (!node) throw new Error("No node provided");
+	if (matches.call(node, focusableCandidateSelector) === false) return false;
+	return isNodeMatchingSelectorFocusable(options, node);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/focus-scope/focus-scope.svelte.js
+var FocusScope = class FocusScope {
+	#paused = false;
+	#container = null;
+	#manager = FocusScopeManager.getInstance();
+	#cleanupFns = [];
+	#opts;
+	constructor(opts) {
+		this.#opts = opts;
+	}
+	get paused() {
+		return this.#paused;
+	}
+	pause() {
+		this.#paused = true;
+	}
+	resume() {
+		this.#paused = false;
+	}
+	#cleanup() {
+		for (const fn of this.#cleanupFns) fn();
+		this.#cleanupFns = [];
+	}
+	mount(container) {
+		if (this.#container) this.unmount();
+		this.#container = container;
+		this.#manager.register(this);
+		this.#setupEventListeners();
+		this.#handleOpenAutoFocus();
+	}
+	unmount() {
+		if (!this.#container) return;
+		this.#cleanup();
+		this.#handleCloseAutoFocus();
+		this.#manager.unregister(this);
+		this.#manager.clearPreFocusMemory(this);
+		this.#container = null;
+	}
+	#handleOpenAutoFocus() {
+		if (!this.#container) return;
+		const event = new CustomEvent("focusScope.onOpenAutoFocus", {
+			bubbles: false,
+			cancelable: true
+		});
+		this.#opts.onOpenAutoFocus.current(event);
+		if (!event.defaultPrevented) requestAnimationFrame(() => {
+			if (!this.#container || this.#paused || !this.#manager.isActiveScope(this) || this.#container.contains(this.#container.ownerDocument.activeElement)) return;
+			const firstTabbable = this.#getFirstTabbable();
+			if (firstTabbable) {
+				firstTabbable.focus();
+				this.#manager.setFocusMemory(this, firstTabbable);
+			} else this.#container.focus();
+		});
+	}
+	#handleCloseAutoFocus() {
+		const event = new CustomEvent("focusScope.onCloseAutoFocus", {
+			bubbles: false,
+			cancelable: true
+		});
+		this.#opts.onCloseAutoFocus.current?.(event);
+		if (!event.defaultPrevented) {
+			const preFocusedElement = this.#manager.getPreFocusMemory(this);
+			if (preFocusedElement && document.contains(preFocusedElement)) try {
+				preFocusedElement.focus();
+			} catch {
+				document.body.focus();
+			}
+		}
+	}
+	#setupEventListeners() {
+		if (!this.#container || !this.#opts.trap.current) return;
+		const container = this.#container;
+		const doc = container.ownerDocument;
+		const handleFocus = (e) => {
+			if (this.#paused || !this.#manager.isActiveScope(this)) return;
+			const target = e.target;
+			if (!target) return;
+			if (container.contains(target)) this.#manager.setFocusMemory(this, target);
+			else {
+				const lastFocused = this.#manager.getFocusMemory(this);
+				if (lastFocused && container.contains(lastFocused) && isFocusable(lastFocused)) {
+					e.preventDefault();
+					lastFocused.focus();
+				} else {
+					const firstTabbable = this.#getFirstTabbable();
+					const firstFocusable = this.#getAllFocusables()[0];
+					(firstTabbable || firstFocusable || container).focus();
+				}
+			}
+		};
+		const handleKeydown = (e) => {
+			if (!this.#opts.loop || this.#paused || e.key !== "Tab") return;
+			if (!this.#manager.isActiveScope(this)) return;
+			const tabbables = this.#getTabbables();
+			if (tabbables.length === 0) return;
+			const first = tabbables[0];
+			const last = tabbables[tabbables.length - 1];
+			if (!e.shiftKey && doc.activeElement === last) {
+				e.preventDefault();
+				first.focus();
+			} else if (e.shiftKey && doc.activeElement === first) {
+				e.preventDefault();
+				last.focus();
+			}
+		};
+		this.#cleanupFns.push(on(doc, "focusin", handleFocus, { capture: true }), on(container, "keydown", handleKeydown));
+		const observer = new MutationObserver(() => {
+			const lastFocused = this.#manager.getFocusMemory(this);
+			if (lastFocused && !container.contains(lastFocused)) {
+				const firstTabbable = this.#getFirstTabbable();
+				const firstFocusable = this.#getAllFocusables()[0];
+				const elementToFocus = firstTabbable || firstFocusable;
+				if (elementToFocus) {
+					elementToFocus.focus();
+					this.#manager.setFocusMemory(this, elementToFocus);
+				} else container.focus();
+			}
+		});
+		observer.observe(container, {
+			childList: true,
+			subtree: true
+		});
+		this.#cleanupFns.push(() => observer.disconnect());
+	}
+	#getTabbables() {
+		if (!this.#container) return [];
+		return tabbable(this.#container, {
+			includeContainer: false,
+			getShadowRoot: true
+		});
+	}
+	#getFirstTabbable() {
+		return this.#getTabbables()[0] || null;
+	}
+	#getAllFocusables() {
+		if (!this.#container) return [];
+		return focusable(this.#container, {
+			includeContainer: false,
+			getShadowRoot: true
+		});
+	}
+	static use(opts) {
+		let scope = null;
+		watch([() => opts.ref.current, () => opts.enabled.current], ([ref, enabled]) => {
+			if (ref && enabled) {
+				if (!scope) scope = new FocusScope(opts);
+				scope.mount(ref);
+			} else if (scope) {
+				scope.unmount();
+				scope = null;
+			}
+		});
+		return { get props() {
+			return { tabindex: -1 };
+		} };
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/focus-scope/focus-scope.svelte
+function Focus_scope($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { enabled = false, trapFocus = false, loop = false, onCloseAutoFocus = noop, onOpenAutoFocus = noop, focusScope, ref } = $$props;
+		const focusScopeState = FocusScope.use({
+			enabled: boxWith(() => enabled),
+			trap: boxWith(() => trapFocus),
+			loop,
+			onCloseAutoFocus: boxWith(() => onCloseAutoFocus),
+			onOpenAutoFocus: boxWith(() => onOpenAutoFocus),
+			ref
+		});
+		focusScope?.($$renderer, { props: focusScopeState.props });
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/text-selection-layer/use-text-selection-layer.svelte.js
+var noopPointer = () => {};
+globalThis.bitsTextSelectionLayers ??= /* @__PURE__ */ new Map();
+var TextSelectionLayerState = class TextSelectionLayerState {
+	static create(opts) {
+		return new TextSelectionLayerState(opts);
+	}
+	opts;
+	domContext;
+	#unsubSelectionLock = noop;
+	#enabledSnapshot = false;
+	#onPointerDownSnapshot = noopPointer;
+	#onPointerUpSnapshot = noopPointer;
+	constructor(opts) {
+		this.opts = opts;
+		this.domContext = new DOMContext(opts.ref);
+		let unsubEvents = noop;
+		watch(() => [
+			this.opts.enabled.current,
+			this.opts.onPointerDown.current,
+			this.opts.onPointerUp.current
+		], ([enabled, onPointerDown, onPointerUp]) => {
+			this.#enabledSnapshot = enabled;
+			this.#onPointerDownSnapshot = onPointerDown;
+			this.#onPointerUpSnapshot = onPointerUp;
+			if (enabled) {
+				globalThis.bitsTextSelectionLayers.set(this, this.opts.enabled);
+				unsubEvents();
+				unsubEvents = this.#addEventListeners();
+			}
+			return () => {
+				this.#enabledSnapshot = false;
+				unsubEvents();
+				this.#resetSelectionLock();
+				globalThis.bitsTextSelectionLayers.delete(this);
+			};
+		});
+	}
+	#addEventListeners() {
+		return executeCallbacks(on(this.domContext.getDocument(), "pointerdown", this.#pointerdown), on(this.domContext.getDocument(), "pointerup", this.#pointerup));
+	}
+	#pointerup = (e) => {
+		this.#resetSelectionLock();
+		if (e.defaultPrevented) return;
+		this.#onPointerUpSnapshot(e);
+	};
+	#pointerdown = (e) => {
+		if (!this.#enabledSnapshot) return;
+		this.#resetSelectionLock();
+		const node = this.opts.ref.current;
+		const target = e.target;
+		if (!isHTMLElement(node) || !isHTMLElement(target)) return;
+		/**
+		* We only lock user-selection overflow if layer is the top most layer and
+		* pointerdown occurred inside the node. You are still allowed to select text
+		* outside the node provided pointerdown occurs outside the node.
+		*/
+		if (!isHighestLayer(this) || !contains(node, target)) return;
+		this.#onPointerDownSnapshot(e);
+		if (e.defaultPrevented) return;
+		this.#unsubSelectionLock = preventTextSelectionOverflow(node, this.domContext.getDocument().body);
+	};
+	#resetSelectionLock = () => {
+		this.#unsubSelectionLock();
+		this.#unsubSelectionLock = noop;
+	};
+};
+var getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
+function preventTextSelectionOverflow(node, body) {
+	const originalBodyUserSelect = getUserSelect(body);
+	const originalNodeUserSelect = getUserSelect(node);
+	setUserSelect(body, "none");
+	setUserSelect(node, "text");
+	return () => {
+		setUserSelect(body, originalBodyUserSelect);
+		setUserSelect(node, originalNodeUserSelect);
+	};
+}
+function setUserSelect(node, value) {
+	node.style.userSelect = value;
+	node.style.webkitUserSelect = value;
+}
+function isHighestLayer(instance) {
+	const layersArr = [...globalThis.bitsTextSelectionLayers];
+	if (!layersArr.length) return false;
+	const highestLayer = layersArr.at(-1);
+	if (!highestLayer) return false;
+	return highestLayer[0] === instance;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/text-selection-layer/text-selection-layer.svelte
+function Text_selection_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { preventOverflowTextSelection = true, onPointerDown = noop, onPointerUp = noop, id, children, enabled, ref } = $$props;
+		TextSelectionLayerState.create({
+			id: boxWith(() => id),
+			onPointerDown: boxWith(() => onPointerDown),
+			onPointerUp: boxWith(() => onPointerUp),
+			enabled: boxWith(() => enabled && preventOverflowTextSelection),
+			ref
+		});
+		children?.($$renderer);
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/use-id.js
+globalThis.bitsIdCounter ??= { current: 0 };
+/**
+* Generates a unique ID based on a global counter.
+*/
+function useId(prefix = "bits") {
+	globalThis.bitsIdCounter.current++;
+	return `${prefix}-${globalThis.bitsIdCounter.current}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/shared-state.svelte.js
+var SharedState = class {
+	#factory;
+	#subscribers = 0;
+	#state;
+	#scope;
+	constructor(factory) {
+		this.#factory = factory;
+	}
+	#dispose() {
+		this.#subscribers -= 1;
+		if (this.#scope && this.#subscribers <= 0) {
+			this.#scope();
+			this.#state = void 0;
+			this.#scope = void 0;
+		}
+	}
+	get(...args) {
+		this.#subscribers += 1;
+		if (this.#state === void 0) this.#scope = () => {};
+		return this.#state;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/internal/body-scroll-lock.svelte.js
+var lockMap = new SvelteMap();
+var initialBodyStyle = null;
+var cleanupTimeoutId = null;
+var isInCleanupTransition = false;
+var anyLocked = boxWith(() => {
+	for (const value of lockMap.values()) if (value) return true;
+	return false;
+});
+/**
+* We track the time we scheduled the cleanup to prevent race conditions
+* when multiple locks are created/destroyed in the same tick, ensuring
+* only the last one to schedule the cleanup will run.
+*
+* reference: https://github.com/huntabyte/bits-ui/issues/1639
+*/
+var cleanupScheduledAt = null;
+var bodyLockStackCount = new SharedState(() => {
+	function resetBodyStyle(documentObj) {}
+	function cancelPendingCleanup() {
+		if (cleanupTimeoutId === null) return;
+		window.clearTimeout(cleanupTimeoutId);
+		cleanupTimeoutId = null;
+	}
+	function scheduleCleanupIfNoNewLocks(delay, callback) {
+		cancelPendingCleanup();
+		isInCleanupTransition = true;
+		cleanupScheduledAt = Date.now();
+		const currentCleanupId = cleanupScheduledAt;
+		/**
+		* We schedule the cleanup to run after a delay to allow new locks to register
+		* that might have been added in the same tick as the current cleanup.
+		*
+		* If a new lock is added in the same tick, the cleanup will be cancelled and
+		* a new cleanup will be scheduled.
+		*
+		* This is to prevent the cleanup from running too early and resetting the body
+		* style before the new lock has had a chance to apply its styles.
+		*/
+		const cleanupFn = () => {
+			cleanupTimeoutId = null;
+			if (cleanupScheduledAt !== currentCleanupId) return;
+			if (!isAnyLocked(lockMap)) {
+				isInCleanupTransition = false;
+				callback();
+			} else isInCleanupTransition = false;
+		};
+		const actualDelay = delay === null ? 24 : delay;
+		cleanupTimeoutId = window.setTimeout(cleanupFn, actualDelay);
+	}
+	function ensureInitialStyleCaptured() {
+		if (initialBodyStyle === null && lockMap.size === 0 && !isInCleanupTransition) initialBodyStyle = document.body.getAttribute("style");
+	}
+	watch(() => anyLocked.current, () => {
+		if (!anyLocked.current) return;
+		ensureInitialStyleCaptured();
+		isInCleanupTransition = false;
+		const htmlStyle = getComputedStyle(document.documentElement);
+		const bodyStyle = getComputedStyle(document.body);
+		const hasStableGutter = htmlStyle.scrollbarGutter?.includes("stable") || bodyStyle.scrollbarGutter?.includes("stable");
+		const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+		const config = {
+			padding: Number.parseInt(bodyStyle.paddingRight ?? "0", 10) + verticalScrollbarWidth,
+			margin: Number.parseInt(bodyStyle.marginRight ?? "0", 10)
+		};
+		if (verticalScrollbarWidth > 0 && !hasStableGutter) {
+			document.body.style.paddingRight = `${config.padding}px`;
+			document.body.style.marginRight = `${config.margin}px`;
+			document.body.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+		}
+		document.body.style.overflow = "hidden";
+		if (isIOS) on(document, "touchmove", (e) => {
+			if (e.target !== document.documentElement) return;
+			if (e.touches.length > 1) return;
+			e.preventDefault();
+		}, { passive: false });
+		/**
+		* We ensure pointer-events: none is applied _after_ DOM updates, so that any focus/
+		* interaction changes from opening overlays/menus complete _before_ we block pointer
+		* events.
+		*
+		* this avoids race conditions where pointer-events could be set too early and break
+		* focus/interaction.
+		*/
+		afterTick(() => {
+			document.body.style.pointerEvents = "none";
+			document.body.style.overflow = "hidden";
+		});
+	});
+	return {
+		get lockMap() {
+			return lockMap;
+		},
+		resetBodyStyle,
+		scheduleCleanupIfNoNewLocks,
+		cancelPendingCleanup,
+		ensureInitialStyleCaptured
+	};
+});
+var BodyScrollLock = class {
+	#id = useId();
+	#initialState;
+	#restoreScrollDelay = () => null;
+	#countState;
+	locked;
+	constructor(initialState, restoreScrollDelay = () => null) {
+		this.#initialState = initialState;
+		this.#restoreScrollDelay = restoreScrollDelay;
+		this.#countState = bodyLockStackCount.get();
+		if (!this.#countState) return;
+		/**
+		* Since a new lock is being created, we cancel any pending cleanup to
+		* prevent the cleanup from running too early and resetting the body style
+		* before the new lock has had a chance to apply its styles.
+		*
+		* reference: https://github.com/huntabyte/bits-ui/issues/1639
+		*/
+		this.#countState.cancelPendingCleanup();
+		this.#countState.ensureInitialStyleCaptured();
+		this.#countState.lockMap.set(this.#id, this.#initialState ?? false);
+		this.locked = boxWith(() => this.#countState.lockMap.get(this.#id) ?? false, (v) => this.#countState.lockMap.set(this.#id, v));
+	}
+};
+function isAnyLocked(map) {
+	for (const [_, value] of map) if (value) return true;
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/scroll-lock/scroll-lock.svelte
+function Scroll_lock($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { preventScroll = true, restoreScrollDelay = null } = $$props;
+		if (preventScroll) new BodyScrollLock(preventScroll, () => restoreScrollDelay);
+	});
+}
+
+export { ARROW_DOWN as A, isSelectableInput as B, Context as C, Dismissible_layer as D, Escape_layer as E, Focus_scope as F, ENTER as G, HOME as H, IsMounted as I, PresenceManager as P, Scroll_lock as S, Text_selection_layer as T, Portal as a, afterTick as b, DOMContext as c, PAGE_UP as d, ARROW_UP as e, PAGE_DOWN as f, ElementSize as g, getWindow as h, isNotNull as i, Previous as j, isIOS as k, isHTMLElement as l, ARROW_RIGHT as m, noop as n, ARROW_LEFT as o, useDebounce as p, AnimationsComplete as q, isElement as r, isTabbable as s, isElementOrSVGElement as t, useId as u, getDocument as v, watch as w, tabbable as x, isFocusable as y, focusable as z };
+//# sourceMappingURL=scroll-lock.js-DCKuvkpD.js.map