@selvajs/selva 4.20.0-beta.15 → 4.20.0-beta.16

package/build/server/chunks/chunks/FilterableDropdown.js-COxcZtMW.js

@@ -0,0 +1,2722 @@
+import { aw as bind_props, al as spread_props, ay as props_id, ao as attributes, ah as derived, aq as attr_class, ap as clsx$1, as as escape_html, aB as snapshot, an as ensure_array_like, ai as attr } from './server.js-D3MqDbVt.js';
+import { o as on } from './events.js-IByrOSdq.js';
+import { n as createBitsAttrs, b as boxWith, q as createId, c as attachRef, l as getDataOpenClosed, r as boolToStr, m as mergeProps, o as getDataTransitionAttrs, p as boolToEmptyStrOrUndef } from './create-id.js-alvgun-Y.js';
+import { c as cn } from './utils3.js-DANle-lS.js';
+import { b as buttonVariants } from './button.js-BtRm7eTa.js';
+import { F as Floating_layer, a as Floating_layer_anchor, P as Popper_layer_force_mount, b as Popper_layer, g as getFloatingContentCSSVars, C as Check } from './popper-layer-force-mount.js-CP6hayn4.js';
+import { C as Chevron_down } from './chevron-down.js-D8rHJiBK.js';
+import { S as Search } from './search.js-5cmK2jkz.js';
+import { s as srOnlyStyles } from './sr-only-styles.js-CgNXGZ9C.js';
+import { n as noop, C as Context, P as PresenceManager, w as watch, f as Portal, j as DOMContext, K as isTouch, l as isElement, m as isTabbable, r as getDocument, k as afterTick, L as getFirstNonCommentChild, y as ENTER, H as HOME, d as ARROW_LEFT, e as ARROW_UP, A as ARROW_RIGHT, c as ARROW_DOWN } from './scroll-lock.js-By--_Rp9.js';
+import { g as afterSleep } from './alert-dialog.js-BG8Wa5yR.js';
+import { I as Input_group, a as Input_group_input } from './input-group.js-DhqokDEu.js';
+import { tv } from 'tailwind-variants';
+
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/utils.js
+function findNextSibling(el, selector) {
+	let sibling = el.nextElementSibling;
+	while (sibling) {
+		if (sibling.matches(selector)) return sibling;
+		sibling = sibling.nextElementSibling;
+	}
+}
+function findPreviousSibling(el, selector) {
+	let sibling = el.previousElementSibling;
+	while (sibling) {
+		if (sibling.matches(selector)) return sibling;
+		sibling = sibling.previousElementSibling;
+	}
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/internal/css-escape.js
+/**
+* https://github.com/mathiasbynens/CSS.escape
+*
+* @param value - The value to escape for use as a CSS identifier
+* @returns The escaped CSS identifier string
+*/
+function cssEscape(value) {
+	if (typeof CSS !== "undefined" && typeof CSS.escape === "function") return CSS.escape(value);
+	const length = value.length;
+	let index = -1;
+	let codeUnit;
+	let result = "";
+	const firstCodeUnit = value.charCodeAt(0);
+	if (length === 1 && firstCodeUnit === 45) return "\\" + value;
+	while (++index < length) {
+		codeUnit = value.charCodeAt(index);
+		if (codeUnit === 0) {
+			result += "�";
+			continue;
+		}
+		if (codeUnit >= 1 && codeUnit <= 31 || codeUnit === 127 || index === 0 && codeUnit >= 48 && codeUnit <= 57 || index === 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit === 45) {
+			result += "\\" + codeUnit.toString(16) + " ";
+			continue;
+		}
+		if (codeUnit >= 128 || codeUnit === 45 || codeUnit === 95 || codeUnit >= 48 && codeUnit <= 57 || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122) {
+			result += value.charAt(index);
+			continue;
+		}
+		result += "\\" + value.charAt(index);
+	}
+	return result;
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/command.svelte.js
+var COMMAND_VALUE_ATTR = "data-value";
+var commandAttrs = createBitsAttrs({
+	component: "command",
+	parts: [
+		"root",
+		"list",
+		"input",
+		"separator",
+		"loading",
+		"empty",
+		"group",
+		"group-items",
+		"group-heading",
+		"item",
+		"viewport",
+		"input-label"
+	]
+});
+var COMMAND_GROUP_SELECTOR = commandAttrs.selector("group");
+var COMMAND_GROUP_ITEMS_SELECTOR = commandAttrs.selector("group-items");
+var COMMAND_GROUP_HEADING_SELECTOR = commandAttrs.selector("group-heading");
+var COMMAND_ITEM_SELECTOR = commandAttrs.selector("item");
+var COMMAND_VALID_ITEM_SELECTOR = `${commandAttrs.selector("item")}:not([aria-disabled="true"])`;
+var CommandRootContext = new Context("Command.Root");
+var CommandListContext = new Context("Command.List");
+var CommandGroupContainerContext = new Context("Command.Group");
+var defaultState = {
+	search: "",
+	value: "",
+	filtered: {
+		count: 0,
+		items: /* @__PURE__ */ new Map(),
+		groups: /* @__PURE__ */ new Set()
+	}
+};
+var CommandRootState = class CommandRootState {
+	static create(opts) {
+		return CommandRootContext.set(new CommandRootState(opts));
+	}
+	opts;
+	attachment;
+	#updateScheduled = false;
+	#isInitialMount = true;
+	#isDestroyed = false;
+	sortAfterTick = false;
+	sortAndFilterAfterTick = false;
+	allItems = /* @__PURE__ */ new Set();
+	allGroups = /* @__PURE__ */ new Map();
+	allIds = /* @__PURE__ */ new Map();
+	key = 0;
+	viewportNode = null;
+	inputNode = null;
+	labelNode = null;
+	commandState = defaultState;
+	_commandState = defaultState;
+	#snapshot() {
+		return snapshot(this._commandState);
+	}
+	/** `afterTick` that skips `fn` if the root was destroyed in the meantime. */
+	#afterTick(fn) {
+		afterTick(() => {
+			if (this.#isDestroyed) return;
+			fn();
+		});
+	}
+	#scheduleUpdate() {
+		if (this.#updateScheduled) return;
+		this.#updateScheduled = true;
+		this.#afterTick(() => {
+			this.#updateScheduled = false;
+			const currentState = this.#snapshot();
+			if (!Object.is(this.commandState, currentState)) {
+				this.commandState = currentState;
+				this.opts.onStateChange?.current?.(currentState);
+			}
+		});
+	}
+	setState(key, value, preventScroll) {
+		if (Object.is(this._commandState[key], value)) return;
+		this._commandState[key] = value;
+		if (key === "search") {
+			this.#filterItems();
+			this.#sort({ forceSelectFirst: !this.#isInitialMount });
+		} else if (key === "value") {
+			if (!preventScroll) this.#scrollSelectedIntoView();
+		}
+		this.#scheduleUpdate();
+	}
+	constructor(opts) {
+		this.opts = opts;
+		this.attachment = attachRef(this.opts.ref);
+		const defaults = {
+			...this._commandState,
+			value: this.opts.value.current ?? ""
+		};
+		this._commandState = defaults;
+		this.commandState = defaults;
+		this.onkeydown = this.onkeydown.bind(this);
+	}
+	/**
+	* Calculates score for an item based on search text and keywords.
+	* Higher score = better match.
+	*
+	* @param value - Item's display text
+	* @param keywords - Optional keywords to boost scoring
+	* @returns Score from 0-1, where 0 = no match
+	*/
+	#score(value, keywords) {
+		const filter = this.opts.filter.current ?? computeCommandScore;
+		return value ? filter(value, this._commandState.search, keywords) : 0;
+	}
+	/**
+	* Sorts items and groups based on search scores.
+	* Groups are sorted by their highest scoring item.
+	* When no search is active, preserves the current item unless a reset is requested.
+	*/
+	#sort(opts = {}) {
+		if (!this._commandState.search || this.opts.shouldFilter.current === false) {
+			if (!this._commandState.value || opts.forceSelectFirst) this.#selectFirstItem();
+			else if (this.#isInitialMount && this._commandState.value) this.#scrollInitialValue();
+			return;
+		}
+		const scores = this._commandState.filtered.items;
+		const groups = [];
+		for (const value of this._commandState.filtered.groups) {
+			const items = this.allGroups.get(value);
+			let max = 0;
+			if (!items) {
+				groups.push([value, max]);
+				continue;
+			}
+			for (const item of items) {
+				const score = scores.get(item);
+				max = Math.max(score ?? 0, max);
+			}
+			groups.push([value, max]);
+		}
+		const listInsertionElement = this.viewportNode;
+		const sorted = this.getValidItems().sort((a, b) => {
+			const valueA = a.getAttribute("data-value");
+			const valueB = b.getAttribute("data-value");
+			const scoresA = scores.get(valueA) ?? 0;
+			return (scores.get(valueB) ?? 0) - scoresA;
+		});
+		for (const item of sorted) {
+			const group = item.closest(COMMAND_GROUP_ITEMS_SELECTOR);
+			if (group) {
+				const itemToAppend = item.parentElement === group ? item : item.closest(`${COMMAND_GROUP_ITEMS_SELECTOR} > *`);
+				if (itemToAppend) group.appendChild(itemToAppend);
+			} else {
+				const itemToAppend = item.parentElement === listInsertionElement ? item : item.closest(`${COMMAND_GROUP_ITEMS_SELECTOR} > *`);
+				if (itemToAppend) listInsertionElement?.appendChild(itemToAppend);
+			}
+		}
+		const sortedGroups = groups.sort((a, b) => b[1] - a[1]);
+		for (const group of sortedGroups) {
+			const element = listInsertionElement?.querySelector(`${COMMAND_GROUP_SELECTOR}[${COMMAND_VALUE_ATTR}="${cssEscape(group[0])}"]`);
+			element?.parentElement?.appendChild(element);
+		}
+		this.#selectFirstItem();
+	}
+	/**
+	* Sets current value and triggers re-render if cleared.
+	*
+	* @param value - New value to set
+	*/
+	setValue(value, opts) {
+		if (value !== this.opts.value.current && value === "") this.#afterTick(() => {
+			this.key++;
+		});
+		this.setState("value", value, opts);
+		this.opts.value.current = value;
+	}
+	/**
+	* Selects first non-disabled item on next tick.
+	*/
+	#selectFirstItem() {
+		this.#afterTick(() => {
+			const value = this.getValidItems().find((item) => item.getAttribute("aria-disabled") !== "true")?.getAttribute(COMMAND_VALUE_ATTR);
+			const shouldPreventScroll = this.#isInitialMount && this.opts.disableInitialScroll.current;
+			this.setValue(value ?? "", shouldPreventScroll);
+			this.#isInitialMount = false;
+		});
+	}
+	#selectFirstItemIfValueMissing(value) {
+		afterTick(() => {
+			if (this._commandState.value !== value) return;
+			if (!this.getValidItems().some((item) => item.getAttribute(COMMAND_VALUE_ATTR) === value)) this.#selectFirstItem();
+		});
+	}
+	/**
+	* Scrolls the initial value into view if it exists and is not the first item.
+	* Called during initial mount when a value is provided.
+	*/
+	#scrollInitialValue() {
+		this.#afterTick(() => {
+			if (!this.opts.disableInitialScroll.current) this.#scrollSelectedIntoView();
+			this.#isInitialMount = false;
+		});
+	}
+	/**
+	* Updates filtered items/groups based on search.
+	* Recalculates scores and filtered count.
+	*/
+	#filterItems() {
+		if (!this._commandState.search || this.opts.shouldFilter.current === false) {
+			this._commandState.filtered.count = this.allItems.size;
+			return;
+		}
+		this._commandState.filtered.groups = /* @__PURE__ */ new Set();
+		let itemCount = 0;
+		for (const id of this.allItems) {
+			const value = this.allIds.get(id)?.value ?? "";
+			const keywords = this.allIds.get(id)?.keywords ?? [];
+			const rank = this.#score(value, keywords);
+			this._commandState.filtered.items.set(id, rank);
+			if (rank > 0) itemCount++;
+		}
+		for (const [groupId, group] of this.allGroups) for (const itemId of group) {
+			const currItem = this._commandState.filtered.items.get(itemId);
+			if (currItem && currItem > 0) {
+				this._commandState.filtered.groups.add(groupId);
+				break;
+			}
+		}
+		this._commandState.filtered.count = itemCount;
+	}
+	/**
+	* Gets all non-disabled, visible command items.
+	*
+	* @returns Array of valid item elements
+	* @remarks Exposed for direct item access and bound checking
+	*/
+	getValidItems() {
+		const node = this.opts.ref.current;
+		if (!node) return [];
+		return Array.from(node.querySelectorAll(COMMAND_VALID_ITEM_SELECTOR)).filter((el) => !!el);
+	}
+	/**
+	* Gets all visible command items.
+	*
+	* @returns Array of valid item elements
+	* @remarks Exposed for direct item access and bound checking
+	*/
+	getVisibleItems() {
+		const node = this.opts.ref.current;
+		if (!node) return [];
+		return Array.from(node.querySelectorAll(COMMAND_ITEM_SELECTOR)).filter((el) => !!el);
+	}
+	/** Returns all visible items in a matrix structure
+	*
+	* @remarks Returns empty if the command isn't configured as a grid
+	*
+	* @returns
+	*/
+	get itemsGrid() {
+		if (!this.isGrid) return [];
+		const columns = this.opts.columns.current ?? 1;
+		const items = this.getVisibleItems();
+		const grid = [[]];
+		let currentGroup = items[0]?.getAttribute("data-group");
+		let column = 0;
+		let row = 0;
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i];
+			const itemGroup = item?.getAttribute("data-group");
+			if (currentGroup !== itemGroup) {
+				currentGroup = itemGroup;
+				column = 1;
+				row++;
+				grid.push([{
+					index: i,
+					firstRowOfGroup: true,
+					ref: item
+				}]);
+			} else {
+				column++;
+				if (column > columns) {
+					row++;
+					column = 1;
+					grid.push([]);
+				}
+				grid[row]?.push({
+					index: i,
+					firstRowOfGroup: grid[row]?.[0]?.firstRowOfGroup ?? i === 0,
+					ref: item
+				});
+			}
+		}
+		return grid;
+	}
+	/**
+	* Gets currently selected command item.
+	*
+	* @returns Selected element or undefined
+	*/
+	#getSelectedItem() {
+		const node = this.opts.ref.current;
+		if (!node) return;
+		const selectedNode = node.querySelector(`${COMMAND_VALID_ITEM_SELECTOR}[data-selected]`);
+		if (!selectedNode) return;
+		return selectedNode;
+	}
+	/**
+	* Scrolls selected item into view.
+	* Special handling for first items in groups.
+	*/
+	#scrollSelectedIntoView() {
+		this.#afterTick(() => {
+			const item = this.#getSelectedItem();
+			if (!item) return;
+			const grandparent = item.parentElement?.parentElement;
+			if (!grandparent) return;
+			if (this.isGrid) {
+				const isFirstRowOfGroup = this.#itemIsFirstRowOfGroup(item);
+				item.scrollIntoView({ block: "nearest" });
+				if (isFirstRowOfGroup) {
+					(item?.closest(COMMAND_GROUP_SELECTOR)?.querySelector(COMMAND_GROUP_HEADING_SELECTOR))?.scrollIntoView({ block: "nearest" });
+					return;
+				}
+			} else {
+				const firstChildOfParent = getFirstNonCommentChild(grandparent);
+				if (firstChildOfParent && firstChildOfParent.dataset?.value === item.dataset?.value) {
+					const closestGroupHeader = item?.closest(COMMAND_GROUP_SELECTOR)?.querySelector(COMMAND_GROUP_HEADING_SELECTOR);
+					if (closestGroupHeader) {
+						closestGroupHeader.scrollIntoView({ block: "nearest" });
+						return;
+					}
+				}
+			}
+			item.scrollIntoView({ block: "nearest" });
+		});
+	}
+	#itemIsFirstRowOfGroup(item) {
+		const grid = this.itemsGrid;
+		if (grid.length === 0) return false;
+		for (let r = 0; r < grid.length; r++) {
+			const row = grid[r];
+			if (row === void 0) continue;
+			for (let c = 0; c < row.length; c++) {
+				const column = row[c];
+				if (column === void 0 || column.ref !== item) continue;
+				return column.firstRowOfGroup;
+			}
+		}
+		return false;
+	}
+	/**
+	* Sets selection to item at specified index in valid items array.
+	* If index is out of bounds, does nothing.
+	*
+	* @param index - Zero-based index of item to select
+	* @remarks
+	* Uses `getValidItems()` to get selectable items, filtering out disabled/hidden ones.
+	* Access valid items directly via `getValidItems()` to check bounds before calling.
+	*
+	* @example
+	* // get valid items length for bounds check
+	* const items = getValidItems()
+	* if (index < items.length) {
+	*   updateSelectedToIndex(index)
+	* }
+	*/
+	updateSelectedToIndex(index) {
+		const item = this.getValidItems()[index];
+		if (!item) return;
+		this.setValue(item.getAttribute(COMMAND_VALUE_ATTR) ?? "");
+	}
+	/**
+	* Updates selected item by moving up/down relative to current selection.
+	* Handles wrapping when loop option is enabled.
+	*
+	* @param change - Direction to move: 1 for next item, -1 for previous item
+	* @remarks
+	* The loop behavior wraps:
+	* - From last item to first when moving next
+	* - From first item to last when moving previous
+	*
+	* Uses `getValidItems()` to get all selectable items, which filters out disabled/hidden items.
+	* You can call `getValidItems()` directly to get the current valid items array.
+	*
+	* @example
+	* // select next item
+	* updateSelectedByItem(1)
+	*
+	* // get all valid items
+	* const items = getValidItems()
+	*/
+	updateSelectedByItem(change) {
+		const selected = this.#getSelectedItem();
+		const items = this.getValidItems();
+		const index = items.findIndex((item) => item === selected);
+		let newSelected = items[index + change];
+		if (this.opts.loop.current) newSelected = index + change < 0 ? items[items.length - 1] : index + change === items.length ? items[0] : items[index + change];
+		if (newSelected) this.setValue(newSelected.getAttribute(COMMAND_VALUE_ATTR) ?? "");
+	}
+	/**
+	* Moves selection to the first valid item in the next/previous group.
+	* If no group is found, falls back to selecting the next/previous item globally.
+	*
+	* @param change - Direction to move: 1 for next group, -1 for previous group
+	* @example
+	* // move to first item in next group
+	* updateSelectedByGroup(1)
+	*
+	* // move to first item in previous group
+	* updateSelectedByGroup(-1)
+	*/
+	updateSelectedByGroup(change) {
+		let group = this.#getSelectedItem()?.closest(COMMAND_GROUP_SELECTOR);
+		let item;
+		while (group && !item) {
+			group = change > 0 ? findNextSibling(group, COMMAND_GROUP_SELECTOR) : findPreviousSibling(group, COMMAND_GROUP_SELECTOR);
+			item = group?.querySelector(COMMAND_VALID_ITEM_SELECTOR);
+		}
+		if (item) this.setValue(item.getAttribute(COMMAND_VALUE_ATTR) ?? "");
+		else this.updateSelectedByItem(change);
+	}
+	/**
+	* Maps item id to display value and search keywords.
+	* Returns cleanup function to remove mapping.
+	*
+	* @param id - Unique item identifier
+	* @param value - Display text
+	* @param keywords - Optional search boost terms
+	* @returns Cleanup function
+	*/
+	registerValue(value, keywords) {
+		if (!(value && value === this.allIds.get(value)?.value)) this.allIds.set(value, {
+			value,
+			keywords
+		});
+		this._commandState.filtered.items.set(value, this.#score(value, keywords));
+		if (!this.sortAfterTick) {
+			this.sortAfterTick = true;
+			this.#afterTick(() => {
+				this.#sort();
+				this.sortAfterTick = false;
+			});
+		}
+		return () => {
+			this.allIds.delete(value);
+		};
+	}
+	/**
+	* Registers item in command list and its group.
+	* Handles filtering, sorting and selection updates.
+	*
+	* @param id - Item identifier
+	* @param groupId - Optional group to add item to
+	* @returns Cleanup function that handles selection
+	*/
+	registerItem(id, groupId) {
+		this.allItems.add(id);
+		if (groupId) {
+			if (!this.allGroups.has(groupId)) this.allGroups.set(groupId, /* @__PURE__ */ new Set([id]));
+			else this.allGroups.get(groupId).add(id);
+		}
+		if (!this.sortAndFilterAfterTick) {
+			this.sortAndFilterAfterTick = true;
+			this.#afterTick(() => {
+				this.#filterItems();
+				this.#sort();
+				this.sortAndFilterAfterTick = false;
+			});
+		}
+		this.#scheduleUpdate();
+		return () => {
+			const selectedItem = this.#getSelectedItem();
+			this.allItems.delete(id);
+			this.commandState.filtered.items.delete(id);
+			this.#filterItems();
+			if (selectedItem?.getAttribute("id") === id) {
+				const selectedValue = selectedItem.getAttribute(COMMAND_VALUE_ATTR);
+				if (selectedValue) this.#selectFirstItemIfValueMissing(selectedValue);
+				else this.#selectFirstItem();
+			}
+			this.#scheduleUpdate();
+		};
+	}
+	/**
+	* Creates empty group if not exists.
+	*
+	* @param id - Group identifier
+	* @returns Cleanup function
+	*/
+	registerGroup(id) {
+		if (!this.allGroups.has(id)) this.allGroups.set(id, /* @__PURE__ */ new Set());
+		return () => {
+			this.allIds.delete(id);
+			this.allGroups.delete(id);
+		};
+	}
+	get isGrid() {
+		return this.opts.columns.current !== null;
+	}
+	/**
+	* Selects last valid item.
+	*/
+	#last() {
+		return this.updateSelectedToIndex(this.getValidItems().length - 1);
+	}
+	/**
+	* Handles next item selection:
+	* - Meta: Jump to last
+	* - Alt: Next group
+	* - Default: Next item
+	*
+	* @param e - Keyboard event
+	*/
+	#next(e) {
+		e.preventDefault();
+		if (e.metaKey) this.#last();
+		else if (e.altKey) this.updateSelectedByGroup(1);
+		else this.updateSelectedByItem(1);
+	}
+	#down(e) {
+		if (this.opts.columns.current === null) return;
+		e.preventDefault();
+		if (e.metaKey) this.updateSelectedByGroup(1);
+		else this.updateSelectedByItem(this.#nextRowColumnOffset(e));
+	}
+	#getColumn(item, grid) {
+		if (grid.length === 0) return null;
+		for (let r = 0; r < grid.length; r++) {
+			const row = grid[r];
+			if (row === void 0) continue;
+			for (let c = 0; c < row.length; c++) {
+				const column = row[c];
+				if (column === void 0 || column.ref !== item) continue;
+				return {
+					columnIndex: c,
+					rowIndex: r
+				};
+			}
+		}
+		return null;
+	}
+	#nextRowColumnOffset(e) {
+		const grid = this.itemsGrid;
+		const selected = this.#getSelectedItem();
+		if (!selected) return 0;
+		const column = this.#getColumn(selected, grid);
+		if (!column) return 0;
+		let newItem = null;
+		const skipRows = e.altKey ? 1 : 0;
+		if (e.altKey && column.rowIndex === grid.length - 2 && !this.opts.loop.current) newItem = this.#findNextNonDisabledItem({
+			start: grid.length - 1,
+			end: grid.length,
+			expectedColumnIndex: column.columnIndex,
+			grid
+		});
+		else if (column.rowIndex === grid.length - 1) {
+			if (!this.opts.loop.current) return 0;
+			newItem = this.#findNextNonDisabledItem({
+				start: 0 + skipRows,
+				end: column.rowIndex,
+				expectedColumnIndex: column.columnIndex,
+				grid
+			});
+		} else {
+			newItem = this.#findNextNonDisabledItem({
+				start: column.rowIndex + 1 + skipRows,
+				end: grid.length,
+				expectedColumnIndex: column.columnIndex,
+				grid
+			});
+			if (newItem === null && this.opts.loop.current) newItem = this.#findNextNonDisabledItem({
+				start: 0,
+				end: column.rowIndex,
+				expectedColumnIndex: column.columnIndex,
+				grid
+			});
+		}
+		return this.#calculateOffset(selected, newItem);
+	}
+	/** Attempts to find the next non-disabled column that matches the expected column.
+	*
+	* @remarks
+	* - Skips over disabled columns
+	* - When a row is shorter than the expected column it defaults to the last item in the row
+	*
+	* @param param0
+	* @returns
+	*/
+	#findNextNonDisabledItem({ start, end, grid, expectedColumnIndex }) {
+		let newItem = null;
+		for (let r = start; r < end; r++) {
+			const row = grid[r];
+			newItem = row[expectedColumnIndex]?.ref ?? null;
+			if (newItem !== null && itemIsDisabled(newItem)) {
+				newItem = null;
+				continue;
+			}
+			if (newItem === null) for (let i = row.length - 1; i >= 0; i--) {
+				const item = row[row.length - 1];
+				if (item === void 0 || itemIsDisabled(item.ref)) continue;
+				newItem = item.ref;
+				break;
+			}
+			break;
+		}
+		return newItem;
+	}
+	#calculateOffset(selected, newSelected) {
+		if (newSelected === null) return 0;
+		const items = this.getValidItems();
+		const ogIndex = items.findIndex((item) => item === selected);
+		return items.findIndex((item) => item === newSelected) - ogIndex;
+	}
+	#up(e) {
+		if (this.opts.columns.current === null) return;
+		e.preventDefault();
+		if (e.metaKey) this.updateSelectedByGroup(-1);
+		else this.updateSelectedByItem(this.#previousRowColumnOffset(e));
+	}
+	#previousRowColumnOffset(e) {
+		const grid = this.itemsGrid;
+		const selected = this.#getSelectedItem();
+		if (selected === void 0) return 0;
+		const column = this.#getColumn(selected, grid);
+		if (column === null) return 0;
+		let newItem = null;
+		const skipRows = e.altKey ? 1 : 0;
+		if (e.altKey && column.rowIndex === 1 && this.opts.loop.current === false) newItem = this.#findNextNonDisabledItemDesc({
+			start: 0,
+			end: 0,
+			expectedColumnIndex: column.columnIndex,
+			grid
+		});
+		else if (column.rowIndex === 0) {
+			if (this.opts.loop.current === false) return 0;
+			newItem = this.#findNextNonDisabledItemDesc({
+				start: grid.length - 1 - skipRows,
+				end: column.rowIndex + 1,
+				expectedColumnIndex: column.columnIndex,
+				grid
+			});
+		} else {
+			newItem = this.#findNextNonDisabledItemDesc({
+				start: column.rowIndex - 1 - skipRows,
+				end: 0,
+				expectedColumnIndex: column.columnIndex,
+				grid
+			});
+			if (newItem === null && this.opts.loop.current) newItem = this.#findNextNonDisabledItemDesc({
+				start: grid.length - 1,
+				end: column.rowIndex + 1,
+				expectedColumnIndex: column.columnIndex,
+				grid
+			});
+		}
+		return this.#calculateOffset(selected, newItem);
+	}
+	/**
+	* Attempts to find the next non-disabled column that matches the expected column.
+	*
+	* @remarks
+	* - Skips over disabled columns
+	* - When a row is shorter than the expected column it defaults to the last item in the row
+	*/
+	#findNextNonDisabledItemDesc({ start, end, grid, expectedColumnIndex }) {
+		let newItem = null;
+		for (let r = start; r >= end; r--) {
+			const row = grid[r];
+			if (row === void 0) continue;
+			newItem = row[expectedColumnIndex]?.ref ?? null;
+			if (newItem !== null && itemIsDisabled(newItem)) {
+				newItem = null;
+				continue;
+			}
+			if (newItem === null) for (let i = row.length - 1; i >= 0; i--) {
+				const item = row[row.length - 1];
+				if (item === void 0 || itemIsDisabled(item.ref)) continue;
+				newItem = item.ref;
+				break;
+			}
+			break;
+		}
+		return newItem;
+	}
+	/**
+	* Handles previous item selection:
+	* - Meta: Jump to first
+	* - Alt: Previous group
+	* - Default: Previous item
+	*
+	* @param e - Keyboard event
+	*/
+	#prev(e) {
+		e.preventDefault();
+		if (e.metaKey) this.updateSelectedToIndex(0);
+		else if (e.altKey) this.updateSelectedByGroup(-1);
+		else this.updateSelectedByItem(-1);
+	}
+	onkeydown(e) {
+		const isVim = this.opts.vimBindings.current && e.ctrlKey;
+		switch (e.key) {
+			case "n":
+			case "j":
+				if (isVim) {
+					if (this.isGrid) this.#down(e);
+					else this.#next(e);
+				}
+				break;
+			case "l":
+				if (isVim) {
+					if (this.isGrid) this.#next(e);
+				}
+				break;
+			case ARROW_DOWN:
+				if (this.isGrid) this.#down(e);
+				else this.#next(e);
+				break;
+			case ARROW_RIGHT:
+				if (!this.isGrid) break;
+				this.#next(e);
+				break;
+			case "p":
+			case "k":
+				if (isVim) {
+					if (this.isGrid) this.#up(e);
+					else this.#prev(e);
+				}
+				break;
+			case "h":
+				if (isVim && this.isGrid) this.#prev(e);
+				break;
+			case ARROW_UP:
+				if (this.isGrid) this.#up(e);
+				else this.#prev(e);
+				break;
+			case ARROW_LEFT:
+				if (!this.isGrid) break;
+				this.#prev(e);
+				break;
+			case HOME:
+				e.preventDefault();
+				this.updateSelectedToIndex(0);
+				break;
+			case "End":
+				e.preventDefault();
+				this.#last();
+				break;
+			case ENTER:
+ /**
+			* Check if IME composition is finished before triggering the select event.
+			* This prevents unwanted triggering while user is still inputting text with IME.
+			* e.keyCode === 229 is for the Japanese IME && Safari as `isComposing` does not
+			* work with Japanese IME and Safari in combination.
+			*/
+			if (!e.isComposing && e.keyCode !== 229) {
+				e.preventDefault();
+				const item = this.#getSelectedItem();
+				if (item) item?.click();
+			}
+		}
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "application",
+		[commandAttrs.root]: "",
+		tabindex: -1,
+		onkeydown: this.onkeydown,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+function itemIsDisabled(item) {
+	return item.getAttribute("aria-disabled") === "true";
+}
+var CommandEmptyState = class CommandEmptyState {
+	static create(opts) {
+		return new CommandEmptyState(opts, CommandRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	#shouldRender = derived(() => {
+		return this.root._commandState.filtered.count === 0 && this.#isInitialRender === false || this.opts.forceMount.current;
+	});
+	get shouldRender() {
+		return this.#shouldRender();
+	}
+	set shouldRender($$value) {
+		return this.#shouldRender($$value);
+	}
+	#isInitialRender = true;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "presentation",
+		[commandAttrs.empty]: "",
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var CommandInputState = class CommandInputState {
+	static create(opts) {
+		return new CommandInputState(opts, CommandRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	#selectedItemId = derived(() => {
+		const item = this.root.viewportNode?.querySelector(`${COMMAND_ITEM_SELECTOR}[${COMMAND_VALUE_ATTR}="${cssEscape(this.root.opts.value.current)}"]`);
+		if (item === void 0 || item === null) return;
+		return item.getAttribute("id") ?? void 0;
+	});
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => this.root.inputNode = v);
+		watch(() => this.opts.ref.current, () => {
+			const node = this.opts.ref.current;
+			if (node && this.opts.autofocus.current) afterSleep(10, () => node.focus());
+		});
+		watch(() => this.opts.value.current, () => {
+			if (this.root.commandState.search !== this.opts.value.current) this.root.setState("search", this.opts.value.current);
+		});
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		type: "text",
+		[commandAttrs.input]: "",
+		autocomplete: "off",
+		autocorrect: "off",
+		spellcheck: false,
+		"aria-autocomplete": "list",
+		role: "combobox",
+		"aria-expanded": boolToStr(true),
+		"aria-controls": this.root.viewportNode?.id ?? void 0,
+		"aria-labelledby": this.root.labelNode?.id ?? void 0,
+		"aria-activedescendant": this.#selectedItemId(),
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var CommandItemState = class CommandItemState {
+	static create(opts) {
+		const group = CommandGroupContainerContext.getOr(null);
+		return new CommandItemState({
+			...opts,
+			group
+		}, CommandRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	#group = null;
+	#trueForceMount = derived(() => {
+		return this.opts.forceMount.current || this.#group?.opts.forceMount.current === true;
+	});
+	#shouldRender = derived(() => {
+		this.opts.ref.current;
+		if (this.#trueForceMount() || this.root.opts.shouldFilter.current === false || !this.root.commandState.search) return true;
+		const currentScore = this.root.commandState.filtered.items.get(this.trueValue);
+		if (currentScore === void 0) return false;
+		return currentScore > 0;
+	});
+	get shouldRender() {
+		return this.#shouldRender();
+	}
+	set shouldRender($$value) {
+		return this.#shouldRender($$value);
+	}
+	#isSelected = derived(() => this.root.opts.value.current === this.trueValue && this.trueValue !== "");
+	get isSelected() {
+		return this.#isSelected();
+	}
+	set isSelected($$value) {
+		return this.#isSelected($$value);
+	}
+	trueValue = "";
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.#group = CommandGroupContainerContext.getOr(null);
+		this.trueValue = opts.value.current;
+		this.attachment = attachRef(this.opts.ref);
+		watch([
+			() => this.trueValue,
+			() => this.#group?.trueValue,
+			() => this.opts.forceMount.current
+		], () => {
+			if (this.opts.forceMount.current || !this.trueValue) return;
+			return this.root.registerItem(this.trueValue, this.#group?.trueValue);
+		});
+		watch([() => this.opts.value.current, () => this.opts.ref.current], () => {
+			if (this.opts.value.current) this.trueValue = this.opts.value.current;
+			else if (this.opts.ref.current?.textContent) this.trueValue = this.opts.ref.current.textContent.trim();
+			if (this.trueValue) {
+				this.root.registerValue(this.trueValue, opts.keywords.current.map((kw) => kw.trim()));
+				this.opts.ref.current?.setAttribute(COMMAND_VALUE_ATTR, this.trueValue);
+			}
+		});
+		this.onclick = this.onclick.bind(this);
+		this.onpointermove = this.onpointermove.bind(this);
+	}
+	#onSelect() {
+		if (this.opts.disabled.current) return;
+		this.#select();
+		this.opts.onSelect?.current();
+	}
+	#select() {
+		if (this.opts.disabled.current) return;
+		this.root.setValue(this.trueValue, true);
+	}
+	onpointermove(_) {
+		if (this.opts.disabled.current || this.root.opts.disablePointerSelection.current) return;
+		this.#select();
+	}
+	onclick(_) {
+		if (this.opts.disabled.current) return;
+		this.#onSelect();
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		"aria-disabled": boolToStr(this.opts.disabled.current),
+		"aria-selected": boolToStr(this.isSelected),
+		"data-disabled": boolToEmptyStrOrUndef(this.opts.disabled.current),
+		"data-selected": boolToEmptyStrOrUndef(this.isSelected),
+		"data-value": this.trueValue,
+		"data-group": this.#group?.trueValue,
+		[commandAttrs.item]: "",
+		role: "option",
+		onpointermove: this.onpointermove,
+		onclick: this.onclick,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var CommandListState = class CommandListState {
+	static create(opts) {
+		return CommandListContext.set(new CommandListState(opts, CommandRootContext.get()));
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "listbox",
+		"aria-label": this.opts.ariaLabel.current,
+		[commandAttrs.list]: "",
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var CommandLabelState = class CommandLabelState {
+	static create(opts) {
+		return new CommandLabelState(opts, CommandRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => this.root.labelNode = v);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		[commandAttrs["input-label"]]: "",
+		for: this.opts.for?.current,
+		style: srOnlyStyles,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/components/_command-label.svelte
+function _command_label($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, children, $$slots, $$events, ...restProps } = $$props;
+		const labelState = CommandLabelState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, labelState.props));
+		$$renderer.push(`<label${attributes({ ...mergedProps() })}>`);
+		children?.($$renderer);
+		$$renderer.push(`<!----></label>`);
+		bind_props($$props, { ref });
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/components/command.svelte
+function Command$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, value = "", onValueChange = noop, onStateChange = noop, loop = false, shouldFilter = true, filter = computeCommandScore, label = "", vimBindings = true, disablePointerSelection = false, disableInitialScroll = false, columns = null, children, child, $$slots, $$events, ...restProps } = $$props;
+		const rootState = CommandRootState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			filter: boxWith(() => filter),
+			shouldFilter: boxWith(() => shouldFilter),
+			loop: boxWith(() => loop),
+			value: boxWith(() => value, (v) => {
+				if (value !== v) {
+					value = v;
+					onValueChange(v);
+				}
+			}),
+			vimBindings: boxWith(() => vimBindings),
+			disablePointerSelection: boxWith(() => disablePointerSelection),
+			disableInitialScroll: boxWith(() => disableInitialScroll),
+			onStateChange: boxWith(() => onStateChange),
+			columns: boxWith(() => columns)
+		});
+		/**
+		* Sets selection to item at specified index in valid items array.
+		* If index is out of bounds, does nothing.
+		*
+		* @param index - Zero-based index of item to select
+		* @remarks
+		* Uses `getValidItems()` to get selectable items, filtering out disabled/hidden ones.
+		* Access valid items directly via `getValidItems()` to check bounds before calling.
+		*
+		* @example
+		* // get valid items length for bounds check
+		* const items = getValidItems()
+		* if (index < items.length) {
+		*   updateSelectedToIndex(index)
+		* }
+		*/
+		const updateSelectedToIndex = (i) => rootState.updateSelectedToIndex(i);
+		/**
+		* Moves selection to the first valid item in the next/previous group.
+		* If no group is found, falls back to selecting the next/previous item globally.
+		*
+		* @param change - Direction to move: 1 for next group, -1 for previous group
+		* @example
+		* // move to first item in next group
+		* updateSelectedByGroup(1)
+		*
+		* // move to first item in previous group
+		* updateSelectedByGroup(-1)
+		*/
+		const updateSelectedByGroup = (c) => rootState.updateSelectedByGroup(c);
+		/**
+		* Updates selected item by moving up/down relative to current selection.
+		* Handles wrapping when loop option is enabled.
+		*
+		* @param change - Direction to move: 1 for next item, -1 for previous item
+		* @remarks
+		* The loop behavior wraps:
+		* - From last item to first when moving next
+		* - From first item to last when moving previous
+		*
+		* Uses `getValidItems()` to get all selectable items, which filters out disabled/hidden items.
+		* You can call `getValidItems()` directly to get the current valid items array.
+		*
+		* @example
+		* // select next item
+		* updateSelectedByItem(1)
+		*
+		* // get all valid items
+		* const items = getValidItems()
+		*/
+		const updateSelectedByItem = (c) => rootState.updateSelectedByItem(c);
+		/**
+		* Gets all non-disabled, visible command items.
+		*
+		* @returns Array of valid item elements
+		* @remarks Exposed for direct item access and bound checking
+		*/
+		const getValidItems = () => rootState.getValidItems();
+		const mergedProps = derived(() => mergeProps(restProps, rootState.props));
+		function Label($$renderer) {
+			_command_label($$renderer, {
+				children: ($$renderer) => {
+					$$renderer.push(`<!---->${escape_html(label)}`);
+				},
+				$$slots: { default: true }
+			});
+		}
+		if (child) {
+			$$renderer.push("<!--[0-->");
+			Label($$renderer);
+			$$renderer.push(`<!----> `);
+			child($$renderer, { props: mergedProps() });
+			$$renderer.push(`<!---->`);
+		} else {
+			$$renderer.push(`<!--[-1--><div${attributes({ ...mergedProps() })}>`);
+			Label($$renderer);
+			$$renderer.push(`<!----> `);
+			children?.($$renderer);
+			$$renderer.push(`<!----></div>`);
+		}
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, {
+			ref,
+			value,
+			updateSelectedToIndex,
+			updateSelectedByGroup,
+			updateSelectedByItem,
+			getValidItems
+		});
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/components/command-empty.svelte
+function Command_empty$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, children, child, forceMount = false, $$slots, $$events, ...restProps } = $$props;
+		const emptyState = CommandEmptyState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			forceMount: boxWith(() => forceMount)
+		});
+		const mergedProps = derived(() => mergeProps(emptyState.props, restProps));
+		if (emptyState.shouldRender) {
+			$$renderer.push("<!--[0-->");
+			if (child) {
+				$$renderer.push("<!--[0-->");
+				child($$renderer, { props: mergedProps() });
+				$$renderer.push(`<!---->`);
+			} else {
+				$$renderer.push(`<!--[-1--><div${attributes({ ...mergedProps() })}>`);
+				children?.($$renderer);
+				$$renderer.push(`<!----></div>`);
+			}
+			$$renderer.push(`<!--]-->`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/components/command-input.svelte
+function Command_input$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { value = "", autofocus = false, id = createId(uid), ref = null, child, $$slots, $$events, ...restProps } = $$props;
+		const inputState = CommandInputState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			value: boxWith(() => value, (v) => {
+				value = v;
+			}),
+			autofocus: boxWith(() => autofocus ?? false)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, inputState.props));
+		if (child) {
+			$$renderer.push("<!--[0-->");
+			child($$renderer, { props: mergedProps() });
+			$$renderer.push(`<!---->`);
+		} else $$renderer.push(`<!--[-1--><input${attributes({
+			...mergedProps(),
+			value
+		}, void 0, void 0, void 0, 4)}/>`);
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, {
+			value,
+			ref
+		});
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/components/command-item.svelte
+function Command_item$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, value = "", disabled = false, children, child, onSelect = noop, forceMount = false, keywords = [], $$slots, $$events, ...restProps } = $$props;
+		const itemState = CommandItemState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			value: boxWith(() => value),
+			disabled: boxWith(() => disabled),
+			onSelect: boxWith(() => onSelect),
+			forceMount: boxWith(() => forceMount),
+			keywords: boxWith(() => keywords)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, itemState.props));
+		$$renderer.push(`<!---->`);
+		$$renderer.push(`<div style="display: contents;" data-item-wrapper=""${attr("data-value", itemState.trueValue)}>`);
+		if (itemState.shouldRender) {
+			$$renderer.push("<!--[0-->");
+			if (child) {
+				$$renderer.push("<!--[0-->");
+				child($$renderer, { props: mergedProps() });
+				$$renderer.push(`<!---->`);
+			} else {
+				$$renderer.push(`<!--[-1--><div${attributes({ ...mergedProps() })}>`);
+				children?.($$renderer);
+				$$renderer.push(`<!----></div>`);
+			}
+			$$renderer.push(`<!--]-->`);
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]--></div>`);
+		$$renderer.push(`<!---->`);
+		bind_props($$props, { ref });
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/components/command-list.svelte
+function Command_list$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, child, children, "aria-label": ariaLabel, $$slots, $$events, ...restProps } = $$props;
+		const listState = CommandListState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			ariaLabel: boxWith(() => ariaLabel ?? "Suggestions...")
+		});
+		const mergedProps = derived(() => mergeProps(restProps, listState.props));
+		$$renderer.push(`<!---->`);
+		if (child) {
+			$$renderer.push("<!--[0-->");
+			child($$renderer, { props: mergedProps() });
+			$$renderer.push(`<!---->`);
+		} else {
+			$$renderer.push(`<!--[-1--><div${attributes({ ...mergedProps() })}>`);
+			children?.($$renderer);
+			$$renderer.push(`<!----></div>`);
+		}
+		$$renderer.push(`<!--]-->`);
+		$$renderer.push(`<!---->`);
+		bind_props($$props, { ref });
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/command/compute-command-score.js
+var SCORE_CONTINUE_MATCH = 1;
+var SCORE_SPACE_WORD_JUMP = .9;
+var SCORE_NON_SPACE_WORD_JUMP = .8;
+var SCORE_CHARACTER_JUMP = .17;
+var SCORE_TRANSPOSITION = .1;
+var PENALTY_SKIPPED = .999;
+var PENALTY_CASE_MISMATCH = .9999;
+var PENALTY_NOT_COMPLETE = .99;
+var IS_GAP_REGEXP = /[\\/_+.#"@[({&]/;
+var COUNT_GAPS_REGEXP = /[\\/_+.#"@[({&]/g;
+var IS_SPACE_REGEXP = /[\s-]/;
+var COUNT_SPACE_REGEXP = /[\s-]/g;
+function computeCommandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, stringIndex, abbreviationIndex, memoizedResults) {
+	if (abbreviationIndex === abbreviation.length) {
+		if (stringIndex === string.length) return SCORE_CONTINUE_MATCH;
+		return PENALTY_NOT_COMPLETE;
+	}
+	const memoizeKey = `${stringIndex},${abbreviationIndex}`;
+	if (memoizedResults[memoizeKey] !== void 0) return memoizedResults[memoizeKey];
+	const abbreviationChar = lowerAbbreviation.charAt(abbreviationIndex);
+	let index = lowerString.indexOf(abbreviationChar, stringIndex);
+	let highScore = 0;
+	let score, transposedScore, wordBreaks, spaceBreaks;
+	while (index >= 0) {
+		score = computeCommandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, index + 1, abbreviationIndex + 1, memoizedResults);
+		if (score > highScore) {
+			if (index === stringIndex) score *= SCORE_CONTINUE_MATCH;
+			else if (IS_GAP_REGEXP.test(string.charAt(index - 1))) {
+				score *= SCORE_NON_SPACE_WORD_JUMP;
+				wordBreaks = string.slice(stringIndex, index - 1).match(COUNT_GAPS_REGEXP);
+				if (wordBreaks && stringIndex > 0) score *= PENALTY_SKIPPED ** wordBreaks.length;
+			} else if (IS_SPACE_REGEXP.test(string.charAt(index - 1))) {
+				score *= SCORE_SPACE_WORD_JUMP;
+				spaceBreaks = string.slice(stringIndex, index - 1).match(COUNT_SPACE_REGEXP);
+				if (spaceBreaks && stringIndex > 0) score *= PENALTY_SKIPPED ** spaceBreaks.length;
+			} else {
+				score *= SCORE_CHARACTER_JUMP;
+				if (stringIndex > 0) score *= PENALTY_SKIPPED ** (index - stringIndex);
+			}
+			if (string.charAt(index) !== abbreviation.charAt(abbreviationIndex)) score *= PENALTY_CASE_MISMATCH;
+		}
+		if (score < SCORE_TRANSPOSITION && lowerString.charAt(index - 1) === lowerAbbreviation.charAt(abbreviationIndex + 1) || lowerAbbreviation.charAt(abbreviationIndex + 1) === lowerAbbreviation.charAt(abbreviationIndex) && lowerString.charAt(index - 1) !== lowerAbbreviation.charAt(abbreviationIndex)) {
+			transposedScore = computeCommandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, index + 1, abbreviationIndex + 2, memoizedResults);
+			if (transposedScore * SCORE_TRANSPOSITION > score) score = transposedScore * SCORE_TRANSPOSITION;
+		}
+		if (score > highScore) highScore = score;
+		index = lowerString.indexOf(abbreviationChar, index + 1);
+	}
+	memoizedResults[memoizeKey] = highScore;
+	return highScore;
+}
+/**
+*
+* @param string
+* @returns
+*/
+function formatInput(string) {
+	return string.toLowerCase().replace(COUNT_SPACE_REGEXP, " ");
+}
+/**
+* Given a command, a search query, and (optionally) a list of keywords for the command,
+* computes a score between 0 and 1 that represents how well the search query matches the
+* abbreviation and keywords. 1 is a perfect match, 0 is no match.
+*
+* The score is calculated based on the following rules:
+* - The scores are arranged so that a continuous match of characters will result in a total
+* score of 1. The best case, this character is a match, and either this is the start of the string
+* or the previous character was also a match.
+* - A new match at the start of a word scores better than a new match elsewhere as it's more likely
+* that the user will type the starts of fragments.
+* - Word jumps between spaces are scored slightly higher than slashes, brackets, hyphens, etc.
+* - A continuous match of characters will result in a total score of 1.
+* - A new match at the start of a word scores better than a new match elsewhere as it's more likely that the user will type the starts of fragments.
+* - Any other match isn't ideal, but we include it for completeness.
+* - If the user transposed two letters, it should be significantly penalized.
+* - The goodness of a match should decay slightly with each missing character.
+* - Match higher for letters closer to the beginning of the word.
+*
+* @param command - The value to score against the search string (e.g. a command name like "Calculator")
+* @param search - The search string to score against the value/aliases
+* @param commandKeywords - An optional list of aliases/keywords to score against the search string - e.g. ["math", "add", "divide", "multiply", "subtract"]
+* @returns A score between 0 and 1 that represents how well the search string matches the
+* command (and keywords)
+*/
+function computeCommandScore(command, search, commandKeywords) {
+	/**
+	* NOTE: We used to do lower-casing on each recursive call, but this meant that `toLowerCase()`
+	* was the dominating cost in the algorithm. Passing both is a little ugly, but considerably
+	* faster.
+	*/
+	command = commandKeywords && commandKeywords.length > 0 ? `${`${command} ${commandKeywords?.join(" ")}`}` : command;
+	return computeCommandScoreInner(command, search, formatInput(command), formatInput(search), 0, 0, {});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/internal/safe-polygon.svelte.js
+function isPointInPolygon(point, polygon) {
+	const [x, y] = point;
+	let isInside = false;
+	const length = polygon.length;
+	for (let i = 0, j = length - 1; i < length; j = i++) {
+		const [xi, yi] = polygon[i] ?? [0, 0];
+		const [xj, yj] = polygon[j] ?? [0, 0];
+		if (yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi) isInside = !isInside;
+	}
+	return isInside;
+}
+function isInsideRect(point, rect) {
+	return point[0] >= rect.left && point[0] <= rect.right && point[1] >= rect.top && point[1] <= rect.bottom;
+}
+function getSide(triggerRect, contentRect) {
+	const triggerCenterX = triggerRect.left + triggerRect.width / 2;
+	const triggerCenterY = triggerRect.top + triggerRect.height / 2;
+	const contentCenterX = contentRect.left + contentRect.width / 2;
+	const contentCenterY = contentRect.top + contentRect.height / 2;
+	const deltaX = contentCenterX - triggerCenterX;
+	const deltaY = contentCenterY - triggerCenterY;
+	if (Math.abs(deltaX) > Math.abs(deltaY)) return deltaX > 0 ? "right" : "left";
+	return deltaY > 0 ? "bottom" : "top";
+}
+/**
+* Creates a safe polygon area that allows users to move their cursor between
+* the trigger and floating content without closing it.
+*/
+var SafePolygon = class {
+	#opts;
+	#buffer;
+	#transitIntentTimeout;
+	#exitPoint = null;
+	#exitTarget = null;
+	#transitTargets = [];
+	#trackedTriggerNode = null;
+	#leaveFallbackRafId = null;
+	#transitIntentTimeoutId = null;
+	#cancelLeaveFallback() {
+		if (this.#leaveFallbackRafId !== null) {
+			cancelAnimationFrame(this.#leaveFallbackRafId);
+			this.#leaveFallbackRafId = null;
+		}
+	}
+	#scheduleLeaveFallback() {
+		this.#cancelLeaveFallback();
+		this.#leaveFallbackRafId = requestAnimationFrame(() => {
+			this.#leaveFallbackRafId = null;
+			if (!this.#exitPoint || !this.#exitTarget) return;
+			this.#clearTracking();
+			this.#opts.onPointerExit();
+		});
+	}
+	#cancelTransitIntentTimeout() {
+		if (this.#transitIntentTimeoutId !== null) {
+			clearTimeout(this.#transitIntentTimeoutId);
+			this.#transitIntentTimeoutId = null;
+		}
+	}
+	#scheduleTransitIntentTimeout() {
+		if (this.#transitIntentTimeout === null) return;
+		this.#cancelTransitIntentTimeout();
+		this.#transitIntentTimeoutId = window.setTimeout(() => {
+			this.#transitIntentTimeoutId = null;
+			if (!this.#exitPoint || !this.#exitTarget) return;
+			this.#clearTracking();
+			this.#opts.onPointerExit();
+		}, this.#transitIntentTimeout);
+	}
+	constructor(opts) {
+		this.#opts = opts;
+		this.#buffer = opts.buffer ?? 1;
+		const transitIntentTimeout = opts.transitIntentTimeout;
+		this.#transitIntentTimeout = typeof transitIntentTimeout === "number" && transitIntentTimeout > 0 ? transitIntentTimeout : null;
+		watch([
+			opts.triggerNode,
+			opts.contentNode,
+			opts.enabled
+		], ([triggerNode, contentNode, enabled]) => {
+			if (!triggerNode || !contentNode || !enabled) {
+				this.#trackedTriggerNode = null;
+				this.#clearTracking();
+				return;
+			}
+			if (this.#trackedTriggerNode && this.#trackedTriggerNode !== triggerNode) this.#clearTracking();
+			this.#trackedTriggerNode = triggerNode;
+			const doc = getDocument(triggerNode);
+			const handlePointerMove = (e) => {
+				this.#onPointerMove([e.clientX, e.clientY], triggerNode, contentNode);
+			};
+			const handleTriggerLeave = (e) => {
+				const target = e.relatedTarget;
+				if (isElement(target) && contentNode.contains(target)) return;
+				const ignoredTargets = this.#opts.ignoredTargets?.() ?? [];
+				if (isElement(target) && ignoredTargets.some((n) => n === target || n.contains(target))) return;
+				this.#transitTargets = isElement(target) && ignoredTargets.length > 0 ? ignoredTargets.filter((n) => target.contains(n)) : [];
+				this.#exitPoint = [e.clientX, e.clientY];
+				this.#exitTarget = "content";
+				this.#scheduleLeaveFallback();
+			};
+			const handleTriggerEnter = () => {
+				this.#clearTracking();
+			};
+			const handleContentEnter = () => {
+				this.#clearTracking();
+			};
+			const handleContentLeave = (e) => {
+				const target = e.relatedTarget;
+				if (isElement(target) && triggerNode.contains(target)) return;
+				this.#exitPoint = [e.clientX, e.clientY];
+				this.#exitTarget = "trigger";
+				this.#scheduleLeaveFallback();
+			};
+			return [
+				on(doc, "pointermove", handlePointerMove),
+				on(triggerNode, "pointerleave", handleTriggerLeave),
+				on(triggerNode, "pointerenter", handleTriggerEnter),
+				on(contentNode, "pointerenter", handleContentEnter),
+				on(contentNode, "pointerleave", handleContentLeave)
+			].reduce((acc, cleanup) => () => {
+				acc();
+				cleanup();
+			}, () => {});
+		});
+	}
+	#onPointerMove(clientPoint, triggerNode, contentNode) {
+		if (!this.#exitPoint || !this.#exitTarget) return;
+		this.#cancelLeaveFallback();
+		this.#scheduleTransitIntentTimeout();
+		const triggerRect = triggerNode.getBoundingClientRect();
+		const contentRect = contentNode.getBoundingClientRect();
+		if (this.#exitTarget === "content" && isInsideRect(clientPoint, contentRect)) {
+			this.#clearTracking();
+			return;
+		}
+		if (this.#exitTarget === "trigger" && isInsideRect(clientPoint, triggerRect)) {
+			this.#clearTracking();
+			return;
+		}
+		if (this.#exitTarget === "content" && this.#transitTargets.length > 0) for (const transitTarget of this.#transitTargets) {
+			const transitRect = transitTarget.getBoundingClientRect();
+			if (isInsideRect(clientPoint, transitRect)) return;
+			const transitSide = getSide(triggerRect, transitRect);
+			const transitCorridor = this.#getCorridorPolygon(triggerRect, transitRect, transitSide);
+			if (transitCorridor && isPointInPolygon(clientPoint, transitCorridor)) return;
+		}
+		const side = getSide(triggerRect, contentRect);
+		const corridorPoly = this.#getCorridorPolygon(triggerRect, contentRect, side);
+		if (corridorPoly && isPointInPolygon(clientPoint, corridorPoly)) return;
+		const targetRect = this.#exitTarget === "content" ? contentRect : triggerRect;
+		if (isPointInPolygon(clientPoint, this.#getSafePolygon(this.#exitPoint, targetRect, side, this.#exitTarget))) return;
+		this.#clearTracking();
+		this.#opts.onPointerExit();
+	}
+	#clearTracking() {
+		this.#exitPoint = null;
+		this.#exitTarget = null;
+		this.#transitTargets = [];
+		this.#cancelLeaveFallback();
+		this.#cancelTransitIntentTimeout();
+	}
+	/**
+	* Creates a rectangular corridor between trigger and content
+	* This prevents closing when cursor is in the gap between them
+	*/
+	#getCorridorPolygon(triggerRect, contentRect, side) {
+		const buffer = this.#buffer;
+		switch (side) {
+			case "top": return [
+				[Math.min(triggerRect.left, contentRect.left) - buffer, triggerRect.top],
+				[Math.min(triggerRect.left, contentRect.left) - buffer, contentRect.bottom],
+				[Math.max(triggerRect.right, contentRect.right) + buffer, contentRect.bottom],
+				[Math.max(triggerRect.right, contentRect.right) + buffer, triggerRect.top]
+			];
+			case "bottom": return [
+				[Math.min(triggerRect.left, contentRect.left) - buffer, triggerRect.bottom],
+				[Math.min(triggerRect.left, contentRect.left) - buffer, contentRect.top],
+				[Math.max(triggerRect.right, contentRect.right) + buffer, contentRect.top],
+				[Math.max(triggerRect.right, contentRect.right) + buffer, triggerRect.bottom]
+			];
+			case "left": return [
+				[triggerRect.left, Math.min(triggerRect.top, contentRect.top) - buffer],
+				[contentRect.right, Math.min(triggerRect.top, contentRect.top) - buffer],
+				[contentRect.right, Math.max(triggerRect.bottom, contentRect.bottom) + buffer],
+				[triggerRect.left, Math.max(triggerRect.bottom, contentRect.bottom) + buffer]
+			];
+			case "right": return [
+				[triggerRect.right, Math.min(triggerRect.top, contentRect.top) - buffer],
+				[contentRect.left, Math.min(triggerRect.top, contentRect.top) - buffer],
+				[contentRect.left, Math.max(triggerRect.bottom, contentRect.bottom) + buffer],
+				[triggerRect.right, Math.max(triggerRect.bottom, contentRect.bottom) + buffer]
+			];
+		}
+	}
+	/**
+	* Creates a triangular/trapezoidal safe zone from the exit point to the target
+	*/
+	#getSafePolygon(exitPoint, targetRect, side, exitTarget) {
+		const buffer = this.#buffer * 4;
+		const [x, y] = exitPoint;
+		switch (exitTarget === "trigger" ? this.#flipSide(side) : side) {
+			case "top": return [
+				[x - buffer, y + buffer],
+				[x + buffer, y + buffer],
+				[targetRect.right + buffer, targetRect.bottom],
+				[targetRect.right + buffer, targetRect.top],
+				[targetRect.left - buffer, targetRect.top],
+				[targetRect.left - buffer, targetRect.bottom]
+			];
+			case "bottom": return [
+				[x - buffer, y - buffer],
+				[x + buffer, y - buffer],
+				[targetRect.right + buffer, targetRect.top],
+				[targetRect.right + buffer, targetRect.bottom],
+				[targetRect.left - buffer, targetRect.bottom],
+				[targetRect.left - buffer, targetRect.top]
+			];
+			case "left": return [
+				[x + buffer, y - buffer],
+				[x + buffer, y + buffer],
+				[targetRect.right, targetRect.bottom + buffer],
+				[targetRect.left, targetRect.bottom + buffer],
+				[targetRect.left, targetRect.top - buffer],
+				[targetRect.right, targetRect.top - buffer]
+			];
+			case "right": return [
+				[x - buffer, y - buffer],
+				[x - buffer, y + buffer],
+				[targetRect.left, targetRect.bottom + buffer],
+				[targetRect.right, targetRect.bottom + buffer],
+				[targetRect.right, targetRect.top - buffer],
+				[targetRect.left, targetRect.top - buffer]
+			];
+		}
+	}
+	#flipSide(side) {
+		switch (side) {
+			case "top": return "bottom";
+			case "bottom": return "top";
+			case "left": return "right";
+			case "right": return "left";
+		}
+	}
+};
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/popover/popover.svelte.js
+var popoverAttrs = createBitsAttrs({
+	component: "popover",
+	parts: [
+		"root",
+		"trigger",
+		"content",
+		"close",
+		"overlay"
+	]
+});
+var PopoverRootContext = new Context("Popover.Root");
+var PopoverRootState = class PopoverRootState {
+	static create(opts) {
+		return PopoverRootContext.set(new PopoverRootState(opts));
+	}
+	opts;
+	contentNode = null;
+	contentPresence;
+	triggerNode = null;
+	overlayNode = null;
+	overlayPresence;
+	openedViaHover = false;
+	hasInteractedWithContent = false;
+	hoverCooldown = false;
+	closeDelay = 0;
+	#closeTimeout = null;
+	#domContext = null;
+	constructor(opts) {
+		this.opts = opts;
+		this.contentPresence = new PresenceManager({
+			ref: boxWith(() => this.contentNode),
+			open: this.opts.open,
+			onComplete: () => {
+				this.opts.onOpenChangeComplete.current(this.opts.open.current);
+			}
+		});
+		this.overlayPresence = new PresenceManager({
+			ref: boxWith(() => this.overlayNode),
+			open: this.opts.open
+		});
+		watch(() => this.opts.open.current, (isOpen) => {
+			if (!isOpen) {
+				this.openedViaHover = false;
+				this.hasInteractedWithContent = false;
+				this.#clearCloseTimeout();
+			}
+		});
+	}
+	setDomContext(ctx) {
+		this.#domContext = ctx;
+	}
+	#clearCloseTimeout() {
+		if (this.#closeTimeout !== null && this.#domContext) {
+			this.#domContext.clearTimeout(this.#closeTimeout);
+			this.#closeTimeout = null;
+		}
+	}
+	toggleOpen() {
+		this.#clearCloseTimeout();
+		this.opts.open.current = !this.opts.open.current;
+	}
+	handleClose() {
+		this.#clearCloseTimeout();
+		if (!this.opts.open.current) return;
+		this.opts.open.current = false;
+	}
+	handleHoverOpen() {
+		this.#clearCloseTimeout();
+		if (this.opts.open.current) return;
+		this.openedViaHover = true;
+		this.opts.open.current = true;
+	}
+	handleHoverClose() {
+		if (!this.opts.open.current) return;
+		if (this.openedViaHover && !this.hasInteractedWithContent) this.opts.open.current = false;
+	}
+	handleDelayedHoverClose() {
+		if (!this.opts.open.current) return;
+		if (!this.openedViaHover || this.hasInteractedWithContent) return;
+		this.#clearCloseTimeout();
+		if (this.closeDelay <= 0) this.opts.open.current = false;
+		else if (this.#domContext) this.#closeTimeout = this.#domContext.setTimeout(() => {
+			if (this.openedViaHover && !this.hasInteractedWithContent) this.opts.open.current = false;
+			this.#closeTimeout = null;
+		}, this.closeDelay);
+	}
+	cancelDelayedClose() {
+		this.#clearCloseTimeout();
+	}
+	markInteraction() {
+		this.hasInteractedWithContent = true;
+		this.#clearCloseTimeout();
+	}
+};
+var PopoverTriggerState = class PopoverTriggerState {
+	static create(opts) {
+		return new PopoverTriggerState(opts, PopoverRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	domContext;
+	#openTimeout = null;
+	#closeTimeout = null;
+	#isHovering = false;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => this.root.triggerNode = v);
+		this.domContext = new DOMContext(opts.ref);
+		this.root.setDomContext(this.domContext);
+		this.onclick = this.onclick.bind(this);
+		this.onkeydown = this.onkeydown.bind(this);
+		this.onpointerenter = this.onpointerenter.bind(this);
+		this.onpointerleave = this.onpointerleave.bind(this);
+		watch(() => this.opts.closeDelay.current, (delay) => {
+			this.root.closeDelay = delay;
+		});
+	}
+	#clearOpenTimeout() {
+		if (this.#openTimeout !== null) {
+			this.domContext.clearTimeout(this.#openTimeout);
+			this.#openTimeout = null;
+		}
+	}
+	#clearCloseTimeout() {
+		if (this.#closeTimeout !== null) {
+			this.domContext.clearTimeout(this.#closeTimeout);
+			this.#closeTimeout = null;
+		}
+	}
+	#clearAllTimeouts() {
+		this.#clearOpenTimeout();
+		this.#clearCloseTimeout();
+	}
+	onpointerenter(e) {
+		if (this.opts.disabled.current) return;
+		if (!this.opts.openOnHover.current) return;
+		if (isTouch(e)) return;
+		this.#isHovering = true;
+		this.#clearCloseTimeout();
+		this.root.cancelDelayedClose();
+		if (this.root.opts.open.current || this.root.hoverCooldown) return;
+		const delay = this.opts.openDelay.current;
+		if (delay <= 0) this.root.handleHoverOpen();
+		else this.#openTimeout = this.domContext.setTimeout(() => {
+			this.root.handleHoverOpen();
+			this.#openTimeout = null;
+		}, delay);
+	}
+	onpointerleave(e) {
+		if (this.opts.disabled.current) return;
+		if (!this.opts.openOnHover.current) return;
+		if (isTouch(e)) return;
+		this.#isHovering = false;
+		this.#clearOpenTimeout();
+		this.root.hoverCooldown = false;
+	}
+	onclick(e) {
+		if (this.opts.disabled.current) return;
+		if (e.button !== 0) return;
+		this.#clearAllTimeouts();
+		if (this.#isHovering && this.root.opts.open.current && this.root.openedViaHover) {
+			this.root.openedViaHover = false;
+			this.root.hasInteractedWithContent = true;
+			return;
+		}
+		if (this.#isHovering && this.opts.openOnHover.current && this.root.opts.open.current) this.root.hoverCooldown = true;
+		if (this.root.hoverCooldown && !this.root.opts.open.current) this.root.hoverCooldown = false;
+		this.root.toggleOpen();
+	}
+	onkeydown(e) {
+		if (this.opts.disabled.current) return;
+		if (!(e.key === "Enter" || e.key === " ")) return;
+		e.preventDefault();
+		this.#clearAllTimeouts();
+		this.root.toggleOpen();
+	}
+	#getAriaControls() {
+		if (this.root.opts.open.current && this.root.contentNode?.id) return this.root.contentNode?.id;
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		"aria-haspopup": "dialog",
+		"aria-expanded": boolToStr(this.root.opts.open.current),
+		"data-state": getDataOpenClosed(this.root.opts.open.current),
+		"aria-controls": this.#getAriaControls(),
+		[popoverAttrs.trigger]: "",
+		disabled: this.opts.disabled.current,
+		onkeydown: this.onkeydown,
+		onclick: this.onclick,
+		onpointerenter: this.onpointerenter,
+		onpointerleave: this.onpointerleave,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var PopoverContentState = class PopoverContentState {
+	static create(opts) {
+		return new PopoverContentState(opts, PopoverRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(this.opts.ref, (v) => this.root.contentNode = v);
+		this.onpointerdown = this.onpointerdown.bind(this);
+		this.onfocusin = this.onfocusin.bind(this);
+		this.onpointerenter = this.onpointerenter.bind(this);
+		this.onpointerleave = this.onpointerleave.bind(this);
+		new SafePolygon({
+			triggerNode: () => this.root.triggerNode,
+			contentNode: () => this.root.contentNode,
+			enabled: () => this.root.opts.open.current && this.root.openedViaHover && !this.root.hasInteractedWithContent,
+			onPointerExit: () => {
+				this.root.handleDelayedHoverClose();
+			}
+		});
+	}
+	onpointerdown(_) {
+		this.root.markInteraction();
+	}
+	onfocusin(e) {
+		const target = e.target;
+		if (isElement(target) && isTabbable(target)) this.root.markInteraction();
+	}
+	onpointerenter(e) {
+		if (isTouch(e)) return;
+		this.root.cancelDelayedClose();
+	}
+	onpointerleave(e) {
+		if (isTouch(e)) return;
+	}
+	onInteractOutside = (e) => {
+		this.opts.onInteractOutside.current(e);
+		if (e.defaultPrevented) return;
+		if (!isElement(e.target)) return;
+		const closestTrigger = e.target.closest(popoverAttrs.selector("trigger"));
+		if (closestTrigger && closestTrigger === this.root.triggerNode) return;
+		if (this.opts.customAnchor.current) {
+			if (isElement(this.opts.customAnchor.current)) {
+				if (this.opts.customAnchor.current.contains(e.target)) return;
+			} else if (typeof this.opts.customAnchor.current === "string") {
+				const el = document.querySelector(this.opts.customAnchor.current);
+				if (el && el.contains(e.target)) return;
+			}
+		}
+		this.root.handleClose();
+	};
+	onEscapeKeydown = (e) => {
+		this.opts.onEscapeKeydown.current(e);
+		if (e.defaultPrevented) return;
+		this.root.handleClose();
+	};
+	get shouldRender() {
+		return this.root.contentPresence.shouldRender;
+	}
+	get shouldTrapFocus() {
+		if (this.root.openedViaHover && !this.root.hasInteractedWithContent) return false;
+		return true;
+	}
+	#snippetProps = derived(() => ({ open: this.root.opts.open.current }));
+	get snippetProps() {
+		return this.#snippetProps();
+	}
+	set snippetProps($$value) {
+		return this.#snippetProps($$value);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		tabindex: -1,
+		"data-state": getDataOpenClosed(this.root.opts.open.current),
+		...getDataTransitionAttrs(this.root.contentPresence.transitionStatus),
+		[popoverAttrs.content]: "",
+		style: {
+			pointerEvents: "auto",
+			contain: "layout style"
+		},
+		onpointerdown: this.onpointerdown,
+		onfocusin: this.onfocusin,
+		onpointerenter: this.onpointerenter,
+		onpointerleave: this.onpointerleave,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+	popperProps = {
+		onInteractOutside: this.onInteractOutside,
+		onEscapeKeydown: this.onEscapeKeydown
+	};
+};
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/popover/components/popover-content.svelte
+function Popover_content$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { child, children, ref = null, id = createId(uid), forceMount = false, onOpenAutoFocus = noop, onCloseAutoFocus = noop, onEscapeKeydown = noop, onInteractOutside = noop, trapFocus = true, preventScroll = false, customAnchor = null, style, $$slots, $$events, ...restProps } = $$props;
+		const contentState = PopoverContentState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			onInteractOutside: boxWith(() => onInteractOutside),
+			onEscapeKeydown: boxWith(() => onEscapeKeydown),
+			customAnchor: boxWith(() => customAnchor)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, contentState.props));
+		const effectiveTrapFocus = derived(() => trapFocus && contentState.shouldTrapFocus);
+		function handleOpenAutoFocus(e) {
+			if (!contentState.shouldTrapFocus) e.preventDefault();
+			onOpenAutoFocus(e);
+		}
+		if (forceMount) {
+			$$renderer.push("<!--[0-->");
+			{
+				function popper($$renderer, { props, wrapperProps }) {
+					const finalProps = mergeProps(props, { style: getFloatingContentCSSVars("popover") }, { style });
+					if (child) {
+						$$renderer.push("<!--[0-->");
+						child($$renderer, {
+							props: finalProps,
+							wrapperProps,
+							...contentState.snippetProps
+						});
+						$$renderer.push(`<!---->`);
+					} else {
+						$$renderer.push(`<!--[-1--><div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
+						children?.($$renderer);
+						$$renderer.push(`<!----></div></div>`);
+					}
+					$$renderer.push(`<!--]-->`);
+				}
+				Popper_layer_force_mount($$renderer, spread_props([
+					mergedProps(),
+					contentState.popperProps,
+					{
+						ref: contentState.opts.ref,
+						enabled: contentState.root.opts.open.current,
+						id,
+						trapFocus: effectiveTrapFocus(),
+						preventScroll,
+						loop: true,
+						forceMount: true,
+						customAnchor,
+						onOpenAutoFocus: handleOpenAutoFocus,
+						onCloseAutoFocus,
+						shouldRender: contentState.shouldRender,
+						popper,
+						$$slots: { popper: true }
+					}
+				]));
+			}
+		} else if (!forceMount) {
+			$$renderer.push("<!--[1-->");
+			{
+				function popper($$renderer, { props, wrapperProps }) {
+					const finalProps = mergeProps(props, { style: getFloatingContentCSSVars("popover") }, { style });
+					if (child) {
+						$$renderer.push("<!--[0-->");
+						child($$renderer, {
+							props: finalProps,
+							wrapperProps,
+							...contentState.snippetProps
+						});
+						$$renderer.push(`<!---->`);
+					} else {
+						$$renderer.push(`<!--[-1--><div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
+						children?.($$renderer);
+						$$renderer.push(`<!----></div></div>`);
+					}
+					$$renderer.push(`<!--]-->`);
+				}
+				Popper_layer($$renderer, spread_props([
+					mergedProps(),
+					contentState.popperProps,
+					{
+						ref: contentState.opts.ref,
+						open: contentState.root.opts.open.current,
+						id,
+						trapFocus: effectiveTrapFocus(),
+						preventScroll,
+						loop: true,
+						forceMount: false,
+						customAnchor,
+						onOpenAutoFocus: handleOpenAutoFocus,
+						onCloseAutoFocus,
+						shouldRender: contentState.shouldRender,
+						popper,
+						$$slots: { popper: true }
+					}
+				]));
+			}
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/popover/components/popover-trigger.svelte
+function Popover_trigger$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { children, child, id = createId(uid), ref = null, type = "button", disabled = false, openOnHover = false, openDelay = 700, closeDelay = 300, $$slots, $$events, ...restProps } = $$props;
+		const triggerState = PopoverTriggerState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			disabled: boxWith(() => Boolean(disabled)),
+			openOnHover: boxWith(() => openOnHover),
+			openDelay: boxWith(() => openDelay),
+			closeDelay: boxWith(() => closeDelay)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, triggerState.props, { type }));
+		Floating_layer_anchor($$renderer, {
+			id,
+			ref: triggerState.opts.ref,
+			children: ($$renderer) => {
+				if (child) {
+					$$renderer.push("<!--[0-->");
+					child($$renderer, { props: mergedProps() });
+					$$renderer.push(`<!---->`);
+				} else {
+					$$renderer.push(`<!--[-1--><button${attributes({ ...mergedProps() })}>`);
+					children?.($$renderer);
+					$$renderer.push(`<!----></button>`);
+				}
+				$$renderer.push(`<!--]-->`);
+			}});
+		bind_props($$props, { ref });
+	});
+}
+// ../../node_modules/.pnpm/bits-ui@2.20.2_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_352103915e0d81ce5e87f30915895338/node_modules/bits-ui/dist/bits/popover/components/popover.svelte
+function Popover$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { open = false, onOpenChange = noop, onOpenChangeComplete = noop, children } = $$props;
+		PopoverRootState.create({
+			open: boxWith(() => open, (v) => {
+				open = v;
+				onOpenChange(v);
+			}),
+			onOpenChangeComplete: boxWith(() => onOpenChangeComplete)
+		});
+		Floating_layer($$renderer, {
+			children: ($$renderer) => {
+				children?.($$renderer);
+				$$renderer.push(`<!---->`);
+			}});
+		bind_props($$props, { open });
+	});
+}
+// ../ui/src/lib/components/primitives/popover/popover-portal.svelte
+function Popover_portal($$renderer, $$props) {
+	let { $$slots, $$events, ...restProps } = $$props;
+	if (Portal) {
+		$$renderer.push("<!--[-->");
+		Portal($$renderer, spread_props([restProps]));
+		$$renderer.push("<!--]-->");
+	} else {
+		$$renderer.push("<!--[!-->");
+		$$renderer.push("<!--]-->");
+	}
+}
+// ../ui/src/lib/components/primitives/popover/popover-content.svelte
+function Popover_content($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, sideOffset = 4, align = "center", portalProps, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			Popover_portal($$renderer, spread_props([portalProps, {
+				children: ($$renderer) => {
+					if (Popover_content$1) {
+						$$renderer.push("<!--[-->");
+						Popover_content$1($$renderer, spread_props([
+							{
+								"data-slot": "popover-content",
+								sideOffset,
+								align,
+								class: cn("data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 gap-2.5 p-2.5 text-sm shadow-md w-72 z-50 flex origin-(--bits-popover-content-transform-origin) flex-col rounded-lg bg-popover text-popover-foreground ring-1 ring-foreground/10 outline-hidden duration-100", className)
+							},
+							restProps,
+							{
+								get ref() {
+									return ref;
+								},
+								set ref($$value) {
+									ref = $$value;
+									$$settled = false;
+								}
+							}
+						]));
+						$$renderer.push("<!--]-->");
+					} else {
+						$$renderer.push("<!--[!-->");
+						$$renderer.push("<!--]-->");
+					}
+				},
+				$$slots: { default: true }
+			}]));
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+// ../ui/src/lib/components/primitives/popover/popover-trigger.svelte
+function Popover_trigger($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Popover_trigger$1) {
+				$$renderer.push("<!--[-->");
+				Popover_trigger$1($$renderer, spread_props([
+					{
+						"data-slot": "popover-trigger",
+						class: cn(className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						}
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+// ../ui/src/lib/components/primitives/popover/popover.svelte
+function Popover($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { open = false, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Popover$1) {
+				$$renderer.push("<!--[-->");
+				Popover$1($$renderer, spread_props([restProps, {
+					get open() {
+						return open;
+					},
+					set open($$value) {
+						open = $$value;
+						$$settled = false;
+					}
+				}]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { open });
+	});
+}
+// ../ui/src/lib/components/primitives/command/command.svelte
+function Command($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { api = null, ref = null, value = "", class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Command$1) {
+				$$renderer.push("<!--[-->");
+				Command$1($$renderer, spread_props([
+					{
+						"data-slot": "command",
+						class: cn("p-1 flex size-full flex-col overflow-hidden rounded-xl! bg-popover text-popover-foreground", className)
+					},
+					restProps,
+					{
+						get value() {
+							return value;
+						},
+						set value($$value) {
+							value = $$value;
+							$$settled = false;
+						},
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						}
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, {
+			api,
+			ref,
+			value
+		});
+	});
+}
+// ../ui/src/lib/components/primitives/command/command-empty.svelte
+function Command_empty($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Command_empty$1) {
+				$$renderer.push("<!--[-->");
+				Command_empty$1($$renderer, spread_props([
+					{
+						"data-slot": "command-empty",
+						class: cn("py-6 text-sm text-center", className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						}
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+// ../ui/src/lib/components/primitives/input-group/input-group-addon.svelte
+var inputGroupAddonVariants = tv({
+	base: "text-muted-foreground h-auto gap-2 py-1.5 text-sm font-medium group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-sm [&>svg:not([class*='size-'])]:size-4 flex cursor-text items-center justify-center select-none",
+	variants: { align: {
+		"inline-start": "pl-2 has-[>button]:-ml-1 has-[>kbd]:-ml-0.5 order-first",
+		"inline-end": "pr-2 has-[>button]:-mr-1 has-[>kbd]:-mr-0.5 order-last",
+		"block-start": "px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2 order-first w-full justify-start",
+		"block-end": "px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2 order-last w-full justify-start"
+	} },
+	defaultVariants: { align: "inline-start" }
+});
+function Input_group_addon($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, children, align = "inline-start", $$slots, $$events, ...restProps } = $$props;
+		$$renderer.push(`<div${attributes({
+			role: "group",
+			"data-slot": "input-group-addon",
+			"data-align": align,
+			class: clsx$1(cn(inputGroupAddonVariants({ align }), className)),
+			...restProps
+		})}>`);
+		children?.($$renderer);
+		$$renderer.push(`<!----></div>`);
+		bind_props($$props, { ref });
+	});
+}
+// ../ui/src/lib/components/primitives/command/command-input.svelte
+function Command_input($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, value = "", $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			$$renderer.push(`<div data-slot="command-input-wrapper" class="p-1 pb-0">`);
+			if (Input_group) {
+				$$renderer.push("<!--[-->");
+				Input_group($$renderer, {
+					class: "h-8! *:data-[slot=input-group-addon]:pl-2! rounded-lg! border-input/30 bg-input/30 shadow-none!",
+					children: ($$renderer) => {
+						{
+							function child($$renderer, { props }) {
+								if (Input_group_input) {
+									$$renderer.push("<!--[-->");
+									Input_group_input($$renderer, spread_props([props, {
+										get value() {
+											return value;
+										},
+										set value($$value) {
+											value = $$value;
+											$$settled = false;
+										},
+										get ref() {
+											return ref;
+										},
+										set ref($$value) {
+											ref = $$value;
+											$$settled = false;
+										}
+									}]));
+									$$renderer.push("<!--]-->");
+								} else {
+									$$renderer.push("<!--[!-->");
+									$$renderer.push("<!--]-->");
+								}
+							}
+							if (Command_input$1) {
+								$$renderer.push("<!--[-->");
+								Command_input$1($$renderer, spread_props([
+									{
+										value,
+										"data-slot": "command-input",
+										class: cn("text-sm w-full outline-hidden disabled:cursor-not-allowed disabled:opacity-50", className)
+									},
+									restProps,
+									{
+										child,
+										$$slots: { child: true }
+									}
+								]));
+								$$renderer.push("<!--]-->");
+							} else {
+								$$renderer.push("<!--[!-->");
+								$$renderer.push("<!--]-->");
+							}
+						}
+						$$renderer.push(` `);
+						if (Input_group_addon) {
+							$$renderer.push("<!--[-->");
+							Input_group_addon($$renderer, {
+								children: ($$renderer) => {
+									Search($$renderer, { class: "size-4 shrink-0 opacity-50" });
+								},
+								$$slots: { default: true }
+							});
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+					},
+					$$slots: { default: true }
+				});
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+			$$renderer.push(`</div>`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, {
+			ref,
+			value
+		});
+	});
+}
+// ../ui/src/lib/components/primitives/command/command-item.svelte
+function Command_item($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, children, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Command_item$1) {
+				$$renderer.push("<!--[-->");
+				Command_item$1($$renderer, spread_props([
+					{
+						"data-slot": "command-item",
+						class: cn("gap-2 px-2 py-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 group/command-item relative flex cursor-default items-center rounded-sm outline-hidden select-none in-data-[slot=dialog-content]:rounded-lg! data-selected:bg-muted data-selected:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 data-selected:*:[svg]:text-foreground", "data-disabled:pointer-events-none data-disabled:opacity-50", className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						},
+						children: ($$renderer) => {
+							children?.($$renderer);
+							$$renderer.push(`<!----> `);
+							Check($$renderer, { class: "ml-auto opacity-0 group-has-data-[slot=command-shortcut]/command-item:hidden group-data-[checked=true]/command-item:opacity-100" });
+							$$renderer.push(`<!---->`);
+						},
+						$$slots: { default: true }
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+// ../ui/src/lib/components/primitives/command/command-list.svelte
+function Command_list($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Command_list$1) {
+				$$renderer.push("<!--[-->");
+				Command_list$1($$renderer, spread_props([
+					{
+						"data-slot": "command-list",
+						class: cn("max-h-72 scroll-py-1 no-scrollbar overflow-x-hidden overflow-y-auto outline-none", className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						}
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+// ../ui/src/lib/components/primitives/FilterableDropdown.svelte
+function FilterableDropdown($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		/** Above this many items the list gets a filter box. */
+		let { items, value, onChange, id, placeholder = "Select...", triggerIcon: TriggerIcon, searchPlaceholder = "Filter...", searchThreshold = 4, disabled = false, class: className } = $$props;
+		let open = false;
+		const selected = derived(() => items.find((item) => item.id === value) ?? null);
+		const SelectedIcon = derived(() => selected()?.icon ?? TriggerIcon);
+		function pick(item) {
+			onChange(item.id);
+			open = false;
+		}
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Popover) {
+				$$renderer.push("<!--[-->");
+				Popover($$renderer, {
+					get open() {
+						return open;
+					},
+					set open($$value) {
+						open = $$value;
+						$$settled = false;
+					},
+					children: ($$renderer) => {
+						if (Popover_trigger) {
+							$$renderer.push("<!--[-->");
+							Popover_trigger($$renderer, {
+								id,
+								disabled,
+								role: "combobox",
+								"aria-expanded": open,
+								class: cn(buttonVariants({ variant: "outline" }), "font-normal w-full justify-start", className),
+								children: ($$renderer) => {
+									if (SelectedIcon()) {
+										$$renderer.push("<!--[0-->");
+										if (SelectedIcon()) {
+											$$renderer.push("<!--[-->");
+											SelectedIcon()($$renderer, { class: cn("size-3.5", selected()?.iconClass ?? "text-muted-foreground") });
+											$$renderer.push("<!--]-->");
+										} else {
+											$$renderer.push("<!--[!-->");
+											$$renderer.push("<!--]-->");
+										}
+									} else $$renderer.push("<!--[-1-->");
+									$$renderer.push(`<!--]--> <span${attr_class(clsx$1(cn("min-w-0 flex-1 truncate text-left", !selected() && "text-muted-foreground")))}>${escape_html(selected() ? selected().label : placeholder)}</span> `);
+									Chevron_down($$renderer, { class: "size-3.5 text-muted-foreground" });
+									$$renderer.push(`<!---->`);
+								},
+								$$slots: { default: true }
+							});
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+						$$renderer.push(` `);
+						if (Popover_content) {
+							$$renderer.push("<!--[-->");
+							Popover_content($$renderer, {
+								align: "start",
+								class: "p-0 w-(--bits-popover-anchor-width)",
+								children: ($$renderer) => {
+									if (Command) {
+										$$renderer.push("<!--[-->");
+										Command($$renderer, {
+											children: ($$renderer) => {
+												if (items.length > searchThreshold) {
+													$$renderer.push("<!--[0-->");
+													if (Command_input) {
+														$$renderer.push("<!--[-->");
+														Command_input($$renderer, { placeholder: searchPlaceholder });
+														$$renderer.push("<!--]-->");
+													} else {
+														$$renderer.push("<!--[!-->");
+														$$renderer.push("<!--]-->");
+													}
+												} else $$renderer.push("<!--[-1-->");
+												$$renderer.push(`<!--]--> `);
+												if (Command_list) {
+													$$renderer.push("<!--[-->");
+													Command_list($$renderer, {
+														children: ($$renderer) => {
+															if (Command_empty) {
+																$$renderer.push("<!--[-->");
+																Command_empty($$renderer, {
+																	children: ($$renderer) => {
+																		$$renderer.push(`<!---->No matches.`);
+																	},
+																	$$slots: { default: true }
+																});
+																$$renderer.push("<!--]-->");
+															} else {
+																$$renderer.push("<!--[!-->");
+																$$renderer.push("<!--]-->");
+															}
+															$$renderer.push(` <!--[-->`);
+															const each_array = ensure_array_like(items);
+															for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+																let item = each_array[$$index];
+																const ItemIcon = item.icon;
+																if (Command_item) {
+																	$$renderer.push("<!--[-->");
+																	Command_item($$renderer, {
+																		value: item.id,
+																		keywords: [item.label],
+																		"data-checked": item.id === value,
+																		onSelect: () => pick(item),
+																		children: ($$renderer) => {
+																			if (ItemIcon) {
+																				$$renderer.push("<!--[0-->");
+																				if (ItemIcon) {
+																					$$renderer.push("<!--[-->");
+																					ItemIcon($$renderer, { class: cn("size-3.5", item.iconClass ?? "text-muted-foreground") });
+																					$$renderer.push("<!--]-->");
+																				} else {
+																					$$renderer.push("<!--[!-->");
+																					$$renderer.push("<!--]-->");
+																				}
+																			} else $$renderer.push("<!--[-1-->");
+																			$$renderer.push(`<!--]--> <span class="truncate">${escape_html(item.label)}</span>`);
+																		},
+																		$$slots: { default: true }
+																	});
+																	$$renderer.push("<!--]-->");
+																} else {
+																	$$renderer.push("<!--[!-->");
+																	$$renderer.push("<!--]-->");
+																}
+															}
+															$$renderer.push(`<!--]-->`);
+														},
+														$$slots: { default: true }
+													});
+													$$renderer.push("<!--]-->");
+												} else {
+													$$renderer.push("<!--[!-->");
+													$$renderer.push("<!--]-->");
+												}
+											},
+											$$slots: { default: true }
+										});
+										$$renderer.push("<!--]-->");
+									} else {
+										$$renderer.push("<!--[!-->");
+										$$renderer.push("<!--]-->");
+									}
+								},
+								$$slots: { default: true }
+							});
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+					},
+					$$slots: { default: true }
+				});
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+	});
+}
+
+export { FilterableDropdown as F };
+//# sourceMappingURL=FilterableDropdown.js-COxcZtMW.js.map