@youcan/celeste 0.6.101 → 0.7.0

package/dist/cjs/chunks/ComboboxRoot.cjs

@@ -0,0 +1,695 @@
+require("./chunk.cjs");
+const require_ohash_D__AXeF1 = require("./ohash.D__AXeF1.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_useFormControl = require("./useFormControl.cjs");
+const require_useKbd = require("./useKbd.cjs");
+const require_useTypeahead = require("./useTypeahead.cjs");
+const require_usePrimitiveElement = require("./usePrimitiveElement.cjs");
+const require_Collection = require("./Collection.cjs");
+const require_VisuallyHiddenInput = require("./VisuallyHiddenInput.cjs");
+const require_utils = require("./utils2.cjs");
+const require_PopperRoot = require("./PopperRoot.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/arrays.js
+/**
+* The function `findValuesBetween` takes an array and two values, then returns a subarray containing
+* elements between the first occurrence of the start value and the first occurrence of the end value
+* in the array.
+* @param {T[]} array - The `array` parameter is an array of values of type `T`.
+* @param {T} start - The `start` parameter is the value that marks the beginning of the range you want
+* to find in the array.
+* @param {T} end - The `end` parameter in the `findValuesBetween` function represents the end value
+* that you want to find in the array. This function will return a subarray of values that are between
+* the `start` and `end` values in the original array.
+* @returns The `findValuesBetween` function returns an array of values from the input array that are
+* between the `start` and `end` values (inclusive). If either the `start` or `end` values are not
+* found in the input array, an empty array is returned.
+*/
+function findValuesBetween(array, start, end) {
+	const startIndex = array.findIndex((i) => require_ohash_D__AXeF1.isEqual(i, start));
+	const endIndex = array.findIndex((i) => require_ohash_D__AXeF1.isEqual(i, end));
+	if (startIndex === -1 || endIndex === -1) return [];
+	const [minIndex, maxIndex] = [startIndex, endIndex].sort((a, b) => a - b);
+	return array.slice(minIndex, maxIndex + 1);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useFilter.js
+/**
+* Provides locale-aware string filtering functions.
+* Uses `Intl.Collator` for comparison to ensure proper Unicode handling.
+*
+* @param options - Optional collator options to customize comparison behavior.
+*   See [Intl.CollatorOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator#options) for details.
+* @returns An object with methods to check if a string starts with, ends with, or contains a substring.
+*
+* @example
+* const { startsWith, endsWith, contains } = useFilter();
+*
+* startsWith('hello', 'he'); // true
+* endsWith('hello', 'lo'); // true
+* contains('hello', 'ell'); // true
+*/
+function useFilter(options) {
+	const computedOptions = (0, vue.computed)(() => (0, vue.unref)(options));
+	const collator = (0, vue.computed)(() => new Intl.Collator("en", {
+		usage: "search",
+		...computedOptions.value
+	}));
+	const startsWith = (string, substring) => {
+		if (substring.length === 0) return true;
+		string = string.normalize("NFC");
+		substring = substring.normalize("NFC");
+		return collator.value.compare(string.slice(0, substring.length), substring) === 0;
+	};
+	const endsWith = (string, substring) => {
+		if (substring.length === 0) return true;
+		string = string.normalize("NFC");
+		substring = substring.normalize("NFC");
+		return collator.value.compare(string.slice(-substring.length), substring) === 0;
+	};
+	const contains = (string, substring) => {
+		if (substring.length === 0) return true;
+		string = string.normalize("NFC");
+		substring = substring.normalize("NFC");
+		let scan = 0;
+		const sliceLen = substring.length;
+		for (; scan + sliceLen <= string.length; scan++) {
+			const slice = string.slice(scan, scan + sliceLen);
+			if (collator.value.compare(substring, slice) === 0) return true;
+		}
+		return false;
+	};
+	return {
+		startsWith,
+		endsWith,
+		contains
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Listbox/utils.js
+function valueComparator(value, currentValue, comparator) {
+	if (value === void 0) return false;
+	else if (Array.isArray(value)) return value.some((val) => compare(val, currentValue, comparator));
+	else return compare(value, currentValue, comparator);
+}
+function compare(value, currentValue, comparator) {
+	if (value === void 0 || currentValue === void 0) return false;
+	if (typeof value === "string") return value === currentValue;
+	if (typeof comparator === "function") return comparator(value, currentValue);
+	if (typeof comparator === "string") return value?.[comparator] === currentValue?.[comparator];
+	return require_ohash_D__AXeF1.isEqual(value, currentValue);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Listbox/ListboxRoot.js
+var [injectListboxRootContext, provideListboxRootContext] = /* @__PURE__ */ require_createContext.createContext("ListboxRoot");
+var ListboxRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "ListboxRoot",
+	props: {
+		modelValue: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: "vertical"
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		selectionBehavior: {
+			type: String,
+			required: false,
+			default: "toggle"
+		},
+		highlightOnHover: {
+			type: Boolean,
+			required: false
+		},
+		by: {
+			type: [String, Function],
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"highlight",
+		"entryFocus",
+		"leave"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { multiple, highlightOnHover, orientation, disabled, selectionBehavior, dir: propDir } = (0, vue.toRefs)(props);
+		const { getItems } = require_Collection.useCollection({ isProvider: true });
+		const { handleTypeaheadSearch } = require_useTypeahead.useTypeahead();
+		const { primitiveElement, currentElement } = require_usePrimitiveElement.usePrimitiveElement();
+		const kbd = require_useKbd.useKbd();
+		const dir = require_useDirection.useDirection(propDir);
+		const isFormControl = require_useFormControl.useFormControl(currentElement);
+		const firstValue = (0, vue.ref)();
+		const isUserAction = (0, vue.ref)(false);
+		const focusable = (0, vue.ref)(true);
+		const modelValue = require_dist.useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue ?? (multiple.value ? [] : void 0),
+			passive: props.modelValue === void 0,
+			deep: true
+		});
+		function onValueChange(val) {
+			isUserAction.value = true;
+			if (props.multiple) {
+				const modelArray = Array.isArray(modelValue.value) ? [...modelValue.value] : [];
+				const index = modelArray.findIndex((i) => compare(i, val, props.by));
+				if (props.selectionBehavior === "toggle") {
+					index === -1 ? modelArray.push(val) : modelArray.splice(index, 1);
+					modelValue.value = modelArray;
+				} else {
+					modelValue.value = [val];
+					firstValue.value = val;
+				}
+			} else if (props.selectionBehavior === "toggle") if (compare(modelValue.value, val, props.by)) modelValue.value = void 0;
+			else modelValue.value = val;
+			else modelValue.value = val;
+			setTimeout(() => {
+				isUserAction.value = false;
+			}, 1);
+		}
+		const highlightedElement = (0, vue.ref)(null);
+		const previousElement = (0, vue.ref)(null);
+		const isVirtual = (0, vue.ref)(false);
+		const isComposing = (0, vue.ref)(false);
+		const virtualFocusHook = require_dist.createEventHook();
+		const virtualKeydownHook = require_dist.createEventHook();
+		const virtualHighlightHook = require_dist.createEventHook();
+		function getCollectionItem() {
+			return getItems().map((i) => i.ref).filter((i) => i.dataset.disabled !== "");
+		}
+		function changeHighlight(el, scrollIntoView = true, focus) {
+			if (!el) return;
+			highlightedElement.value = el;
+			if (focus ?? focusable.value) highlightedElement.value.focus();
+			if (scrollIntoView) highlightedElement.value.scrollIntoView({ block: "nearest" });
+			emits("highlight", getItems().find((i) => i.ref === el));
+		}
+		function highlightItem(value) {
+			if (isVirtual.value) virtualHighlightHook.trigger(value);
+			else {
+				const item = getItems().find((i) => compare(i.value, value, props.by));
+				if (item) {
+					highlightedElement.value = item.ref;
+					changeHighlight(item.ref);
+				}
+			}
+		}
+		function onKeydownEnter(event) {
+			if (highlightedElement.value && highlightedElement.value.isConnected) {
+				if (event.ctrlKey || event.metaKey || event.altKey) return;
+				event.preventDefault();
+				event.stopPropagation();
+				if (!isComposing.value) highlightedElement.value.click();
+			}
+		}
+		function onKeydownTypeAhead(event) {
+			if (!focusable.value) return;
+			isUserAction.value = true;
+			if (isVirtual.value) virtualKeydownHook.trigger(event);
+			else {
+				const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
+				if (isMetaKey && event.key === "a" && multiple.value) {
+					const collection = getItems();
+					modelValue.value = [...collection.map((i) => i.value)];
+					event.preventDefault();
+					const lastItem = collection.at(-1);
+					if (lastItem) changeHighlight(lastItem.ref);
+				} else if (!isMetaKey) {
+					const el = handleTypeaheadSearch(event.key, getItems());
+					if (el) changeHighlight(el);
+				}
+			}
+			setTimeout(() => {
+				isUserAction.value = false;
+			}, 1);
+		}
+		function onCompositionStart() {
+			isComposing.value = true;
+		}
+		function onCompositionEnd() {
+			(0, vue.nextTick)(() => {
+				isComposing.value = false;
+			});
+		}
+		function highlightFirstItem() {
+			(0, vue.nextTick)(() => {
+				onKeydownNavigation(new KeyboardEvent("keydown", { key: "PageUp" }));
+			});
+		}
+		function onLeave(event) {
+			const el = highlightedElement.value;
+			if (el?.isConnected) previousElement.value = el;
+			highlightedElement.value = null;
+			emits("leave", event);
+		}
+		function onEnter(event) {
+			const entryFocusEvent = new CustomEvent("listbox.entryFocus", {
+				bubbles: false,
+				cancelable: true
+			});
+			event.currentTarget?.dispatchEvent(entryFocusEvent);
+			emits("entryFocus", entryFocusEvent);
+			if (entryFocusEvent.defaultPrevented) return;
+			if (previousElement.value) changeHighlight(previousElement.value);
+			else {
+				const el = getCollectionItem()?.[0];
+				changeHighlight(el);
+			}
+		}
+		function onKeydownNavigation(event) {
+			const intent = require_utils.getFocusIntent(event, orientation.value, dir.value);
+			if (!intent) return;
+			let collection = getCollectionItem();
+			if (highlightedElement.value) {
+				if (intent === "last") collection.reverse();
+				else if (intent === "prev" || intent === "next") {
+					if (intent === "prev") collection.reverse();
+					const currentIndex = collection.indexOf(highlightedElement.value);
+					collection = collection.slice(currentIndex + 1);
+				}
+				handleMultipleReplace(event, collection[0]);
+			}
+			if (collection.length) {
+				const index = !highlightedElement.value && intent === "prev" ? collection.length - 1 : 0;
+				changeHighlight(collection[index]);
+			}
+			if (isVirtual.value) return virtualKeydownHook.trigger(event);
+		}
+		function handleMultipleReplace(event, targetEl) {
+			if (isVirtual.value || props.selectionBehavior !== "replace" || !multiple.value || !Array.isArray(modelValue.value)) return;
+			if ((event.altKey || event.ctrlKey || event.metaKey) && !event.shiftKey) return;
+			if (event.shiftKey) {
+				const collection = getItems().filter((i) => i.ref.dataset.disabled !== "");
+				let lastValue = collection.find((i) => i.ref === targetEl)?.value;
+				if (event.key === kbd.END) lastValue = collection.at(-1)?.value;
+				else if (event.key === kbd.HOME) lastValue = collection[0]?.value;
+				if (!lastValue || !firstValue.value) return;
+				modelValue.value = findValuesBetween(collection.map((i) => i.value), firstValue.value, lastValue);
+			}
+		}
+		async function highlightSelected(event, scroll = true) {
+			if (!require_dist.isClient) return;
+			await (0, vue.nextTick)();
+			if (isVirtual.value) virtualFocusHook.trigger({
+				event,
+				scroll
+			});
+			else {
+				const collection = getCollectionItem();
+				const item = collection.find((i) => i.dataset.state === "checked");
+				const focus = scroll ? void 0 : false;
+				if (item) changeHighlight(item, scroll, focus);
+				else if (collection.length) changeHighlight(collection[0], scroll, focus);
+			}
+		}
+		let hasHighlightedOnMount = false;
+		(0, vue.watch)(modelValue, () => {
+			if (!isUserAction.value) {
+				const scroll = hasHighlightedOnMount;
+				hasHighlightedOnMount = true;
+				(0, vue.nextTick)(() => {
+					highlightSelected(void 0, scroll);
+				});
+			}
+		}, {
+			immediate: true,
+			deep: true
+		});
+		__expose({
+			highlightedElement,
+			highlightItem,
+			highlightFirstItem,
+			highlightSelected,
+			getItems
+		});
+		provideListboxRootContext({
+			modelValue,
+			onValueChange,
+			multiple,
+			orientation,
+			dir,
+			disabled,
+			highlightOnHover,
+			highlightedElement,
+			isVirtual,
+			virtualFocusHook,
+			virtualKeydownHook,
+			virtualHighlightHook,
+			by: props.by,
+			firstValue,
+			selectionBehavior,
+			focusable,
+			onLeave,
+			onEnter,
+			changeHighlight,
+			onKeydownEnter,
+			onKeydownNavigation,
+			onKeydownTypeAhead,
+			onCompositionStart,
+			onCompositionEnd,
+			highlightFirstItem
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				ref_key: "primitiveElement",
+				ref: primitiveElement,
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				dir: (0, vue.unref)(dir),
+				"data-disabled": (0, vue.unref)(disabled) ? "" : void 0,
+				onPointerleave: onLeave,
+				onFocusout: _cache[0] || (_cache[0] = async (event) => {
+					const target = event.relatedTarget || event.target;
+					await (0, vue.nextTick)();
+					if (highlightedElement.value && (0, vue.unref)(currentElement) && !(0, vue.unref)(currentElement).contains(target)) onLeave(event);
+				})
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { modelValue: (0, vue.unref)(modelValue) }), (0, vue.unref)(isFormControl) && _ctx.name ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHiddenInput.VisuallyHiddenInput_default), {
+					key: 0,
+					name: _ctx.name,
+					value: (0, vue.unref)(modelValue),
+					disabled: (0, vue.unref)(disabled),
+					required: _ctx.required
+				}, null, 8, [
+					"name",
+					"value",
+					"disabled",
+					"required"
+				])) : (0, vue.createCommentVNode)("v-if", true)]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"dir",
+				"data-disabled"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Combobox/ComboboxRoot.js
+var [injectComboboxRootContext, provideComboboxRootContext] = /* @__PURE__ */ require_createContext.createContext("ComboboxRoot");
+var ComboboxRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "ComboboxRoot",
+	props: {
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false
+		},
+		resetSearchTermOnBlur: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		resetSearchTermOnSelect: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		openOnFocus: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		openOnClick: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		ignoreFilter: {
+			type: Boolean,
+			required: false
+		},
+		resetModelValueOnClear: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		highlightOnHover: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		by: {
+			type: [String, Function],
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"highlight",
+		"update:open"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { primitiveElement, currentElement: parentElement } = require_usePrimitiveElement.usePrimitiveElement();
+		const { multiple, disabled, ignoreFilter, resetSearchTermOnSelect, openOnFocus, openOnClick, dir: propDir, resetModelValueOnClear, highlightOnHover } = (0, vue.toRefs)(props);
+		const dir = require_useDirection.useDirection(propDir);
+		const modelValue = require_dist.useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue ?? (multiple.value ? [] : void 0),
+			passive: props.modelValue === void 0,
+			deep: true
+		});
+		const open = require_dist.useVModel(props, "open", emits, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		async function onOpenChange(val) {
+			open.value = val;
+			filterSearch.value = "";
+			if (val) {
+				await (0, vue.nextTick)();
+				primitiveElement.value?.highlightSelected();
+				isUserInputted.value = true;
+				inputElement.value?.focus();
+			} else {
+				isUserInputted.value = false;
+				setTimeout(() => {
+					if (!val && props.resetSearchTermOnBlur) resetSearchTerm.trigger();
+				}, 1);
+			}
+		}
+		const resetSearchTerm = require_dist.createEventHook();
+		const isUserInputted = (0, vue.ref)(false);
+		const isVirtual = (0, vue.ref)(false);
+		const inputElement = (0, vue.ref)();
+		const triggerElement = (0, vue.ref)();
+		const highlightedElement = (0, vue.computed)(() => primitiveElement.value?.highlightedElement ?? void 0);
+		const allItems = (0, vue.ref)(/* @__PURE__ */ new Map());
+		const allGroups = (0, vue.ref)(/* @__PURE__ */ new Map());
+		const { contains } = useFilter({ sensitivity: "base" });
+		const filterSearch = (0, vue.ref)("");
+		const filterState = (0, vue.computed)((oldValue) => {
+			if (!filterSearch.value || props.ignoreFilter || isVirtual.value) return {
+				count: allItems.value.size,
+				items: oldValue?.items ?? /* @__PURE__ */ new Map(),
+				groups: oldValue?.groups ?? new Set(allGroups.value.keys())
+			};
+			let itemCount = 0;
+			const filteredItems = /* @__PURE__ */ new Map();
+			const filteredGroups = /* @__PURE__ */ new Set();
+			for (const [id, value] of allItems.value) {
+				const score = contains(value, filterSearch.value);
+				filteredItems.set(id, score ? 1 : 0);
+				if (score) itemCount++;
+			}
+			for (const [groupId, group] of allGroups.value) for (const itemId of group) if (filteredItems.get(itemId) > 0) {
+				filteredGroups.add(groupId);
+				break;
+			}
+			return {
+				count: itemCount,
+				items: filteredItems,
+				groups: filteredGroups
+			};
+		});
+		const inst = (0, vue.getCurrentInstance)();
+		(0, vue.onMounted)(() => {
+			if (inst?.exposed) {
+				inst.exposed.highlightItem = primitiveElement.value?.highlightItem;
+				inst.exposed.highlightFirstItem = primitiveElement.value?.highlightFirstItem;
+				inst.exposed.highlightSelected = primitiveElement.value?.highlightSelected;
+			}
+		});
+		__expose({
+			filtered: filterState,
+			highlightedElement,
+			highlightItem: primitiveElement.value?.highlightItem,
+			highlightFirstItem: primitiveElement.value?.highlightFirstItem,
+			highlightSelected: primitiveElement.value?.highlightSelected
+		});
+		provideComboboxRootContext({
+			modelValue,
+			multiple,
+			disabled,
+			open,
+			onOpenChange,
+			contentId: "",
+			isUserInputted,
+			isVirtual,
+			inputElement,
+			highlightedElement,
+			onInputElementChange: (val) => inputElement.value = val,
+			triggerElement,
+			onTriggerElementChange: (val) => triggerElement.value = val,
+			parentElement,
+			resetSearchTermOnSelect,
+			onResetSearchTerm: resetSearchTerm.on,
+			allItems,
+			allGroups,
+			filterSearch,
+			filterState,
+			ignoreFilter,
+			openOnFocus,
+			openOnClick,
+			resetModelValueOnClear
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperRoot.PopperRoot_default), null, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(ListboxRoot_default), (0, vue.mergeProps)({
+					ref_key: "primitiveElement",
+					ref: primitiveElement
+				}, _ctx.$attrs, {
+					modelValue: (0, vue.unref)(modelValue),
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => (0, vue.isRef)(modelValue) ? modelValue.value = $event : null),
+					style: { pointerEvents: (0, vue.unref)(open) ? "auto" : void 0 },
+					as: _ctx.as,
+					"as-child": _ctx.asChild,
+					dir: (0, vue.unref)(dir),
+					multiple: (0, vue.unref)(multiple),
+					name: _ctx.name,
+					required: _ctx.required,
+					disabled: (0, vue.unref)(disabled),
+					"highlight-on-hover": (0, vue.unref)(highlightOnHover),
+					by: props.by,
+					onHighlight: _cache[1] || (_cache[1] = ($event) => emits("highlight", $event))
+				}), {
+					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {
+						open: (0, vue.unref)(open),
+						modelValue: (0, vue.unref)(modelValue)
+					})]),
+					_: 3
+				}, 16, [
+					"modelValue",
+					"style",
+					"as",
+					"as-child",
+					"dir",
+					"multiple",
+					"name",
+					"required",
+					"disabled",
+					"highlight-on-hover",
+					"by"
+				])]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "ComboboxRoot_default", {
+	enumerable: true,
+	get: function() {
+		return ComboboxRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectComboboxRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectComboboxRootContext;
+	}
+});
+Object.defineProperty(exports, "injectListboxRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectListboxRootContext;
+	}
+});
+Object.defineProperty(exports, "valueComparator", {
+	enumerable: true,
+	get: function() {
+		return valueComparator;
+	}
+});