@burtson-labs/ui 0.13.0 → 0.14.0

package/dist/primitives/vendor/cmdk/index.js

@@ -0,0 +1,687 @@
+"use client";
+"use client";
+import { composeRefs } from "../radix/react-compose-refs/compose-refs.js";
+import { Primitive } from "../radix/react-primitive/primitive.js";
+import { useId } from "../radix/react-id/id.js";
+import { Content as DialogContent, Dialog as Dialog$1, DialogOverlay, DialogPortal } from "../radix/react-dialog/dialog.js";
+import { commandScore } from "./command-score.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/primitives/vendor/cmdk/index.tsx
+var GROUP_SELECTOR = `[cmdk-group=""]`;
+var GROUP_ITEMS_SELECTOR = `[cmdk-group-items=""]`;
+var GROUP_HEADING_SELECTOR = `[cmdk-group-heading=""]`;
+var ITEM_SELECTOR = `[cmdk-item=""]`;
+var VALID_ITEM_SELECTOR = `${ITEM_SELECTOR}:not([aria-disabled="true"])`;
+var SELECT_EVENT = `cmdk-item-select`;
+var VALUE_ATTR = `data-value`;
+var defaultFilter = (value, search, keywords) => commandScore(value, search, keywords);
+var CommandContext = React.createContext(void 0);
+var useCommand = () => React.useContext(CommandContext);
+var StoreContext = React.createContext(void 0);
+var useStore = () => React.useContext(StoreContext);
+var GroupContext = React.createContext(void 0);
+var Command = React.forwardRef((props, forwardedRef) => {
+	const state = useLazyRef(() => ({
+		/** Value of the search query. */
+		search: "",
+		/** Currently selected item value. */
+		value: props.value ?? props.defaultValue ?? "",
+		/** Currently selected item id. */
+		selectedItemId: void 0,
+		filtered: {
+			/** The count of all visible items. */
+			count: 0,
+			/** Map from visible item id to its search score. */
+			items: /* @__PURE__ */ new Map(),
+			/** Set of groups with at least one visible item. */
+			groups: /* @__PURE__ */ new Set()
+		}
+	}));
+	const allItems = useLazyRef(() => /* @__PURE__ */ new Set());
+	const allGroups = useLazyRef(() => /* @__PURE__ */ new Map());
+	const ids = useLazyRef(() => /* @__PURE__ */ new Map());
+	const listeners = useLazyRef(() => /* @__PURE__ */ new Set());
+	const propsRef = useAsRef(props);
+	const { label, children, value, onValueChange, filter, shouldFilter, loop, disablePointerSelection = false, vimBindings = true, ...etc } = props;
+	const listId = useId();
+	const labelId = useId();
+	const inputId = useId();
+	const listInnerRef = React.useRef(null);
+	const schedule = useScheduleLayoutEffect();
+	/** Controlled mode `value` handling. */
+	useLayoutEffect(() => {
+		if (value !== void 0) {
+			const v = value.trim();
+			state.current.value = v;
+			store.emit();
+		}
+	}, [value]);
+	useLayoutEffect(() => {
+		schedule(6, scrollSelectedIntoView);
+	}, []);
+	const store = React.useMemo(() => {
+		return {
+			subscribe: (cb) => {
+				listeners.current.add(cb);
+				return () => listeners.current.delete(cb);
+			},
+			snapshot: () => {
+				return state.current;
+			},
+			setState: (key, value, opts) => {
+				if (Object.is(state.current[key], value)) return;
+				state.current[key] = value;
+				if (key === "search") {
+					filterItems();
+					sort();
+					schedule(1, selectFirstItem);
+				} else if (key === "value") {
+					if (document.activeElement?.hasAttribute("cmdk-input") || document.activeElement?.hasAttribute("cmdk-root")) {
+						const input = document.getElementById(inputId);
+						if (input) input.focus();
+						else document.getElementById(listId)?.focus();
+					}
+					schedule(7, () => {
+						state.current.selectedItemId = getSelectedItem()?.id;
+						store.emit();
+					});
+					if (!opts) schedule(5, scrollSelectedIntoView);
+					if (propsRef.current?.value !== void 0) {
+						const newValue = value ?? "";
+						propsRef.current.onValueChange?.(newValue);
+						return;
+					}
+				}
+				store.emit();
+			},
+			emit: () => {
+				listeners.current.forEach((l) => l());
+			}
+		};
+	}, []);
+	const context = React.useMemo(() => ({
+		value: (id, value, keywords) => {
+			if (value !== ids.current.get(id)?.value) {
+				ids.current.set(id, {
+					value,
+					keywords
+				});
+				state.current.filtered.items.set(id, score(value, keywords));
+				schedule(2, () => {
+					sort();
+					store.emit();
+				});
+			}
+		},
+		item: (id, groupId) => {
+			allItems.current.add(id);
+			if (groupId) {
+				if (!allGroups.current.has(groupId)) allGroups.current.set(groupId, /* @__PURE__ */ new Set([id]));
+				else allGroups.current.get(groupId).add(id);
+			}
+			schedule(3, () => {
+				filterItems();
+				sort();
+				if (!state.current.value) selectFirstItem();
+				store.emit();
+			});
+			return () => {
+				ids.current.delete(id);
+				allItems.current.delete(id);
+				state.current.filtered.items.delete(id);
+				const selectedItem = getSelectedItem();
+				schedule(4, () => {
+					filterItems();
+					if (selectedItem?.getAttribute("id") === id) selectFirstItem();
+					store.emit();
+				});
+			};
+		},
+		group: (id) => {
+			if (!allGroups.current.has(id)) allGroups.current.set(id, /* @__PURE__ */ new Set());
+			return () => {
+				ids.current.delete(id);
+				allGroups.current.delete(id);
+			};
+		},
+		filter: () => {
+			return propsRef.current.shouldFilter;
+		},
+		label: label || props["aria-label"],
+		getDisablePointerSelection: () => {
+			return propsRef.current.disablePointerSelection;
+		},
+		listId,
+		inputId,
+		labelId,
+		listInnerRef
+	}), []);
+	function score(value, keywords) {
+		const filter = propsRef.current?.filter ?? defaultFilter;
+		return value ? filter(value, state.current.search, keywords) : 0;
+	}
+	/** Sorts items by score, and groups by highest item score. */
+	function sort() {
+		if (!state.current.search || propsRef.current.shouldFilter === false) return;
+		const scores = state.current.filtered.items;
+		const groups = [];
+		state.current.filtered.groups.forEach((value) => {
+			const items = allGroups.current.get(value);
+			let max = 0;
+			items?.forEach((item) => {
+				const score = scores.get(item);
+				max = Math.max(score ?? 0, max);
+			});
+			groups.push([value, max]);
+		});
+		const listInsertionElement = listInnerRef.current;
+		getValidItems().sort((a, b) => {
+			const valueA = a.getAttribute("id");
+			const valueB = b.getAttribute("id");
+			return (scores.get(valueB) ?? 0) - (scores.get(valueA) ?? 0);
+		}).forEach((item) => {
+			const group = item.closest(GROUP_ITEMS_SELECTOR);
+			if (group) group.appendChild(item.parentElement === group ? item : item.closest(`${GROUP_ITEMS_SELECTOR} > *`));
+			else listInsertionElement.appendChild(item.parentElement === listInsertionElement ? item : item.closest(`${GROUP_ITEMS_SELECTOR} > *`));
+		});
+		groups.sort((a, b) => b[1] - a[1]).forEach((group) => {
+			const element = listInnerRef.current?.querySelector(`${GROUP_SELECTOR}[${VALUE_ATTR}="${encodeURIComponent(group[0])}"]`);
+			element?.parentElement?.appendChild(element);
+		});
+	}
+	function selectFirstItem() {
+		const value = getValidItems().find((item) => item.getAttribute("aria-disabled") !== "true")?.getAttribute(VALUE_ATTR);
+		store.setState("value", value || void 0);
+	}
+	/** Filters the current items. */
+	function filterItems() {
+		if (!state.current.search || propsRef.current.shouldFilter === false) {
+			state.current.filtered.count = allItems.current.size;
+			return;
+		}
+		state.current.filtered.groups = /* @__PURE__ */ new Set();
+		let itemCount = 0;
+		for (const id of allItems.current) {
+			const rank = score(ids.current.get(id)?.value ?? "", ids.current.get(id)?.keywords ?? []);
+			state.current.filtered.items.set(id, rank);
+			if (rank > 0) itemCount++;
+		}
+		for (const [groupId, group] of allGroups.current) for (const itemId of group) if ((state.current.filtered.items.get(itemId) ?? 0) > 0) {
+			state.current.filtered.groups.add(groupId);
+			break;
+		}
+		state.current.filtered.count = itemCount;
+	}
+	function scrollSelectedIntoView() {
+		const item = getSelectedItem();
+		if (item) {
+			if (item.parentElement?.firstChild === item) item.closest(GROUP_SELECTOR)?.querySelector(GROUP_HEADING_SELECTOR)?.scrollIntoView({ block: "nearest" });
+			item.scrollIntoView({ block: "nearest" });
+		}
+	}
+	/** Getters */
+	function getSelectedItem() {
+		return listInnerRef.current?.querySelector(`${ITEM_SELECTOR}[aria-selected="true"]`);
+	}
+	function getValidItems() {
+		return Array.from(listInnerRef.current?.querySelectorAll(VALID_ITEM_SELECTOR) || []);
+	}
+	/** Setters */
+	function updateSelectedToIndex(index) {
+		const item = getValidItems()[index];
+		if (item) store.setState("value", item.getAttribute(VALUE_ATTR));
+	}
+	function updateSelectedByItem(change) {
+		const selected = getSelectedItem();
+		const items = getValidItems();
+		const index = items.findIndex((item) => item === selected);
+		let newSelected = items[index + change];
+		if (propsRef.current?.loop) newSelected = index + change < 0 ? items[items.length - 1] : index + change === items.length ? items[0] : items[index + change];
+		if (newSelected) store.setState("value", newSelected.getAttribute(VALUE_ATTR));
+	}
+	function updateSelectedByGroup(change) {
+		let group = getSelectedItem()?.closest(GROUP_SELECTOR);
+		let item;
+		while (group && !item) {
+			group = change > 0 ? findNextSibling(group, GROUP_SELECTOR) : findPreviousSibling(group, GROUP_SELECTOR);
+			item = group?.querySelector(VALID_ITEM_SELECTOR);
+		}
+		if (item) store.setState("value", item.getAttribute(VALUE_ATTR));
+		else updateSelectedByItem(change);
+	}
+	const last = () => updateSelectedToIndex(getValidItems().length - 1);
+	const next = (e) => {
+		e.preventDefault();
+		if (e.metaKey) last();
+		else if (e.altKey) updateSelectedByGroup(1);
+		else updateSelectedByItem(1);
+	};
+	const prev = (e) => {
+		e.preventDefault();
+		if (e.metaKey) updateSelectedToIndex(0);
+		else if (e.altKey) updateSelectedByGroup(-1);
+		else updateSelectedByItem(-1);
+	};
+	return /* @__PURE__ */ jsxs(Primitive.div, {
+		ref: forwardedRef,
+		tabIndex: -1,
+		...etc,
+		"cmdk-root": "",
+		onKeyDown: (e) => {
+			etc.onKeyDown?.(e);
+			const isComposing = e.nativeEvent.isComposing || e.keyCode === 229;
+			if (e.defaultPrevented || isComposing) return;
+			switch (e.key) {
+				case "n":
+				case "j":
+					if (vimBindings && e.ctrlKey) next(e);
+					break;
+				case "ArrowDown":
+					next(e);
+					break;
+				case "p":
+				case "k":
+					if (vimBindings && e.ctrlKey) prev(e);
+					break;
+				case "ArrowUp":
+					prev(e);
+					break;
+				case "Home":
+					e.preventDefault();
+					updateSelectedToIndex(0);
+					break;
+				case "End":
+					e.preventDefault();
+					last();
+					break;
+				case "Enter": {
+					e.preventDefault();
+					const item = getSelectedItem();
+					if (item) {
+						const event = new Event(SELECT_EVENT);
+						item.dispatchEvent(event);
+					}
+				}
+			}
+		},
+		children: [/* @__PURE__ */ jsx("label", {
+			"cmdk-label": "",
+			htmlFor: context.inputId,
+			id: context.labelId,
+			style: srOnlyStyles,
+			children: label
+		}), SlottableWithNestedChildren(props, (child) => /* @__PURE__ */ jsx(StoreContext.Provider, {
+			value: store,
+			children: /* @__PURE__ */ jsx(CommandContext.Provider, {
+				value: context,
+				children: child
+			})
+		}))]
+	});
+});
+/**
+* Command menu item. Becomes active on pointer enter or through keyboard navigation.
+* Preferably pass a `value`, otherwise the value will be inferred from `children` or
+* the rendered item's `textContent`.
+*/
+var Item = React.forwardRef((props, forwardedRef) => {
+	const id = useId();
+	const ref = React.useRef(null);
+	const groupContext = React.useContext(GroupContext);
+	const context = useCommand();
+	const propsRef = useAsRef(props);
+	const forceMount = propsRef.current?.forceMount ?? groupContext?.forceMount;
+	useLayoutEffect(() => {
+		if (!forceMount) return context.item(id, groupContext?.id);
+	}, [forceMount]);
+	const value = useValue(id, ref, [
+		props.value,
+		props.children,
+		ref
+	], props.keywords);
+	const store = useStore();
+	const selected = useCmdk((state) => state.value && state.value === value.current);
+	const render = useCmdk((state) => forceMount ? true : context.filter() === false ? true : !state.search ? true : (state.filtered.items.get(id) ?? 0) > 0);
+	React.useEffect(() => {
+		const element = ref.current;
+		if (!element || props.disabled) return;
+		element.addEventListener(SELECT_EVENT, onSelect);
+		return () => element.removeEventListener(SELECT_EVENT, onSelect);
+	}, [
+		render,
+		props.onSelect,
+		props.disabled
+	]);
+	function onSelect() {
+		select();
+		propsRef.current.onSelect?.(value.current);
+	}
+	function select() {
+		store.setState("value", value.current, true);
+	}
+	if (!render) return null;
+	const { disabled, value: _, onSelect: __, forceMount: ___, keywords: ____, ...etc } = props;
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		ref: composeRefs(ref, forwardedRef),
+		...etc,
+		id,
+		"cmdk-item": "",
+		role: "option",
+		"aria-disabled": Boolean(disabled),
+		"aria-selected": Boolean(selected),
+		"data-disabled": Boolean(disabled),
+		"data-selected": Boolean(selected),
+		onPointerMove: disabled || context.getDisablePointerSelection() ? void 0 : select,
+		onClick: disabled ? void 0 : onSelect,
+		children: props.children
+	});
+});
+/**
+* Group command menu items together with a heading.
+* Grouped items are always shown together.
+*/
+var Group = React.forwardRef((props, forwardedRef) => {
+	const { heading, children, forceMount, ...etc } = props;
+	const id = useId();
+	const ref = React.useRef(null);
+	const headingRef = React.useRef(null);
+	const headingId = useId();
+	const context = useCommand();
+	const render = useCmdk((state) => forceMount ? true : context.filter() === false ? true : !state.search ? true : state.filtered.groups.has(id));
+	useLayoutEffect(() => {
+		return context.group(id);
+	}, []);
+	useValue(id, ref, [
+		props.value,
+		props.heading,
+		headingRef
+	]);
+	const contextValue = React.useMemo(() => ({
+		id,
+		forceMount
+	}), [forceMount]);
+	return /* @__PURE__ */ jsxs(Primitive.div, {
+		ref: composeRefs(ref, forwardedRef),
+		...etc,
+		"cmdk-group": "",
+		role: "presentation",
+		hidden: render ? void 0 : true,
+		children: [heading && /* @__PURE__ */ jsx("div", {
+			ref: headingRef,
+			"cmdk-group-heading": "",
+			"aria-hidden": true,
+			id: headingId,
+			children: heading
+		}), SlottableWithNestedChildren(props, (child) => /* @__PURE__ */ jsx("div", {
+			"cmdk-group-items": "",
+			role: "group",
+			"aria-labelledby": heading ? headingId : void 0,
+			children: /* @__PURE__ */ jsx(GroupContext.Provider, {
+				value: contextValue,
+				children: child
+			})
+		}))]
+	});
+});
+/**
+* A visual and semantic separator between items or groups.
+* Visible when the search query is empty or `alwaysRender` is true, hidden otherwise.
+*/
+var Separator = React.forwardRef((props, forwardedRef) => {
+	const { alwaysRender, ...etc } = props;
+	const ref = React.useRef(null);
+	const render = useCmdk((state) => !state.search);
+	if (!alwaysRender && !render) return null;
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		ref: composeRefs(ref, forwardedRef),
+		...etc,
+		"cmdk-separator": "",
+		role: "separator"
+	});
+});
+/**
+* Command menu input.
+* All props are forwarded to the underyling `input` element.
+*/
+var Input = React.forwardRef((props, forwardedRef) => {
+	const { onValueChange, ...etc } = props;
+	const isControlled = props.value != null;
+	const store = useStore();
+	const search = useCmdk((state) => state.search);
+	const selectedItemId = useCmdk((state) => state.selectedItemId);
+	const context = useCommand();
+	React.useEffect(() => {
+		if (props.value != null) store.setState("search", props.value);
+	}, [props.value]);
+	return /* @__PURE__ */ jsx(Primitive.input, {
+		ref: forwardedRef,
+		...etc,
+		"cmdk-input": "",
+		autoComplete: "off",
+		autoCorrect: "off",
+		spellCheck: false,
+		"aria-autocomplete": "list",
+		role: "combobox",
+		"aria-expanded": true,
+		"aria-controls": context.listId,
+		"aria-labelledby": context.labelId,
+		"aria-activedescendant": selectedItemId,
+		id: context.inputId,
+		type: "text",
+		value: isControlled ? props.value : search,
+		onChange: (e) => {
+			if (!isControlled) store.setState("search", e.target.value);
+			onValueChange?.(e.target.value);
+		}
+	});
+});
+/**
+* Contains `Item`, `Group`, and `Separator`.
+* Use the `--cmdk-list-height` CSS variable to animate height based on the number of results.
+*/
+var List = React.forwardRef((props, forwardedRef) => {
+	const { children, label = "Suggestions", ...etc } = props;
+	const ref = React.useRef(null);
+	const height = React.useRef(null);
+	const selectedItemId = useCmdk((state) => state.selectedItemId);
+	const context = useCommand();
+	React.useEffect(() => {
+		if (height.current && ref.current) {
+			const el = height.current;
+			const wrapper = ref.current;
+			let animationFrame = 0;
+			const observer = new ResizeObserver(() => {
+				animationFrame = requestAnimationFrame(() => {
+					const height = el.offsetHeight;
+					wrapper.style.setProperty(`--cmdk-list-height`, height.toFixed(1) + "px");
+				});
+			});
+			observer.observe(el);
+			return () => {
+				cancelAnimationFrame(animationFrame);
+				observer.unobserve(el);
+			};
+		}
+	}, []);
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		ref: composeRefs(ref, forwardedRef),
+		...etc,
+		"cmdk-list": "",
+		role: "listbox",
+		tabIndex: -1,
+		"aria-activedescendant": selectedItemId,
+		"aria-label": label,
+		id: context.listId,
+		children: SlottableWithNestedChildren(props, (child) => /* @__PURE__ */ jsx("div", {
+			ref: composeRefs(height, context.listInnerRef),
+			"cmdk-list-sizer": "",
+			children: child
+		}))
+	});
+});
+/**
+* Renders the command menu in a Radix Dialog.
+*/
+var Dialog = React.forwardRef((props, forwardedRef) => {
+	const { open, onOpenChange, overlayClassName, contentClassName, container, ...etc } = props;
+	return /* @__PURE__ */ jsx(Dialog$1, {
+		open,
+		onOpenChange,
+		children: /* @__PURE__ */ jsxs(DialogPortal, {
+			container,
+			children: [/* @__PURE__ */ jsx(DialogOverlay, {
+				"cmdk-overlay": "",
+				className: overlayClassName
+			}), /* @__PURE__ */ jsx(DialogContent, {
+				"aria-label": props.label,
+				"cmdk-dialog": "",
+				className: contentClassName,
+				children: /* @__PURE__ */ jsx(Command, {
+					ref: forwardedRef,
+					...etc
+				})
+			})]
+		})
+	});
+});
+/**
+* Automatically renders when there are no results for the search query.
+*/
+var Empty = React.forwardRef((props, forwardedRef) => {
+	if (!useCmdk((state) => state.filtered.count === 0)) return null;
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		ref: forwardedRef,
+		...props,
+		"cmdk-empty": "",
+		role: "presentation"
+	});
+});
+/**
+* You should conditionally render this with `progress` while loading asynchronous items.
+*/
+var Loading = React.forwardRef((props, forwardedRef) => {
+	const { progress, children, label = "Loading...", ...etc } = props;
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		ref: forwardedRef,
+		...etc,
+		"cmdk-loading": "",
+		role: "progressbar",
+		"aria-valuenow": progress,
+		"aria-valuemin": 0,
+		"aria-valuemax": 100,
+		"aria-label": label,
+		children: SlottableWithNestedChildren(props, (child) => /* @__PURE__ */ jsx("div", {
+			"aria-hidden": true,
+			children: child
+		}))
+	});
+});
+var pkg = Object.assign(Command, {
+	List,
+	Item,
+	Input,
+	Group,
+	Separator,
+	Dialog,
+	Empty,
+	Loading
+});
+/**
+*
+*
+* Helpers
+*
+*
+*/
+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;
+	}
+}
+function useAsRef(data) {
+	const ref = React.useRef(data);
+	useLayoutEffect(() => {
+		ref.current = data;
+	});
+	return ref;
+}
+var useLayoutEffect = typeof window === "undefined" ? React.useEffect : React.useLayoutEffect;
+function useLazyRef(fn) {
+	const ref = React.useRef(void 0);
+	if (ref.current === void 0) ref.current = fn();
+	return ref;
+}
+/** Run a selector against the store state. */
+function useCmdk(selector) {
+	const store = useStore();
+	const cb = () => selector(store.snapshot());
+	return React.useSyncExternalStore(store.subscribe, cb, cb);
+}
+function useValue(id, ref, deps, aliases = []) {
+	const valueRef = React.useRef(void 0);
+	const context = useCommand();
+	useLayoutEffect(() => {
+		const value = (() => {
+			for (const part of deps) {
+				if (typeof part === "string") return part.trim();
+				if (part !== null && typeof part === "object" && "current" in part) {
+					if (part.current) return part.current.textContent?.trim();
+					return valueRef.current;
+				}
+			}
+		})();
+		const keywords = aliases.map((alias) => alias.trim());
+		context.value(id, value, keywords);
+		ref.current?.setAttribute(VALUE_ATTR, value);
+		valueRef.current = value;
+	});
+	return valueRef;
+}
+/** Imperatively run a function on the next layout effect cycle. */
+var useScheduleLayoutEffect = () => {
+	const [s, ss] = React.useState();
+	const fns = useLazyRef(() => /* @__PURE__ */ new Map());
+	useLayoutEffect(() => {
+		fns.current.forEach((f) => f());
+		fns.current = /* @__PURE__ */ new Map();
+	}, [s]);
+	return (id, cb) => {
+		fns.current.set(id, cb);
+		ss({});
+	};
+};
+function renderChildren(children) {
+	const childrenType = children.type;
+	if (typeof childrenType === "function") return childrenType(children.props);
+	else if ("render" in childrenType) return childrenType.render(children.props);
+	else return children;
+}
+function SlottableWithNestedChildren({ asChild, children }, render) {
+	if (asChild && React.isValidElement(children)) return React.cloneElement(renderChildren(children), { ref: children.ref }, render(children.props.children));
+	return render(children);
+}
+var srOnlyStyles = {
+	position: "absolute",
+	width: "1px",
+	height: "1px",
+	padding: "0",
+	margin: "-1px",
+	overflow: "hidden",
+	clip: "rect(0, 0, 0, 0)",
+	whiteSpace: "nowrap",
+	borderWidth: "0"
+};
+//#endregion
+export { pkg as Command, Dialog as CommandDialog, Empty as CommandEmpty, Group as CommandGroup, Input as CommandInput, Item as CommandItem, List as CommandList, Loading as CommandLoading, Command as CommandRoot, Separator as CommandSeparator, defaultFilter, useCmdk as useCommandState };
+
+//# sourceMappingURL=index.js.map