solid-baseui 0.1.0-alpha.0

package/dist/lib/server/useFilteredItems-DvuctLt3.js

@@ -0,0 +1,3157 @@
+import { getStateAttributesProps } from "./internals/getStateAttributesProps.js";
+import { E as pointer, S as listNavigation, b as keyboard, g as inputClear, h as inputChange, l as escapeKey, r as clearPress, t as cancelOpen, v as inputPress, w as none, y as itemPress } from "./internals/reasons.js";
+import { n as resolveClass, t as resolveStyle } from "./resolveStyle-XCSFDHAL.js";
+import { createChangeEventDetails, createGenericEventDetails } from "./internals/createBaseUIEventDetails.js";
+import { transitionStatusMapping } from "./internals/stateAttributesMapping.js";
+import { composeEventHandlers } from "./internals/composeEventHandlers.js";
+import { t as runOnceAnimationsFinish } from "./runOnceAnimationsFinish-DCHzXWZU.js";
+import { a as isElement, c as isHTMLElement, l as isInteractiveElement, n as contains, o as isElementVisible, p as ownerDocument } from "./dom-Crg_2R-j.js";
+import { i as isListIndexDisabled, n as getMinListIndex, r as getNavigatedIndex, t as getMaxListIndex } from "./compositeNavigation-BRVT1C38.js";
+import { t as createAnchorPositioning } from "./createAnchorPositioning-C-cVOPwz.js";
+import { t as InternalBackdrop } from "./InternalBackdrop-C_iDPVR-.js";
+import { t as createAnchoredPopupScrollLock } from "./createAnchoredPopupScrollLock-DFuUrykR.js";
+import { t as createClickInteraction } from "./createClickInteraction-BYsMgvup.js";
+import { c as useFloatingTree, i as createFloatingNode, n as FloatingTreeContext, r as FloatingTreeStore, s as useFloatingParentNodeId, t as FloatingParentNodeContext } from "./FloatingTree-z1JPD1dR.js";
+import { a as createPopupPresence, n as createTriggerRegistration, o as createDismiss, t as PopupStore } from "./PopupStore-DEs3FAEe.js";
+import { t as createTransitionStatus } from "./createTransitionStatus-BTlrerSS.js";
+import { a as triggerOpenStateMapping, i as pressableTriggerOpenStateMapping, n as popupStateMapping, o as PopupPortal, r as popupTransitionStateMapping } from "./popupStateMapping-nKoUwoke.js";
+import { t as FocusManager } from "./FocusManager-BrbZVWME.js";
+import { a as stopButtonInteraction, i as preventDisabledButtonKeyDown, n as handleNonNativeButtonKeyUp, r as preventButtonInteraction, t as handleNonNativeButtonKeyDown } from "./buttonSemantics-BSwDxJhh.js";
+import { t as setRef } from "./setRef-Bt70sW7c.js";
+import { n as useDirection } from "./DirectionContext-YORWLF08.js";
+import { DEFAULT_FIELD_STATE_ATTRIBUTES, fieldStateAttributesMapping } from "./internals/field-constants.js";
+import { n as useFieldRootContext } from "./FieldRootContext-IC-LWzVp.js";
+import { n as useFormContext } from "./FormContext-pvESt85v.js";
+import { a as defaultItemEquality, c as removeItem, i as compareItemEquality, l as selectedValueIncludes, n as isSolidAccessor, o as findItemIndex, r as areItemArraysEqual, s as findSelectionIndex, t as mergeStyleValue } from "./mergeStyleValue-Db8bRCM4.js";
+import { r as useLabelableContext } from "./LabelableContext-DZP3rgAY.js";
+import { i as isScrollableY } from "./scrollable-CjsSxbGr.js";
+import { t as isAndroid } from "./platform-DYukKUir.js";
+import { Dynamic, escape, memo, mergeProps, ssr, ssrAttribute, ssrElement, ssrGroup, ssrHydrationKey, ssrStyle } from "@solidjs/web";
+import { For, Show, createContext, createEffect, createMemo, createSignal, createUniqueId, flush, omit, onCleanup, untrack, useContext } from "solid-js";
+//#region src/internals/overlay/createListNavigation.ts
+function createListNavigation(options) {
+	const enabled = () => options.enabled?.() ?? true;
+	const orientation = () => options.orientation?.() ?? "vertical";
+	const isNavigationKey = (key) => key === "Home" || key === "End" || orientation() !== "horizontal" && (key === "ArrowDown" || key === "ArrowUp") || orientation() !== "vertical" && (key === "ArrowLeft" || key === "ArrowRight");
+	let pendingOpenNavigation = null;
+	const isForwardKey = (key) => {
+		if (key === "Home" || key === "ArrowDown") return true;
+		if (key === "End" || key === "ArrowUp") return false;
+		return key === (options.rtl?.() ?? false ? "ArrowLeft" : "ArrowRight");
+	};
+	const navigate = (event, list, initial = false) => {
+		let index = options.activeIndex() ?? options.selectedIndex?.() ?? -1;
+		if (initial) index = isForwardKey(event.key) ? getMinListIndex(list, options.disabledIndices?.()) : getMaxListIndex(list, options.disabledIndices?.());
+		else {
+			const loop = options.loopFocus?.() ?? false;
+			const escapeEnabled = loop && (options.allowEscape?.() ?? false);
+			const next = getNavigatedIndex({
+				list,
+				currentIndex: index,
+				key: event.key,
+				orientation: orientation(),
+				rtl: options.rtl?.() ?? false,
+				loop: escapeEnabled ? index === -1 : loop,
+				cols: options.cols?.() ?? 1,
+				disabledIndices: options.disabledIndices?.()
+			});
+			const isEdgeKey = event.key === "Home" || event.key === "End";
+			index = next === index && escapeEnabled && index !== -1 && !isEdgeKey ? -1 : next;
+		}
+		options.onNavigate(index === -1 ? null : index, event);
+		if (!(options.virtual?.() ?? false) && index >= 0) list[index]?.focus({ preventScroll: true });
+	};
+	createEffect(() => ({
+		open: options.context.track().open,
+		list: options.list()
+	}), (state) => {
+		if (!pendingOpenNavigation || !state.open || state.list.length === 0) return;
+		const pending = pendingOpenNavigation;
+		pendingOpenNavigation = null;
+		untrack(() => navigate(pending.event, state.list, true));
+	});
+	return {
+		onKeyDown(event) {
+			if (!enabled() || !isNavigationKey(event.key)) return;
+			event.preventDefault();
+			event.stopPropagation();
+			if (!options.context.state.open) {
+				const arrowKey = event.key.startsWith("Arrow");
+				if (!(options.openOnArrowKeyDown?.() ?? true) || !arrowKey) return;
+				pendingOpenNavigation = { event };
+				const details = createChangeEventDetails(listNavigation, event, options.context.state.domReferenceElement ?? void 0);
+				options.context.setOpen(true, details);
+				if (details.isCanceled) {
+					pendingOpenNavigation = null;
+					return;
+				}
+				const list = options.list();
+				if (options.context.state.open && list.length > 0) {
+					pendingOpenNavigation = null;
+					navigate(event, list, true);
+				}
+				return;
+			}
+			const list = options.list();
+			if (list.length > 0) navigate(event, list);
+		},
+		onItemPointerMove(event, index) {
+			if (!enabled() || !(options.focusItemOnHover?.() ?? true) || isListIndexDisabled(options.list(), index, options.disabledIndices?.())) return;
+			options.onNavigate(index, event);
+			if (!(options.virtual?.() ?? false)) options.list()[index]?.focus({ preventScroll: true });
+		},
+		onItemPointerLeave(event) {
+			if (enabled() && (options.virtual?.() ?? false)) options.onNavigate(null, event);
+		}
+	};
+}
+//#endregion
+//#region src/internals/overlay/createTypeahead.ts
+function createTypeahead(options) {
+	let typed = "";
+	let previousIndex = untrack(() => options.selectedIndex?.() ?? options.activeIndex() ?? -1);
+	let matchIndex = null;
+	let resetTimer;
+	const reset = () => {
+		clearTimeout(resetTimer);
+		typed = "";
+		previousIndex = matchIndex ?? previousIndex;
+		options.onTyping?.(false);
+	};
+	onCleanup(reset);
+	createEffect(() => ({
+		open: options.context.track().open,
+		selected: options.selectedIndex?.() ?? null
+	}), (state) => {
+		if (state.open || state.selected === null) {
+			clearTimeout(resetTimer);
+			matchIndex = null;
+			typed = "";
+		}
+	});
+	const available = (index) => {
+		const element = options.elements?.()[index];
+		if (element && !isElementVisible(element) || element?.matches(":disabled")) return false;
+		const disabled = options.disabledIndices?.();
+		return !disabled || !isListIndexDisabled([], index, disabled);
+	};
+	const matchingIndex = (query, startIndex) => {
+		const list = options.list();
+		if (!list.length) return -1;
+		const normalizedStart = (startIndex % list.length + list.length) % list.length;
+		const lowerQuery = query.toLowerCase();
+		for (let offset = 0; offset < list.length; offset += 1) {
+			const index = (normalizedStart + offset) % list.length;
+			if (list[index]?.toLowerCase().startsWith(lowerQuery) && available(index)) return index;
+		}
+		return -1;
+	};
+	return {
+		onKeyDown(event) {
+			if (!(options.enabled?.() ?? true) || event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return;
+			const list = options.list();
+			if (typed && event.key === " ") {
+				event.preventDefault();
+				event.stopPropagation();
+				options.onTyping?.(true);
+			}
+			const newSession = typed === "";
+			if (newSession) previousIndex = options.selectedIndex?.() ?? options.activeIndex() ?? -1;
+			if (list.every((text, index) => text && available(index) ? text[0]?.toLowerCase() !== text[1]?.toLowerCase() : true) && typed === event.key) {
+				typed = "";
+				previousIndex = matchIndex ?? previousIndex;
+			}
+			typed += event.key;
+			clearTimeout(resetTimer);
+			resetTimer = setTimeout(reset, options.resetMs?.() ?? 750);
+			const start = (newSession ? options.selectedIndex?.() ?? options.activeIndex() ?? -1 : previousIndex) + 1;
+			const index = matchingIndex(typed, start);
+			if (index !== -1) {
+				if (options.context.state.open && event.key !== " ") {
+					event.preventDefault();
+					event.stopPropagation();
+				}
+				options.onTyping?.(true);
+				options.onMatch(index);
+				matchIndex = index;
+			} else if (event.key !== " ") reset();
+		},
+		onBlur(event) {
+			const next = event.relatedTarget;
+			if (!contains(options.context.state.domReferenceElement, next) && !contains(options.context.state.floatingElement, next)) reset();
+		}
+	};
+}
+//#endregion
+//#region src/internals/valueLabel.ts
+/** Serializes any value to the string a form submits for it. */
+function serializeValue(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function isGroupedItems(items) {
+	return Array.isArray(items) && items.length > 0 && typeof items[0] === "object" && items[0] != null && "items" in items[0];
+}
+function flattenItems(items) {
+	if (!Array.isArray(items)) return [];
+	if (isGroupedItems(items)) return items.flatMap((group) => group.items);
+	return items;
+}
+/** Whether an explicit `null` item carries a label that should win over a placeholder. */
+function hasNullItemLabel(items) {
+	if (items == null) return false;
+	if (!Array.isArray(items)) return "null" in items;
+	for (const item of flattenItems(items)) {
+		const labeled = item;
+		if (labeled && typeof labeled === "object" && labeled.value == null && labeled.label != null) return true;
+	}
+	return false;
+}
+/** The string form of an item as displayed to the user. */
+function stringifyAsLabel(item, itemToStringLabel) {
+	if (itemToStringLabel && item != null) return itemToStringLabel(item) ?? "";
+	if (item && typeof item === "object") {
+		if ("label" in item && item.label != null) return String(item.label);
+		if ("value" in item) return String(item.value);
+	}
+	return serializeValue(item);
+}
+/** The string form of an item as submitted with a form. */
+function stringifyAsValue(item, itemToStringValue) {
+	if (itemToStringValue && item != null) return itemToStringValue(item) ?? "";
+	if (item && typeof item === "object" && "value" in item && "label" in item) return serializeValue(item.value);
+	return serializeValue(item);
+}
+/** Resolves the renderable label for one selected value, falling back to its string form. */
+function resolveSelectedLabel(value, items, itemToStringLabel) {
+	const fallback = () => stringifyAsLabel(value, itemToStringLabel);
+	if (itemToStringLabel && value != null) return itemToStringLabel(value);
+	if (value && typeof value === "object" && "label" in value && value.label != null) return value.label;
+	if (items && !Array.isArray(items)) return items[String(value)] ?? fallback();
+	if (Array.isArray(items)) {
+		const flatItems = flattenItems(items);
+		if (value == null || typeof value !== "object") {
+			const match = flatItems.find((item) => item && item.value === value);
+			return match && match.label != null ? match.label : fallback();
+		}
+		if ("value" in value) {
+			const match = flatItems.find((item) => item && item.value === value.value);
+			if (match && match.label != null) return match.label;
+		}
+	}
+	return fallback();
+}
+/** Renders every selected value as a comma-separated label list. */
+function resolveMultipleLabels(values, items, itemToStringLabel) {
+	return values.flatMap((value, index) => {
+		const label = resolveSelectedLabel(value, items, itemToStringLabel);
+		return index === 0 ? [label] : [", ", label];
+	});
+}
+//#endregion
+//#region src/internals/filter.ts
+var filterCache = /* @__PURE__ */ new Map();
+function stringifyLocale(locale) {
+	if (Array.isArray(locale)) return locale.map((value) => stringifyLocale(value)).join(",");
+	if (locale == null) return "";
+	return String(locale);
+}
+/** Matches items against a query using `Intl.Collator` for robust string matching. */
+function getFilter(options = {}) {
+	const mergedOptions = {
+		usage: "search",
+		sensitivity: "base",
+		ignorePunctuation: true,
+		...options
+	};
+	const cacheKey = `${stringifyLocale(options.locale)}|${JSON.stringify(mergedOptions)}`;
+	const cachedFilter = filterCache.get(cacheKey);
+	if (cachedFilter) return cachedFilter;
+	const collator = new Intl.Collator(options.locale, mergedOptions);
+	const filter = {
+		contains(item, query, itemToString) {
+			if (!query) return true;
+			const itemString = stringifyAsLabel(item, itemToString);
+			for (let index = 0; index <= itemString.length - query.length; index += 1) if (collator.compare(itemString.slice(index, index + query.length), query) === 0) return true;
+			return false;
+		},
+		startsWith(item, query, itemToString) {
+			if (!query) return true;
+			const itemString = stringifyAsLabel(item, itemToString);
+			return collator.compare(itemString.slice(0, query.length), query) === 0;
+		},
+		endsWith(item, query, itemToString) {
+			if (!query) return true;
+			const itemString = stringifyAsLabel(item, itemToString);
+			const queryLength = query.length;
+			return itemString.length >= queryLength && collator.compare(itemString.slice(itemString.length - queryLength), query) === 0;
+		}
+	};
+	filterCache.set(cacheKey, filter);
+	return filter;
+}
+//#endregion
+//#region src/combobox/store/ComboboxItemRegistry.ts
+/**
+* The live registry of rendered `<Combobox.Item>` elements.
+*
+* Registration order seeds the position; once every item has an element the list is ordered by
+* document position so a reordered or conditionally rendered list keeps indices in sync with
+* what the user sees. An item that declares an explicit `index` keeps that index instead, which
+* is how externally virtualized and `items`-driven lists address their windowed rows.
+*/
+var ComboboxItemRegistry = class {
+	registrations = /* @__PURE__ */ new Map();
+	revision;
+	setRevision;
+	order = 0;
+	constructor() {
+		const [revision, setRevision] = createSignal(0, { ownedWrite: true });
+		this.revision = revision;
+		this.setRevision = setRevision;
+	}
+	register(item) {
+		const registration = {
+			...item,
+			order: this.order
+		};
+		this.order += 1;
+		this.registrations.set(item.token, registration);
+		this.touch();
+		return () => {
+			if (this.registrations.delete(item.token)) this.touch();
+		};
+	}
+	touch() {
+		this.setRevision((value) => value + 1);
+	}
+	items() {
+		this.revision();
+		return Array.from(this.registrations.values()).sort(compareItems);
+	}
+	/** The index the item at `token` occupies, or `-1` when it is not registered. */
+	indexOf(token) {
+		const items = this.items();
+		const position = items.findIndex((item) => item.token === token);
+		if (position === -1) return -1;
+		return items[position]?.index() ?? position;
+	}
+	/**
+	* DOM elements addressed by index. Explicit indices can leave holes, which list navigation
+	* treats as absent rather than disabled.
+	*/
+	elements() {
+		const items = this.items();
+		const elements = [];
+		items.forEach((item, position) => {
+			elements[item.index() ?? position] = item.element();
+		});
+		for (let index = 0; index < elements.length; index += 1) elements[index] ??= null;
+		return elements;
+	}
+	values() {
+		const items = this.items();
+		const values = [];
+		items.forEach((item, position) => {
+			values[item.index() ?? position] = item.value();
+		});
+		return values;
+	}
+	labels() {
+		return this.elements().map((element) => element?.textContent ?? null);
+	}
+	disabledIndices() {
+		return this.items().flatMap((item, position) => item.disabled() ? [item.index() ?? position] : []);
+	}
+	size() {
+		return this.items().length;
+	}
+};
+function compareItems(first, second) {
+	const firstIndex = first.index();
+	const secondIndex = second.index();
+	if (firstIndex !== void 0 && secondIndex !== void 0) return firstIndex - secondIndex;
+	const firstElement = first.element();
+	const secondElement = second.element();
+	if (firstElement && secondElement && firstElement !== secondElement && firstElement.isConnected && secondElement.isConnected) {
+		const position = firstElement.compareDocumentPosition(secondElement);
+		if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+		if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+	}
+	return first.order - second.order;
+}
+//#endregion
+//#region src/combobox/store/ComboboxStore.ts
+/**
+* A plain read/write pair. The setter always writes through a thunk so a value that happens to
+* be a function is stored rather than invoked as an updater.
+*/
+function signal(initial) {
+	const [read, write] = createSignal(() => initial, { ownedWrite: true });
+	return [read, (value) => {
+		write(() => value);
+	}];
+}
+/**
+* Combobox popup state shared by every part.
+*
+* The highlighted and selected positions are indices rather than elements because a combobox can
+* be driven by the `items` prop or by an external virtualizer, where no element exists for a row
+* until it is windowed in.
+*/
+var ComboboxStore = class extends PopupStore {
+	collection = new ComboboxItemRegistry();
+	/**
+	* Whether the last interaction came from the keyboard. Read at event time to attribute a
+	* highlight change, so it stays a plain field rather than a signal.
+	*/
+	keyboardActive = true;
+	/**
+	* The item element that received the last `pointerdown`, used to tell a click apart from the
+	* release of a drag-select gesture that started somewhere else.
+	*/
+	pointerDownItem = null;
+	/** A keyboard event standing in for the synthetic click it dispatched on the active item. */
+	selectionEvent = null;
+	chipsContainerElement = null;
+	clearElement = null;
+	emptyElement = null;
+	startDismissElement = null;
+	endDismissElement = null;
+	activeIndex;
+	setActiveIndex;
+	selectedIndex;
+	setSelectedIndex;
+	forceMounted;
+	setForceMounted;
+	labelId;
+	setLabelId;
+	listElement;
+	setListElement;
+	popupSide;
+	setPopupSide;
+	openMethod;
+	setOpenMethod;
+	/**
+	* Whether `<Combobox.Input>` is rendered inside the popup. That inverts the anatomy: the
+	* trigger becomes the labelled combobox control and the popup becomes a dialog.
+	*/
+	inputInsidePopup;
+	setInputInsidePopup;
+	inputOwnsFormValue;
+	setInputOwnsFormValue;
+	constructor(options) {
+		super(options);
+		[this.activeIndex, this.setActiveIndex] = signal(null);
+		[this.selectedIndex, this.setSelectedIndex] = signal(null);
+		[this.forceMounted, this.setForceMounted] = signal(false);
+		[this.labelId, this.setLabelId] = signal(void 0);
+		[this.listElement, this.setListElement] = signal(null);
+		[this.popupSide, this.setPopupSide] = signal(null);
+		[this.openMethod, this.setOpenMethod] = signal(null);
+		[this.inputInsidePopup, this.setInputInsidePopup] = signal(true);
+		[this.inputOwnsFormValue, this.setInputOwnsFormValue] = signal(false);
+	}
+	/** The item elements addressed by index, as list navigation and typeahead see them. */
+	elements() {
+		return this.collection.elements();
+	}
+	/**
+	* The popup side is only meaningful while the positioner is mounted; the store retains the last
+	* resolved side after the popup unmounts so an exit animation does not lose it.
+	*/
+	resolvedPopupSide() {
+		return this.track().mounted && this.track().positionerElement ? this.popupSide() : null;
+	}
+	resetAfterClose() {
+		this.setOpenMethod(null);
+		this.pointerDownItem = null;
+		this.selectionEvent = null;
+	}
+};
+//#endregion
+//#region src/combobox/root/ComboboxRootContext.ts
+var MISSING_ROOT = Symbol("ComboboxRootContext");
+var ComboboxRootContext = createContext(MISSING_ROOT);
+function useComboboxRootContext() {
+	const context = useContext(ComboboxRootContext);
+	if (context === MISSING_ROOT) throw new Error("Base UI: ComboboxRootContext is missing. Combobox parts must be placed within <Combobox.Root>.");
+	return context;
+}
+var MISSING_GROUP_COLLECTION = Symbol("ComboboxGroupCollectionContext");
+/** Scopes `<Combobox.Collection>` to the items of the enclosing `<Combobox.Group items>`. */
+var ComboboxGroupCollectionContext = createContext(MISSING_GROUP_COLLECTION);
+function useComboboxGroupCollectionContext() {
+	const context = useContext(ComboboxGroupCollectionContext);
+	return context === MISSING_GROUP_COLLECTION ? void 0 : context;
+}
+//#endregion
+//#region src/combobox/root/AriaCombobox.tsx
+var _tmpl$$1 = [
+	"<input",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	" tabindex=\"-1\" style=\"",
+	"\" aria-hidden=\"true\"",
+	"",
+	">"
+];
+var _tmpl$2 = [
+	"<input",
+	" type=\"hidden\"",
+	"",
+	"",
+	"",
+	">"
+];
+var HIDDEN_INPUT_STYLE = {
+	"clip-path": "inset(50%)",
+	overflow: "hidden",
+	"white-space": "nowrap",
+	border: "0",
+	padding: "0",
+	width: "1px",
+	height: "1px",
+	margin: "-1px",
+	position: "fixed",
+	top: "0",
+	left: "0"
+};
+var HIDDEN_NAMED_INPUT_STYLE = {
+	...HIDDEN_INPUT_STYLE,
+	position: "absolute"
+};
+/** Sentinel meaning "nothing has been highlighted yet", distinct from a real `undefined` value. */
+var NO_ACTIVE_VALUE = Symbol("none");
+var INITIAL_LAST_HIGHLIGHT = {
+	value: NO_ACTIVE_VALUE,
+	index: -1
+};
+/**
+* The shared combobox engine behind `Combobox.Root` and `Autocomplete.Root`.
+* @internal
+*/
+function AriaCombobox(props) {
+	var _v$, _g$2, _g$, _v$6;
+	const field = useFieldRootContext(true);
+	const formContext = useFormContext();
+	const labelable = useLabelableContext();
+	const direction = useDirection();
+	const inheritedTree = useFloatingTree();
+	const inheritedParentNodeId = useFloatingParentNodeId();
+	const tree = inheritedTree ?? new FloatingTreeStore();
+	const fieldControlSource = Symbol("Combobox");
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const floatingId = `base-ui-${createUniqueId()}`;
+	const nodeId = createUniqueId();
+	const controlledSelected = untrack(() => props.selectedValue !== void 0);
+	const controlledInput = untrack(() => props.inputValue !== void 0);
+	const controlledOpen = untrack(() => props.open !== void 0);
+	const hasInputValueProp = untrack(() => props.inputValue !== void 0 || props.defaultInputValue !== void 0);
+	const selectionMode = createMemo(() => props.selectionMode);
+	const multiple = createMemo(() => props.selectionMode === "multiple");
+	const single = createMemo(() => props.selectionMode === "single");
+	const comparator = createMemo(() => props.isItemEqualToValue ?? defaultItemEquality);
+	const itemToStringLabel = () => props.itemToStringLabel;
+	const itemToStringValue = () => props.itemToStringValue;
+	const initialSelectedValue = untrack(() => {
+		const defaultValue = props.defaultSelectedValue;
+		if (defaultValue !== void 0 && defaultValue !== null) return Array.isArray(defaultValue) ? defaultValue.slice() : defaultValue;
+		return props.selectionMode === "multiple" ? [] : defaultValue ?? null;
+	});
+	const [uncontrolledSelected, setUncontrolledSelected] = createSignal(() => initialSelectedValue);
+	const selectedValue = createMemo(() => controlledSelected ? props.selectedValue ?? null : uncontrolledSelected());
+	const initialDefaultInputValue = untrack(() => {
+		if (hasInputValueProp) return props.defaultInputValue ?? props.inputValue ?? "";
+		if (props.selectionMode === "single") return stringifyAsLabel(selectedValue(), props.itemToStringLabel);
+		return "";
+	});
+	const [uncontrolledInput, setUncontrolledInput] = createSignal(initialDefaultInputValue);
+	const inputValue = createMemo(() => controlledInput ? props.inputValue ?? "" : uncontrolledInput());
+	const [queryChangedAfterOpen, setQueryChangedAfterOpen] = createSignal(false);
+	const [closeQuery, setCloseQuery] = createSignal(null);
+	const [inputElement, setInputElement] = createSignal(null, { ownedWrite: true });
+	const [triggerElement, setTriggerElement] = createSignal(null, { ownedWrite: true });
+	const [inputGroupElement, setInputGroupElement] = createSignal(null, { ownedWrite: true });
+	const [internalBackdropElement, setInternalBackdropElement] = createSignal(null, { ownedWrite: true });
+	const [hiddenInputElement, setHiddenInputElement] = createSignal(null, { ownedWrite: true });
+	const id = createMemo(() => props.id ?? generatedId);
+	const disabled = createMemo(() => field.disabled() || (props.disabled ?? false));
+	const readOnly = createMemo(() => props.readOnly ?? false);
+	const required = createMemo(() => props.required ?? false);
+	const modal = createMemo(() => props.modal ?? false);
+	const grid = createMemo(() => props.grid ?? false);
+	const virtualized = createMemo(() => props.virtualized ?? false);
+	const inline = createMemo(() => props.inline ?? false);
+	const openOnInputClick = createMemo(() => props.openOnInputClick ?? true);
+	const keepHighlight = createMemo(() => props.keepHighlight ?? false);
+	const highlightItemOnHover = createMemo(() => props.highlightItemOnHover ?? true);
+	const loopFocus = createMemo(() => props.loopFocus ?? true);
+	const submitOnItemClick = createMemo(() => props.submitOnItemClick ?? false);
+	const autoCompleteMode = createMemo(() => props.autoComplete ?? "list");
+	const limit = createMemo(() => props.limit ?? -1);
+	const name = createMemo(() => field.name() ?? props.name);
+	const form = createMemo(() => props.form);
+	const hasItems = createMemo(() => props.items !== void 0);
+	const hasFilteredItemsProp = createMemo(() => props.filteredItems !== void 0);
+	const autoHighlight = createMemo(() => {
+		if (props.autoHighlight === "always") return "always";
+		return props.autoHighlight ? "input-change" : false;
+	});
+	const collatorFilter = createMemo(() => getFilter({ locale: props.locale }));
+	const filter = createMemo(() => {
+		if (props.filter === null) return () => true;
+		if (props.filter !== void 0) return props.filter;
+		const collator = collatorFilter();
+		const toLabel = props.itemToStringLabel;
+		return (item, query) => item == null ? false : collator.contains(item, query, toLabel);
+	});
+	const query = createMemo(() => closeQuery() ?? String(inputValue()).trim());
+	const selectedLabelString = createMemo(() => single() ? stringifyAsLabel(selectedValue(), props.itemToStringLabel) : "");
+	const shouldBypassFiltering = createMemo(() => {
+		const label = selectedLabelString();
+		const currentQuery = query();
+		return single() && !queryChangedAfterOpen() && currentQuery !== "" && label.length === currentQuery.length && collatorFilter().contains(label, currentQuery);
+	});
+	const filterQuery = createMemo(() => shouldBypassFiltering() ? "" : query());
+	const shouldIgnoreExternalFiltering = createMemo(() => hasItems() && hasFilteredItemsProp() && shouldBypassFiltering());
+	const flatItems = createMemo(() => flattenItems(props.items));
+	const filteredItems = createMemo(() => {
+		if (props.filteredItems !== void 0 && !shouldIgnoreExternalFiltering()) return props.filteredItems;
+		const items = props.items;
+		if (items === void 0) return [];
+		const currentQuery = filterQuery();
+		const currentLimit = limit();
+		const match = filter();
+		const toLabel = props.itemToStringLabel;
+		if (isGroupedItems(items)) {
+			const resultingGroups = [];
+			let currentCount = 0;
+			for (const group of items) {
+				if (currentLimit > -1 && currentCount >= currentLimit) break;
+				const remainingLimit = currentLimit > -1 ? currentLimit - currentCount : Infinity;
+				const itemsToTake = currentQuery === "" ? group.items.slice(0, remainingLimit) : [];
+				if (currentQuery !== "") for (const item of group.items) {
+					if (itemsToTake.length >= remainingLimit) break;
+					if (match(item, currentQuery, toLabel)) itemsToTake.push(item);
+				}
+				if (itemsToTake.length > 0) {
+					resultingGroups.push({
+						...group,
+						items: itemsToTake
+					});
+					currentCount += itemsToTake.length;
+				}
+			}
+			return resultingGroups;
+		}
+		const flat = flatItems();
+		if (currentQuery === "") return currentLimit > -1 ? flat.slice(0, currentLimit) : flat;
+		const limitedItems = [];
+		for (const item of flat) {
+			if (currentLimit > -1 && limitedItems.length >= currentLimit) break;
+			if (match(item, currentQuery, toLabel)) limitedItems.push(item);
+		}
+		return limitedItems;
+	});
+	const flatFilteredItems = createMemo(() => {
+		const current = filteredItems();
+		return isGroupedItems(current) ? current.flatMap((group) => group.items) : current;
+	});
+	const listEmpty = createMemo(() => filteredItems().length === 0);
+	let hadInputClear = false;
+	let lastHighlight = INITIAL_LAST_HIGHLIGHT;
+	let pendingQueryHighlight = null;
+	let pendingInitialHighlight = null;
+	let initializedOpen = false;
+	let previousSelectedValue = cloneValue(untrack(selectedValue));
+	let previousInputValue = untrack(inputValue);
+	let previousItems = untrack(() => props.items);
+	let previousQuery = untrack(query);
+	const store = new ComboboxStore({
+		controlledOpen: () => controlledOpen ? props.open : void 0,
+		floatingId,
+		nodeId,
+		onOpenChange: () => (open, details) => {
+			if (store.open() === open) return;
+			if (!open && props.actionsRef) details.preventUnmountOnClose();
+			if (details.reason === "escape-key" && hasItems() && flatFilteredItems().length === 0 && !store.emptyElement) details.allowPropagation();
+			props.onOpenChange?.(open, details);
+			if (details.isCanceled) return;
+			applyOpenSideEffects(open, details);
+		},
+		onOpenChangeComplete: () => props.onOpenChangeComplete
+	});
+	store.update({ open: untrack(() => props.open ?? props.defaultOpen ?? false) });
+	store.configureTriggerUnmount({ closeOnActiveTriggerUnmount: false });
+	store.setInputOwnsFormValue(untrack(() => props.selectionMode === "none"));
+	const node = createFloatingNode({
+		tree,
+		id: nodeId,
+		parentId: inheritedParentNodeId,
+		context: () => store.context.floatingRoot
+	});
+	const presence = createPopupPresence(store, () => resolvedAnimatedElement(), { onUnmount: () => handleUnmount() });
+	/**
+	* The element whose exit animation gates the unmount. An inline list has no popup of its own,
+	* so a `Dialog` composed around it owns the animation; `[role="dialog"]` is more interoperable
+	* than a context here because it also works with third-party modal libraries.
+	*/
+	function resolvedAnimatedElement() {
+		if (inline()) return store.track().positionerElement?.closest("[role=\"dialog\"]") ?? null;
+		return store.track().popupElement;
+	}
+	/** Item values addressed by index, from `items` when provided and rendered items otherwise. */
+	const itemValues = createMemo(() => hasItems() || hasFilteredItemsProp() ? flatFilteredItems() : store.collection.values());
+	createMemo(() => {
+		const rendered = store.collection.labels();
+		if (!hasItems()) return rendered;
+		const derived = flatFilteredItems().map((item) => stringifyAsLabel(item, props.itemToStringLabel));
+		if (!store.forceMounted()) return derived;
+		return derived.map((label, index) => rendered[index] ?? label);
+	});
+	const listElements = createMemo(() => {
+		const elements = store.collection.elements();
+		const length = itemValues().length;
+		if (elements.length < length) elements.length = length;
+		return elements;
+	});
+	/** Columns inferred from the first rendered `<Combobox.Row>`, for grid navigation. */
+	const cols = createMemo(() => {
+		if (!grid()) return 1;
+		store.collection.items();
+		const row = store.listElement()?.querySelector("[role=\"row\"]");
+		return Math.max(1, row?.childElementCount ?? 1);
+	});
+	const hasSelectedValue = createMemo(() => {
+		const current = selectedValue();
+		if (current == null) return false;
+		if (multiple() && Array.isArray(current)) return current.length > 0;
+		return true;
+	});
+	const hasSelectionChips = createMemo(() => {
+		const current = selectedValue();
+		return Array.isArray(current) && current.length > 0;
+	});
+	const fieldRawValue = createMemo(() => selectionMode() === "none" ? inputValue() : selectedValue());
+	const fieldStringValue = createMemo(() => {
+		if (selectionMode() === "none") return inputValue();
+		const current = selectedValue();
+		return Array.isArray(current) ? current.map((value) => stringifyAsValue(value, props.itemToStringValue)) : stringifyAsValue(current, props.itemToStringValue);
+	});
+	const serializedValue = createMemo(() => {
+		const raw = fieldRawValue();
+		return Array.isArray(raw) ? "" : stringifyAsValue(raw, props.itemToStringValue);
+	});
+	const hiddenInputName = createMemo(() => multiple() || selectionMode() === "none" && store.inputOwnsFormValue() ? void 0 : name());
+	function emitHighlight(value, index, type) {
+		if (index === -1) {
+			if (lastHighlight === INITIAL_LAST_HIGHLIGHT) return;
+			lastHighlight = INITIAL_LAST_HIGHLIGHT;
+		} else lastHighlight = {
+			value,
+			index
+		};
+		props.onItemHighlighted?.(value, createGenericEventDetails(type, void 0, { index }));
+	}
+	function setIndices(update) {
+		if (update.selectedIndex !== void 0) store.setSelectedIndex(update.selectedIndex);
+		if (update.activeIndex === void 0) return;
+		store.setActiveIndex(update.activeIndex);
+		const type = update.type || "none";
+		if (update.activeIndex === null) emitHighlight(void 0, -1, type);
+		else emitHighlight(untrack(itemValues)[update.activeIndex], update.activeIndex, type);
+	}
+	/** Resets a non-virtualized list's own scroller so a new query starts at the top. */
+	function resetListScroll() {
+		const list = store.listElement();
+		if (virtualized() || !list) return;
+		const popup = store.track().popupElement;
+		let node = list.firstElementChild ?? list;
+		while (isHTMLElement(node)) {
+			if (popup ? !contains(popup, node) : node.getAttribute("role") === "dialog") break;
+			if (isScrollableY(node)) {
+				node.scrollTop = 0;
+				break;
+			}
+			node = node.parentElement;
+		}
+	}
+	function setInputValue(next, details) {
+		hadInputClear = details.reason === inputClear;
+		props.onInputValueChange?.(next, details);
+		if (details.isCanceled) return;
+		if (details.reason === "input-change") {
+			if (store.open() && closeQuery() !== null) setCloseQuery(null);
+			const event = details.event;
+			const inputType = event.inputType;
+			if (event.type === "compositionend" || inputType != null && inputType !== "" && inputType !== "insertReplacementText") {
+				const hasQuery = next.trim() !== "";
+				if (hasQuery) setQueryChangedAfterOpen(true);
+				pendingQueryHighlight = { hasQuery };
+				resetListScroll();
+				if (hasQuery && autoHighlight() && store.activeIndex() == null && (store.open() || inline())) store.setActiveIndex(0);
+			}
+		} else if (details.reason === "input-clear" && next === "" && store.inputInsidePopup()) pendingQueryHighlight = {
+			hasQuery: false,
+			selection: true
+		};
+		if (!controlledInput) setUncontrolledInput(next);
+	}
+	function setOpen(nextOpen, details) {
+		return store.setOpen(nextOpen, details);
+	}
+	/**
+	* Runs after the change is accepted but before it commits, so `store.open()` still reports the
+	* state being left behind.
+	*/
+	function applyOpenSideEffects(nextOpen, details) {
+		if (nextOpen && store.inputInsidePopup() && !inline() && closeQuery() !== null) {
+			setQueryChangedAfterOpen(false);
+			setCloseQuery(null);
+			if (inputValue() !== "" && details.reason !== "input-change") setInputValue("", createChangeEventDetails(inputClear, details.event));
+		}
+		if (!nextOpen && queryChangedAfterOpen()) {
+			const currentQuery = query();
+			if (single()) {
+				if (!inline()) setCloseQuery(currentQuery);
+				if (currentQuery === "") setQueryChangedAfterOpen(false);
+			} else if (multiple()) {
+				if (!inline()) setCloseQuery(currentQuery);
+				if (store.inputInsidePopup()) setIndices({ activeIndex: null });
+				if (!store.inputInsidePopup() || inline()) setInputValue("", createChangeEventDetails(inputClear, details.event));
+			}
+		}
+		if (!nextOpen && store.inputInsidePopup() && (details.reason === "focus-out" || details.reason === "outside-press")) {
+			field.setTouched(true);
+			field.setFocused(false);
+			if (field.validationMode() === "onBlur") field.validation.commit(untrack(fieldRawValue));
+		}
+	}
+	function setSelectedValue(next, details) {
+		props.onSelectedValueChange?.(next, details);
+		if (details.isCanceled) return;
+		if (!controlledSelected) setUncontrolledSelected(() => next);
+		if (selectionMode() === "none" && store.track().popupElement != null && (props.fillInputOnItemPress ?? true) || single() && !store.inputInsidePopup()) setInputValue(stringifyAsLabel(next, props.itemToStringLabel), createChangeEventDetails(details.reason, details.event));
+	}
+	function handleSelection(event, itemValue) {
+		const target = event.target;
+		const overrideEvent = store.selectionEvent ?? event;
+		store.selectionEvent = null;
+		const details = createChangeEventDetails(itemPress, overrideEvent);
+		const href = target?.closest("a")?.getAttribute("href");
+		if (href) {
+			if (href.startsWith("#")) setOpen(false, details);
+			return;
+		}
+		if (multiple()) {
+			const current = Array.isArray(selectedValue()) ? selectedValue() : [];
+			setSelectedValue(selectedValueIncludes(current, itemValue, comparator()) ? removeItem(current, itemValue, comparator()) : [...current, itemValue], details);
+			if (details.isCanceled) return;
+			if (!((inputElement()?.value.trim() ?? "") !== "")) return;
+			if (store.inputInsidePopup()) setInputValue("", createChangeEventDetails(inputClear, details.event));
+			else setOpen(false, details);
+			return;
+		}
+		setSelectedValue(itemValue, details);
+		if (details.isCanceled) return;
+		setOpen(false, details);
+	}
+	function requestSubmit() {
+		const formElement = field.validation.getInputControl()?.closest("form") ?? hiddenInputElement()?.form ?? inputElement()?.form;
+		if (formElement && typeof formElement.requestSubmit === "function") formElement.requestSubmit();
+	}
+	function forceMount() {
+		if (props.items) return;
+		store.setForceMounted(true);
+	}
+	function focusInput() {
+		inputElement()?.focus();
+	}
+	function clickHighlightedItem(index, event) {
+		const item = untrack(listElements)[index];
+		if (!item) return;
+		store.selectionEvent = event;
+		item.click();
+		store.selectionEvent = null;
+	}
+	function handleUnmount() {
+		setQueryChangedAfterOpen(false);
+		setCloseQuery(null);
+		store.resetAfterClose();
+		if (selectionMode() === "none") setIndices({
+			activeIndex: null,
+			selectedIndex: null
+		});
+		else setIndices({ activeIndex: null });
+		const currentInput = inputElement();
+		if (multiple() && currentInput && currentInput.value !== "" && !hadInputClear) setInputValue("", createChangeEventDetails(inputClear));
+		if (single()) {
+			if (store.inputInsidePopup()) {
+				if (currentInput && currentInput.value !== "") setInputValue("", createChangeEventDetails(inputClear));
+			} else {
+				const label = stringifyAsLabel(selectedValue(), props.itemToStringLabel);
+				if (currentInput && currentInput.value !== label) setInputValue(label, createChangeEventDetails(label === "" ? inputClear : none));
+			}
+		}
+	}
+	const actions = { unmount() {
+		presence.forceUnmount();
+	} };
+	const expanded = createMemo(() => store.open() || inline());
+	const referenceAria = createMemo(() => {
+		const element = inputElement();
+		const isPlainInput = element?.tagName === "INPUT";
+		const treatAsInput = element == null || isPlainInput;
+		const applyAria = treatAsInput || expanded();
+		const reference = treatAsInput ? {
+			autocomplete: "off",
+			spellcheck: "false",
+			autocorrect: "off",
+			autocapitalize: "none"
+		} : {};
+		if (applyAria) {
+			reference.role = "combobox";
+			reference["aria-expanded"] = expanded() ? "true" : "false";
+			reference["aria-haspopup"] = grid() ? "grid" : "listbox";
+			reference["aria-controls"] = expanded() ? store.listElement()?.id : void 0;
+			reference["aria-autocomplete"] = autoCompleteMode();
+		}
+		return reference;
+	});
+	const click = createClickInteraction({
+		context: store.context.floatingRoot,
+		enabled: () => !readOnly() && !disabled() && openOnInputClick(),
+		event: () => "mousedown-only",
+		toggle: () => false,
+		reason: () => inputPress,
+		touchOpenDelay: () => store.inputInsidePopup() ? 0 : 100
+	});
+	const dismiss = createDismiss({
+		context: store.context.floatingRoot,
+		tree: () => tree,
+		enabled: () => !readOnly() && !disabled() && !inline(),
+		outsidePressEvent: () => ({
+			mouse: "sloppy",
+			touch: "intentional"
+		}),
+		bubbles: () => inline(),
+		outsidePress: () => (event) => {
+			const target = event.target;
+			return !contains(triggerElement(), target) && !contains(store.clearElement, target) && !contains(store.chipsContainerElement, target) && !contains(inputGroupElement(), target);
+		}
+	});
+	const listNavigation$1 = createListNavigation({
+		context: store.context.floatingRoot,
+		enabled: () => !readOnly() && !disabled(),
+		list: listElements,
+		activeIndex: store.activeIndex,
+		selectedIndex: store.selectedIndex,
+		virtual: () => true,
+		loopFocus,
+		allowEscape: () => loopFocus() && !autoHighlight(),
+		focusItemOnHover: highlightItemOnHover,
+		orientation: () => grid() ? "both" : "vertical",
+		cols,
+		rtl: () => direction() === "rtl",
+		openOnArrowKeyDown: () => false,
+		disabledIndices: () => [],
+		onNavigate(index, event) {
+			if (!event && !store.open() || store.track().transitionStatus === "ending") return;
+			if (!event) {
+				setIndices({ activeIndex: index });
+				return;
+			}
+			setIndices({
+				activeIndex: index,
+				type: store.keyboardActive ? keyboard : pointer
+			});
+		}
+	});
+	const context = {
+		store,
+		tree,
+		node,
+		presence,
+		id,
+		items: () => props.items,
+		hasItems,
+		query,
+		filteredItems,
+		flatFilteredItems,
+		listEmpty,
+		itemValues,
+		selectedValue,
+		inputValue,
+		hasSelectedValue,
+		hasSelectionChips,
+		selectionMode,
+		multiple,
+		single,
+		disabled,
+		readOnly,
+		required,
+		modal,
+		grid,
+		virtualized,
+		inline,
+		openOnInputClick,
+		autoHighlight,
+		keepHighlight,
+		highlightItemOnHover,
+		loopFocus,
+		autoComplete: autoCompleteMode,
+		submitOnItemClick,
+		hasInputValueProp: () => hasInputValueProp,
+		name,
+		form,
+		itemToStringLabel,
+		itemToStringValue,
+		comparator,
+		inputElement,
+		setInputElement,
+		triggerElement,
+		setTriggerElement,
+		inputGroupElement,
+		setInputGroupElement,
+		internalBackdropElement,
+		setInternalBackdropElement,
+		setOpen,
+		setInputValue,
+		setSelectedValue,
+		setIndices,
+		handleSelection,
+		forceMount,
+		requestSubmit,
+		focusInput,
+		clickHighlightedItem,
+		listNavigation: listNavigation$1,
+		dismiss,
+		click,
+		cols,
+		referenceAria,
+		expanded,
+		field,
+		formContext
+	};
+	const registration = {
+		id: generatedId,
+		name: void 0,
+		value: fieldRawValue,
+		getValue: fieldStringValue,
+		getControl: () => store.inputInsidePopup() ? triggerElement() : inputElement()
+	};
+	store.context.floatingRoot.context.data.insideElements = () => [
+		internalBackdropElement(),
+		store.startDismissElement,
+		store.endDismissElement
+	];
+	createEffect(() => ({
+		open: store.open(),
+		activeTriggerId: store.activeTriggerId()
+	}), () => untrack(() => store.reconcileTriggers()));
+	createEffect(() => ({
+		inline: inline(),
+		open: store.open()
+	}), (state) => {
+		if (state.inline) store.context.floatingRoot.update({ open: true });
+	});
+	createEffect(() => ({
+		mode: selectionMode(),
+		inline: inline(),
+		insidePopup: store.inputInsidePopup()
+	}), (state) => store.setInputOwnsFormValue(state.mode === "none" && (state.inline || !state.insidePopup)));
+	createEffect(() => ({
+		open: store.open(),
+		selected: selectedValue(),
+		mode: selectionMode(),
+		values: itemValues(),
+		compare: comparator(),
+		isMultiple: multiple()
+	}), (state) => {
+		if (state.open) return;
+		store.pointerDownItem = null;
+		if (state.mode === "none") return;
+		untrack(() => setIndices({ selectedIndex: findSelectionIndex(hasItems() ? flatItems() : state.values, state.selected, state.compare, state.isMultiple) }));
+	});
+	createEffect(() => ({
+		activeIndex: store.activeIndex(),
+		values: itemValues(),
+		input: inputValue(),
+		open: store.open(),
+		inline: inline(),
+		highlight: autoHighlight()
+	}), (state) => untrack(() => resolveHighlight(state)));
+	function resolveHighlight(state) {
+		const pending = pendingQueryHighlight;
+		if (pending) {
+			const listIsNavigable = state.open || state.inline || store.track().positionerElement?.hidden === false;
+			if (pending.hasQuery) {
+				if (state.highlight && listIsNavigable) store.setActiveIndex(0);
+				pendingQueryHighlight = null;
+			} else if (String(state.input).trim() === "") {
+				pendingQueryHighlight = null;
+				if (listIsNavigable) {
+					const clearedBySelection = pending.selection;
+					if (state.highlight === "always" && !clearedBySelection && selectionMode() === "none") store.setActiveIndex(0);
+					queueMicrotask(() => untrack(() => {
+						if (!store.open() && !inline() || (inputElement()?.value.trim() ?? "") !== "") return;
+						const current = selectedValue();
+						const isMultiple = multiple();
+						const lastSelected = isMultiple && Array.isArray(current) ? current[current.length - 1] : current;
+						const hasSelection = selectionMode() !== "none" && lastSelected != null;
+						if (hasSelection || clearedBySelection) store.setActiveIndex(hasSelection ? findSelectionIndex(itemValues(), current, comparator(), isMultiple) : null);
+						else if (autoHighlight() === "always") store.setActiveIndex(0);
+					}));
+				}
+			}
+		}
+		if (!state.open && !state.inline) return;
+		if (state.activeIndex == null) {
+			if (state.highlight === "always" && state.values.length > 0) {
+				store.setActiveIndex(0);
+				return;
+			}
+			emitHighlight(void 0, -1, none);
+			return;
+		}
+		if (state.activeIndex >= state.values.length) {
+			emitHighlight(void 0, -1, none);
+			store.setActiveIndex(null);
+			return;
+		}
+		const itemValue = state.values[state.activeIndex];
+		const previousValue = lastHighlight.value;
+		const sameItem = previousValue !== NO_ACTIVE_VALUE && compareItemEquality(itemValue, previousValue, comparator());
+		if (lastHighlight.index !== state.activeIndex || !sameItem) emitHighlight(itemValue, state.activeIndex, none);
+	}
+	createEffect(() => ({
+		index: store.activeIndex(),
+		elements: listElements()
+	}), (state) => {
+		if (state.index == null || !store.keyboardActive) return;
+		state.elements[state.index]?.scrollIntoView?.({
+			block: "nearest",
+			inline: "nearest"
+		});
+	});
+	createEffect(() => ({
+		open: store.open(),
+		mounted: presence.mounted(),
+		count: itemValues().length
+	}), (state) => {
+		if (!state.open) {
+			initializedOpen = false;
+			pendingInitialHighlight = null;
+			return;
+		}
+		if (!state.mounted || state.count === 0 || initializedOpen) return;
+		initializedOpen = true;
+		untrack(() => {
+			const pending = pendingInitialHighlight;
+			pendingInitialHighlight = null;
+			if (store.activeIndex() != null || queryChangedAfterOpen()) return;
+			const selected = selectionMode() === "none" ? null : store.selectedIndex();
+			if (selected != null) {
+				setIndices({ activeIndex: selected });
+				return;
+			}
+			if (pending && (selectionMode() !== "none" || autoHighlight() !== false)) {
+				setIndices({ activeIndex: pending === "first" ? 0 : state.count - 1 });
+				return;
+			}
+			if (autoHighlight() === "always") setIndices({ activeIndex: 0 });
+		});
+	});
+	createEffect(() => ({
+		mode: selectionMode(),
+		input: inputValue(),
+		selected: selectedValue(),
+		isMultiple: multiple()
+	}), (state) => {
+		if (state.mode === "none") {
+			field.setFilled(String(state.input) !== "");
+			return;
+		}
+		field.setFilled(state.isMultiple ? Array.isArray(state.selected) && state.selected.length > 0 : state.selected != null);
+	});
+	createEffect(() => ({
+		hasItems: hasItems(),
+		highlight: autoHighlight(),
+		count: flatFilteredItems().length
+	}), (state) => {
+		if (state.hasItems && state.highlight && state.count === 0) untrack(() => setIndices({ activeIndex: null }));
+	});
+	createEffect(() => ({
+		query: query(),
+		open: store.open()
+	}), (state) => {
+		const previous = previousQuery;
+		previousQuery = state.query;
+		if (previous === state.query || !state.open) return;
+		if (state.query === "" || state.query === String(initialDefaultInputValue)) return;
+		setQueryChangedAfterOpen(true);
+	});
+	function syncInputToSelectedLabel() {
+		const label = stringifyAsLabel(selectedValue(), props.itemToStringLabel);
+		if (inputValue() !== label) setInputValue(label, createChangeEventDetails(none));
+	}
+	createEffect(() => ({
+		selected: selectedValue(),
+		mode: selectionMode(),
+		compare: comparator()
+	}), (state) => {
+		const previous = previousSelectedValue;
+		if (sameValue(state.selected, previous, state.compare)) return;
+		previousSelectedValue = cloneValue(state.selected);
+		if (state.mode === "none") return;
+		untrack(() => {
+			formContext.clearError(name());
+			field.setDirty(!sameDirtyValue(state.selected, field.validityData().initialValue, state.compare));
+			field.validation.change(state.selected);
+			if (single() && !hasInputValueProp && !store.inputInsidePopup()) syncInputToSelectedLabel();
+		});
+	});
+	createEffect(() => ({
+		input: inputValue(),
+		mode: selectionMode()
+	}), (state) => {
+		const previous = previousInputValue;
+		previousInputValue = state.input;
+		if (previous === state.input || state.mode !== "none") return;
+		untrack(() => {
+			formContext.clearError(name());
+			field.setDirty(state.input !== field.validityData().initialValue);
+			field.validation.change(state.input);
+		});
+	});
+	createEffect(() => props.items, (items) => {
+		const previous = previousItems;
+		previousItems = items;
+		if (previous === items) return;
+		untrack(() => {
+			if (!single() || hasInputValueProp || store.inputInsidePopup() || queryChangedAfterOpen()) return;
+			syncInputToSelectedLabel();
+		});
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		id: id(),
+		name: props.name,
+		control: store.inputInsidePopup() ? triggerElement() : inputElement()
+	}), (current) => {
+		registration.id = current.id;
+		registration.name = current.name;
+		field.registerFieldControl(fieldControlSource, current.disabled || !current.control ? void 0 : registration);
+	});
+	createEffect(hiddenInputElement, (input) => {
+		if (!input) return;
+		return field.validation.registerInput(fieldControlSource, input, () => store.inputInsidePopup() ? triggerElement() : inputElement());
+	});
+	createEffect(() => props.actionsRef, (actionsRef) => {
+		actionsRef?.(actions);
+	});
+	/** Opens the popup from a closed arrow-key press, remembering which end to highlight. */
+	function openWithNavigation(edge, event) {
+		pendingInitialHighlight = edge;
+		store.setOpenMethod("keyboard");
+		if (!setOpen(true, createChangeEventDetails("list-navigation", event, triggerElement() ?? void 0))) pendingInitialHighlight = null;
+	}
+	function handleNavigationKeyDown(event) {
+		if (readOnly() || disabled()) return;
+		if (!store.open() && !inline()) {
+			if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+			event.preventDefault();
+			event.stopPropagation();
+			openWithNavigation(event.key === "ArrowDown" ? "first" : "last", event);
+			return;
+		}
+		listNavigation$1.onKeyDown(event);
+	}
+	context.listNavigation = {
+		...listNavigation$1,
+		onKeyDown: handleNavigationKeyDown
+	};
+	onCleanup(() => {
+		field.registerFieldControl(fieldControlSource, void 0);
+		store.clearInteractionProps();
+		delete store.context.floatingRoot.context.data.insideElements;
+	});
+	return ComboboxRootContext({
+		value: context,
+		get children() {
+			return FloatingTreeContext({
+				value: tree,
+				get children() {
+					return FloatingParentNodeContext({
+						get value() {
+							return node.id ?? null;
+						},
+						get children() {
+							return [
+								memo(() => {
+									return escape(props.children);
+								}),
+								(_v$ = ssrHydrationKey(), props.inputRef, _g$2 = ssrGroup(() => {
+									return [
+										ssrAttribute("id", hiddenInputName() == null ? `${escape(id(), true)}-hidden-input` : escape(void 0, true)),
+										ssrAttribute("form", escape(form(), true)),
+										ssrAttribute("name", escape(hiddenInputName(), true)),
+										ssrAttribute("autocomplete", escape(props.formAutoComplete, true))
+									];
+								}, 4), _g$ = ssrGroup(() => {
+									return [
+										ssrAttribute("disabled", escape(disabled(), true)),
+										ssrAttribute("required", required() && !(multiple() && hasSelectionChips())),
+										ssrAttribute("readonly", escape(readOnly(), true)),
+										ssrStyle(hiddenInputName() ? HIDDEN_NAMED_INPUT_STYLE : HIDDEN_INPUT_STYLE),
+										ssrAttribute("aria-describedby", escape(labelable.getAriaDescribedBy(void 0), true)),
+										ssrAttribute("aria-invalid", field.state().valid === false && !disabled() ? "true" : escape(void 0, true))
+									];
+								}, 6), _v$6 = () => {
+									return ssrAttribute("value", escape(serializedValue(), true));
+								}, ssr(_tmpl$$1, _v$, _g$2, _g$2, _g$2, _g$2, _v$6, _g$, _g$, _g$, _g$, _g$, _g$)),
+								For({
+									get each() {
+										return memo(() => {
+											return !!(multiple() && name());
+										})() ? selectedValue() ?? [] : [];
+									},
+									children: (item) => {
+										var _v$13, _g$3, _v$17, _v$16;
+										return _v$13 = ssrHydrationKey(), _g$3 = ssrGroup(() => {
+											return [ssrAttribute("form", escape(form(), true)), ssrAttribute("name", escape(name(), true))];
+										}, 2), _v$17 = () => {
+											return ssrAttribute("disabled", escape(disabled(), true));
+										}, _v$16 = () => {
+											return ssrAttribute("value", escape(stringifyAsValue(item, props.itemToStringValue), true));
+										}, ssr(_tmpl$2, _v$13, _g$3, _g$3, _v$16, _v$17);
+									}
+								})
+							];
+						}
+					});
+				}
+			});
+		}
+	});
+}
+function cloneValue(value) {
+	return Array.isArray(value) ? value.slice() : value;
+}
+function sameValue(first, second, comparer) {
+	if (Array.isArray(first) && Array.isArray(second)) return areItemArraysEqual(first, second, comparer);
+	return Object.is(first, second);
+}
+function sameDirtyValue(current, initial, comparer) {
+	if (Array.isArray(current) && Array.isArray(initial)) return areItemArraysEqual(current, initial, comparer);
+	return current === initial;
+}
+//#endregion
+//#region src/combobox/utils/comboboxPopupId.ts
+/**
+* The default id `<Combobox.Popup>` takes when the input is rendered inside it. The popup applies
+* it and the trigger references it through `aria-controls`, so the convention lives in one place.
+*/
+function getComboboxPopupId(rootId) {
+	return rootId == null ? void 0 : `${rootId}-popup`;
+}
+//#endregion
+//#region src/combobox/utils/stateAttributesMapping.ts
+/** Shared by the input, input group, and trigger, which all reflect the popup's state. */
+var comboboxControlStateMapping = {
+	...pressableTriggerOpenStateMapping,
+	...fieldStateAttributesMapping,
+	popupSide: (side) => side ? { "data-popup-side": side } : null,
+	listEmpty: (empty) => empty ? { "data-list-empty": "" } : null
+};
+var comboboxPositionerStateMapping = { ...popupStateMapping };
+var comboboxPopupStateMapping = {
+	...popupTransitionStateMapping,
+	instant: (value) => value ? { "data-instant": value } : null
+};
+var POPUP_OPEN = { "data-open": "" };
+var POPUP_CLOSED = { "data-closed": "" };
+var comboboxBackdropStateMapping = {
+	open: (value) => value ? POPUP_OPEN : POPUP_CLOSED,
+	...transitionStatusMapping
+};
+var comboboxClearStateMapping = {
+	...triggerOpenStateMapping,
+	...transitionStatusMapping
+};
+//#endregion
+//#region src/combobox/trigger/ComboboxTrigger.tsx
+/** A button that opens the popup. */
+function ComboboxTrigger(props) {
+	const context = useComboboxRootContext();
+	const labelable = useLabelableContext();
+	const internalProps = props;
+	const allProps = props;
+	const labelSource = Symbol("ComboboxTrigger");
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? true);
+	const disabled = createMemo(() => context.disabled() || (internalProps.disabled ?? false));
+	const insidePopup = createMemo(() => context.store.inputInsidePopup());
+	const id = createMemo(() => insidePopup() ? internalProps.id ?? context.id() : internalProps.id);
+	const ariaControls = createMemo(() => {
+		if (!context.store.open()) return;
+		if (insidePopup()) return context.store.popupId() ?? getComboboxPopupId(context.id());
+		return context.store.listElement()?.id;
+	});
+	const ariaLabelledBy = createMemo(() => internalProps["aria-labelledby"] ?? labelable.labelId() ?? context.store.labelId());
+	const state = createMemo(() => ({
+		...context.field.state(),
+		open: context.store.open(),
+		disabled: disabled(),
+		popupSide: context.store.resolvedPopupSide(),
+		listEmpty: context.listEmpty(),
+		placeholder: context.selectionMode() === "none" ? false : !context.hasSelectedValue()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxControlStateMapping));
+	const others = omit(allProps, "aria-labelledby", "as", "class", "disabled", "id", "nativeButton", "onBlur", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onMouseDown", "onPointerDown", "onPointerEnter", "ref", "style");
+	const click = createClickInteraction({
+		context: context.store.context.floatingRoot,
+		enabled: () => !context.readOnly() && !context.disabled(),
+		event: () => "mousedown"
+	});
+	const typeahead = createTypeahead({
+		context: context.store.context.floatingRoot,
+		enabled: () => !context.store.open() && !context.readOnly() && !context.disabled() && context.selectionMode() === "single",
+		list: () => context.store.collection.labels(),
+		elements: () => context.store.collection.elements(),
+		activeIndex: context.store.activeIndex,
+		selectedIndex: context.store.selectedIndex,
+		onMatch(index) {
+			const next = context.itemValues()[index];
+			if (next !== void 0) context.setSelectedValue(next, createChangeEventDetails(none));
+		}
+	});
+	let pointerType = "";
+	let focusTimer;
+	let removeMouseUp;
+	createTriggerRegistration(() => context.store, id, element);
+	function handlePointerDown(event) {
+		pointerType = event.pointerType || "";
+		click.onPointerDown(event);
+	}
+	function handleFocus() {
+		context.field.setFocused(true);
+		if (disabled() || context.readOnly()) return;
+		clearTimeout(focusTimer);
+		focusTimer = setTimeout(() => context.forceMount(), 0);
+	}
+	function handleBlur(event) {
+		untrack(() => {
+			if (contains(context.store.track().positionerElement, event.relatedTarget)) return;
+			context.field.setTouched(true);
+			context.field.setFocused(false);
+			if (context.field.validationMode() === "onBlur") context.field.validation.commit(context.selectionMode() === "none" ? context.inputValue() : context.selectedValue());
+			typeahead.onBlur(event);
+		});
+	}
+	function watchCancelOpen(trigger) {
+		removeMouseUp?.();
+		const documentNode = ownerDocument(trigger);
+		const onMouseUp = (event) => {
+			removeMouseUp = void 0;
+			const target = event.target;
+			if (contains(trigger, target) || contains(context.store.track().positionerElement, target) || contains(context.store.listElement(), target)) return;
+			const rect = trigger.getBoundingClientRect();
+			if (event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom) return;
+			context.setOpen(false, createChangeEventDetails(cancelOpen, event));
+		};
+		documentNode.addEventListener("mouseup", onMouseUp, { once: true });
+		removeMouseUp = () => documentNode.removeEventListener("mouseup", onMouseUp);
+	}
+	function handleMouseDown(event) {
+		if (disabled() || context.readOnly()) return;
+		const trigger = event.currentTarget;
+		if (!insidePopup()) context.store.context.floatingRoot.update({ domReferenceElement: trigger });
+		context.forceMount();
+		if (pointerType !== "touch") {
+			context.focusInput();
+			if (!insidePopup()) event.preventDefault();
+		}
+		if (!context.store.open()) {
+			context.store.setOpenMethod(pointerType || "mouse");
+			if (insidePopup()) watchCancelOpen(trigger);
+		}
+		click.onMouseDown(event);
+	}
+	function handleClick(event) {
+		if (event.detail === 0) context.store.setOpenMethod("keyboard");
+		click.onClick(event);
+	}
+	function handleKeyDown(event) {
+		if (context.readOnly()) return;
+		typeahead.onKeyDown(event);
+		if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+			event.preventDefault();
+			event.stopPropagation();
+			context.store.setOpenMethod("keyboard");
+			context.setOpen(true, createChangeEventDetails(listNavigation, event));
+			context.focusInput();
+		}
+	}
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => handleBlur);
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => handleClick);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => handleFocus);
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledButtonKeyDown : void 0), () => internalProps.onKeyDown, () => handleKeyDown, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyDown));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyUp));
+	const onMouseDown = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onMouseDown, () => handleMouseDown);
+	const onPointerDown = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onPointerDown, () => handlePointerDown);
+	const onPointerEnter = composeEventHandlers(() => internalProps.onPointerEnter, () => (event) => {
+		pointerType = event.pointerType || "";
+	});
+	createEffect(() => ({
+		id: id(),
+		element: element(),
+		insidePopup: insidePopup()
+	}), (current) => {
+		context.setTriggerElement(current.element);
+		labelable.registerControlId(labelSource, current.insidePopup ? current.id : void 0);
+		return () => {
+			if (untrack(context.triggerElement) === current.element) context.setTriggerElement(null);
+		};
+	});
+	onCleanup(() => {
+		clearTimeout(focusTimer);
+		removeMouseUp?.();
+		labelable.registerControlId(labelSource, void 0);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "button";
+		},
+		ref: [((value) => setElement(value)), internalProps.ref],
+		get id() {
+			return id();
+		},
+		get type() {
+			return nativeButton() ? "button" : void 0;
+		},
+		get tabindex() {
+			return insidePopup() ? 0 : -1;
+		},
+		get role() {
+			return insidePopup() ? "combobox" : void 0;
+		},
+		get disabled() {
+			return nativeButton() && disabled() ? true : void 0;
+		},
+		get ["aria-disabled"]() {
+			return !nativeButton() && disabled() ? "true" : void 0;
+		},
+		get ["aria-expanded"]() {
+			return context.store.open() ? "true" : "false";
+		},
+		get ["aria-haspopup"]() {
+			return insidePopup() ? "dialog" : "listbox";
+		},
+		get ["aria-controls"]() {
+			return ariaControls();
+		},
+		get ["aria-required"]() {
+			return insidePopup() && context.required() ? "true" : void 0;
+		},
+		get ["aria-labelledby"]() {
+			return ariaLabelledBy();
+		},
+		get ["aria-invalid"]() {
+			return state().valid === false && !disabled() ? "true" : void 0;
+		},
+		"data-base-ui-click-trigger": "",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onBlur,
+		onClick,
+		onFocus,
+		onKeyDown,
+		onKeyUp,
+		onMouseDown,
+		onPointerDown,
+		onPointerEnter
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/combobox/chips/ComboboxChipsContext.ts
+/** The DOM-ordered registry of rendered chips, which the keyboard highlight walks. */
+var ComboboxChipRegistry = class {
+	registrations = /* @__PURE__ */ new Map();
+	revision;
+	setRevision;
+	order = 0;
+	orders = /* @__PURE__ */ new Map();
+	constructor() {
+		const [revision, setRevision] = createSignal(0, { ownedWrite: true });
+		this.revision = revision;
+		this.setRevision = setRevision;
+	}
+	register(token, element) {
+		this.registrations.set(token, element);
+		this.orders.set(token, this.order);
+		this.order += 1;
+		this.touch();
+		return () => {
+			if (this.registrations.delete(token)) {
+				this.orders.delete(token);
+				this.touch();
+			}
+		};
+	}
+	touch() {
+		this.setRevision((value) => value + 1);
+	}
+	tokens() {
+		this.revision();
+		return Array.from(this.registrations.keys()).sort((first, second) => {
+			const firstElement = this.registrations.get(first)?.() ?? null;
+			const secondElement = this.registrations.get(second)?.() ?? null;
+			if (firstElement && secondElement && firstElement !== secondElement) {
+				const position = firstElement.compareDocumentPosition(secondElement);
+				if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+				if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+			}
+			return (this.orders.get(first) ?? 0) - (this.orders.get(second) ?? 0);
+		});
+	}
+	elements() {
+		return this.tokens().map((token) => this.registrations.get(token)?.() ?? null);
+	}
+	indexOf(token) {
+		return this.tokens().indexOf(token);
+	}
+	size() {
+		return this.tokens().length;
+	}
+};
+var MISSING_CONTEXT$4 = Symbol("ComboboxChipsContext");
+var ComboboxChipsContext = createContext(MISSING_CONTEXT$4);
+function useComboboxChipsContext() {
+	const context = useContext(ComboboxChipsContext);
+	return context === MISSING_CONTEXT$4 ? void 0 : context;
+}
+function useRequiredComboboxChipsContext() {
+	const context = useComboboxChipsContext();
+	if (!context) throw new Error("Base UI: ComboboxChipsContext is missing. Chip parts must be placed within <Combobox.Chips>.");
+	return context;
+}
+//#endregion
+//#region src/combobox/positioner/ComboboxPositionerContext.ts
+var MISSING_CONTEXT$3 = Symbol("ComboboxPositionerContext");
+var ComboboxPositionerContext = createContext(MISSING_CONTEXT$3);
+function useComboboxPositionerContext(optional = false) {
+	const context = useContext(ComboboxPositionerContext);
+	if (context === MISSING_CONTEXT$3) {
+		if (optional) return;
+		throw new Error("Base UI: <Combobox.Popup> and <Combobox.Arrow> must be used within the <Combobox.Positioner> component.");
+	}
+	return context;
+}
+//#endregion
+//#region src/combobox/utils/ComboboxInternalDismissButton.tsx
+var _tmpl$ = [
+	"<span",
+	" role=\"button\" aria-label=\"Dismiss\" style=\"",
+	"\"></span>"
+];
+var DISMISS_BUTTON_STYLE = {
+	"clip-path": "inset(50%)",
+	overflow: "hidden",
+	"white-space": "nowrap",
+	border: "0",
+	padding: "0",
+	width: "1px",
+	height: "1px",
+	margin: "-1px",
+	position: "absolute",
+	top: "0",
+	left: "0"
+};
+/**
+* A visually hidden control that gives screen reader users a way out of the popup when the input
+* is inside it and the trigger is no longer reachable.
+* @internal
+*/
+function ComboboxInternalDismissButton(props) {
+	useComboboxRootContext();
+	var _v$ = ssrHydrationKey();
+	return ssr(_tmpl$, _v$, ssrStyle(DISMISS_BUTTON_STYLE));
+}
+//#endregion
+//#region src/combobox/utils/parts.ts
+/** The arrow keys that move the chip highlight backwards and forwards, in that order. */
+function getChipNavigationKeys(direction) {
+	return direction === "rtl" ? ["ArrowRight", "ArrowLeft"] : ["ArrowLeft", "ArrowRight"];
+}
+/** Where the highlight lands once the chip at `index` is removed, or `undefined` for none. */
+function getIndexAfterChipRemoval(index, chipCount) {
+	const nextIndex = index >= chipCount - 1 ? chipCount - 2 : index;
+	return nextIndex >= 0 ? nextIndex : void 0;
+}
+//#endregion
+//#region src/combobox/input/ComboboxInput.tsx
+/** A text input to search for items in the list. */
+function ComboboxInput(props) {
+	const context = useComboboxRootContext();
+	const chips = useComboboxChipsContext();
+	const positioner = useComboboxPositionerContext(true);
+	const labelable = useLabelableContext();
+	const direction = useDirection();
+	const internalProps = props;
+	const allProps = props;
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const hasPositionerParent = positioner !== void 0;
+	const insidePopup = createMemo(() => hasPositionerParent || context.inline());
+	const focusManagerModal = createMemo(() => !insidePopup() || context.modal());
+	const id = createMemo(() => internalProps.id ?? (insidePopup() ? generatedId : context.id()));
+	const disabled = createMemo(() => context.field.disabled() || context.disabled() || (internalProps.disabled ?? false));
+	const inputOwnsFormValue = createMemo(() => context.selectionMode() === "none" && !hasPositionerParent);
+	const [composingValue, setComposingValue] = createSignal(null);
+	let composing = false;
+	let lastActiveIndex = null;
+	let shouldRestoreActiveIndex = false;
+	const fieldState = createMemo(() => hasPositionerParent ? {
+		...context.field.state(),
+		...DEFAULT_FIELD_STATE_ATTRIBUTES
+	} : context.field.state());
+	const state = createMemo(() => ({
+		...fieldState(),
+		open: context.store.open(),
+		disabled: disabled(),
+		readOnly: context.readOnly(),
+		popupSide: context.store.resolvedPopupSide(),
+		listEmpty: context.listEmpty()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxControlStateMapping));
+	const activeDescendant = createMemo(() => {
+		const activeIndex = context.store.activeIndex();
+		return activeIndex == null ? void 0 : `${context.id()}-${activeIndex}`;
+	});
+	const others = omit(allProps, "as", "class", "disabled", "id", "onBlur", "onCompositionEnd", "onCompositionStart", "onFocus", "onInput", "onKeyDown", "onMouseDown", "onPointerDown", "onPointerMove", "ref", "style");
+	function clearHighlight() {
+		context.setIndices({
+			activeIndex: null,
+			selectedIndex: null,
+			type: context.store.keyboardActive ? keyboard : pointer
+		});
+	}
+	function handleFocus() {
+		context.field.setFocused(true);
+		if (!context.inline() || !shouldRestoreActiveIndex) return;
+		shouldRestoreActiveIndex = false;
+		const nextActiveIndex = lastActiveIndex;
+		if (nextActiveIndex == null || context.itemValues()[nextActiveIndex] === void 0) return;
+		context.setIndices({ activeIndex: nextActiveIndex });
+	}
+	function handleBlur() {
+		context.field.setTouched(true);
+		context.field.setFocused(false);
+		const activeIndex = context.store.activeIndex();
+		if (context.inline() && activeIndex !== null && context.autoHighlight() !== "always") {
+			lastActiveIndex = activeIndex;
+			shouldRestoreActiveIndex = true;
+			context.setIndices({ activeIndex: null });
+		}
+		if (context.field.validationMode() === "onBlur") context.field.validation.commit(context.selectionMode() === "none" ? context.inputValue() : context.selectedValue());
+	}
+	function handleCompositionStart(event) {
+		if (isAndroid()) return;
+		composing = true;
+		setComposingValue(event.currentTarget.value);
+	}
+	function handleCompositionEnd(event) {
+		composing = false;
+		const next = event.currentTarget.value;
+		setComposingValue(null);
+		context.setInputValue(next, createChangeEventDetails(inputChange, event));
+	}
+	function maybeOpenOnInput(trimmed, event, shouldOpen) {
+		if (context.readOnly() || disabled() || !trimmed || !shouldOpen) return;
+		context.setOpen(true, createChangeEventDetails(inputChange, event));
+		if (!context.autoHighlight()) clearHighlight();
+	}
+	function handleInput(event) {
+		const input = event.currentTarget;
+		const autofillLike = !event.inputType || event.inputType === "insertReplacementText";
+		const shouldOpenOnInput = composing || !autofillLike;
+		if (composing) {
+			const nextValue = input.value;
+			setComposingValue(nextValue);
+			if (nextValue === "" && !context.openOnInputClick() && !context.store.inputInsidePopup()) context.setOpen(false, createChangeEventDetails(inputClear, event));
+			const trimmed = nextValue.trim();
+			const maintainHighlight = Boolean(context.autoHighlight()) && trimmed !== "";
+			maybeOpenOnInput(trimmed, event, shouldOpenOnInput);
+			if (context.store.open() && context.store.activeIndex() !== null && !maintainHighlight) clearHighlight();
+			return;
+		}
+		const changeDetails = createChangeEventDetails(inputChange, event);
+		context.setInputValue(input.value, changeDetails);
+		if (changeDetails.isCanceled) return;
+		const empty = input.value === "";
+		const clearDetails = createChangeEventDetails(inputClear, event);
+		if (empty && !context.store.inputInsidePopup()) {
+			if (context.selectionMode() === "single") context.setSelectedValue(null, clearDetails);
+			if (!context.openOnInputClick()) context.setOpen(false, clearDetails);
+		}
+		maybeOpenOnInput(input.value.trim(), event, shouldOpenOnInput);
+		if (context.store.open() && context.store.activeIndex() !== null && !context.autoHighlight()) clearHighlight();
+	}
+	/** Chip highlight movement driven from the input, which owns real focus. */
+	function resolveChipIndex(event) {
+		if (!chips) return;
+		const input = event.currentTarget;
+		const highlighted = chips.highlightedChipIndex();
+		const chipCount = chips.chips.size();
+		const [previousChipKey, nextChipKey] = getChipNavigationKeys(direction());
+		const selected = context.selectedValue();
+		const values = Array.isArray(selected) ? selected : [];
+		if (highlighted !== void 0) {
+			if (event.key === previousChipKey) {
+				event.preventDefault();
+				return highlighted > 0 ? highlighted - 1 : void 0;
+			}
+			if (event.key === nextChipKey) {
+				event.preventDefault();
+				return highlighted < chipCount - 1 ? highlighted + 1 : void 0;
+			}
+			if (event.key === "Backspace" || event.key === "Delete") {
+				event.preventDefault();
+				const nextIndex = getIndexAfterChipRemoval(highlighted, values.length);
+				clearHighlight();
+				return nextIndex;
+			}
+			return;
+		}
+		if (event.key === previousChipKey && (input.selectionStart ?? 0) === 0 && values.length > 0) {
+			event.preventDefault();
+			return chipCount > 0 ? chipCount - 1 : void 0;
+		}
+	}
+	function handleEscapeWhileClosed(event) {
+		const selected = context.selectedValue();
+		const alreadyClear = context.selectionMode() === "multiple" && Array.isArray(selected) ? selected.length === 0 : selected === null;
+		const details = createChangeEventDetails(escapeKey, event);
+		context.setInputValue("", details);
+		context.setSelectedValue(context.selectionMode() === "multiple" ? [] : null, details);
+		if (!alreadyClear && !context.inline() && !details.isPropagationAllowed) event.stopPropagation();
+	}
+	function handleKeyDown(event) {
+		const editable = !disabled() && !context.readOnly();
+		const modified = event.ctrlKey || event.shiftKey || event.altKey || event.metaKey;
+		if (editable && !modified) context.store.keyboardActive = true;
+		if (!(context.grid() && context.store.activeIndex() == null && (event.key === "ArrowLeft" || event.key === "ArrowRight"))) context.listNavigation.onKeyDown(event);
+		context.dismiss.onKeyDown(event);
+		if (!editable || modified) return;
+		const input = event.currentTarget;
+		const isRTL = direction() === "rtl";
+		if (event.key === "Home" || event.key === "End") {
+			event.preventDefault();
+			event.stopPropagation();
+			const scrollAmount = input.scrollWidth - input.clientWidth;
+			const atStart = event.key === "Home";
+			const cursor = isGecko() && isRTL === atStart ? input.value.length : atStart ? 0 : input.value.length;
+			input.setSelectionRange(cursor, cursor);
+			input.scrollLeft = atStart ? 0 : isRTL ? -scrollAmount : scrollAmount;
+			return;
+		}
+		if (!context.presence.mounted() && event.key === "Escape") {
+			handleEscapeWhileClosed(event);
+			return;
+		}
+		if (chips && event.key === "Backspace" && input.value === "" && chips.highlightedChipIndex() === void 0 && Array.isArray(context.selectedValue()) && context.selectedValue().length > 0) {
+			const values = context.selectedValue();
+			const chipCount = chips.chips.size();
+			const removalIndex = chipCount > 0 ? chipCount - 1 : values.length - 1;
+			clearHighlight();
+			context.setSelectedValue(values.filter((_, index) => index !== removalIndex), createChangeEventDetails(none, event));
+			return;
+		}
+		if (chips) {
+			const hadHighlightedChip = chips.highlightedChipIndex() !== void 0;
+			const nextIndex = resolveChipIndex(event);
+			chips.setHighlightedChipIndex(nextIndex);
+			if (nextIndex !== void 0) chips.chips.elements()[nextIndex]?.focus();
+			else if (hadHighlightedChip) context.focusInput();
+		}
+		if (event.keyCode === 229) return;
+		if (event.key === "Enter" && context.store.open()) {
+			const activeIndex = context.store.activeIndex();
+			if (activeIndex === null) {
+				if (context.inline()) return;
+				context.setOpen(false, createChangeEventDetails(none, event));
+				return;
+			}
+			event.preventDefault();
+			event.stopPropagation();
+			context.clickHighlightedItem(activeIndex, event);
+		}
+	}
+	function markPointerActive() {
+		context.store.keyboardActive = false;
+	}
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => handleBlur);
+	const onCompositionEnd = composeEventHandlers(() => internalProps.onCompositionEnd, () => handleCompositionEnd);
+	const onCompositionStart = composeEventHandlers(() => internalProps.onCompositionStart, () => handleCompositionStart);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => handleFocus);
+	const onInput = composeEventHandlers(() => internalProps.onInput, () => handleInput);
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => handleKeyDown);
+	const onMouseDown = composeEventHandlers(() => internalProps.onMouseDown, () => (event) => context.click.onMouseDown(event));
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => (event) => {
+		markPointerActive();
+		context.click.onPointerDown(event);
+	});
+	const onPointerMove = composeEventHandlers(() => internalProps.onPointerMove, () => markPointerActive);
+	createEffect(() => ({
+		insidePopup: insidePopup(),
+		owns: inputOwnsFormValue()
+	}), (current) => {
+		context.store.setInputInsidePopup(current.insidePopup);
+		context.store.setInputOwnsFormValue(current.owns);
+		if (current.insidePopup && !context.hasInputValueProp()) untrack(() => context.setInputValue("", createChangeEventDetails(none)));
+	});
+	onCleanup(() => {
+		if (untrack(context.inputElement) === element) context.setInputElement(null);
+	});
+	let element = null;
+	return [Show({
+		get when() {
+			return memo(() => {
+				return !!context.store.open();
+			})() ? focusManagerModal() : context.store.open();
+		},
+		get children() {
+			return ComboboxInternalDismissButton({ ref: (node) => {
+				context.store.startDismissElement = node;
+			} });
+		}
+	}), Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "input";
+		},
+		ref: [((value) => {
+			element = value;
+			context.setInputElement(value);
+		}), internalProps.ref],
+		get id() {
+			return id();
+		},
+		get value() {
+			return composingValue() ?? context.inputValue();
+		},
+		get disabled() {
+			return disabled();
+		},
+		get readonly() {
+			return context.readOnly();
+		},
+		get required() {
+			return memo(() => {
+				return context.selectionMode() === "none";
+			})() ? context.required() : void 0;
+		},
+		get form() {
+			return context.form();
+		},
+		get name() {
+			return memo(() => {
+				return !!inputOwnsFormValue();
+			})() ? context.name() : void 0;
+		},
+		get ["aria-readonly"]() {
+			return context.readOnly() ? "true" : void 0;
+		},
+		get ["aria-required"]() {
+			return context.required() ? "true" : void 0;
+		},
+		get ["aria-labelledby"]() {
+			return labelable.labelId();
+		},
+		get ["aria-describedby"]() {
+			return labelable.getAriaDescribedBy(void 0);
+		},
+		get ["aria-activedescendant"]() {
+			return activeDescendant();
+		},
+		get ["aria-invalid"]() {
+			return state().valid === false && !disabled() ? "true" : void 0;
+		},
+		"data-base-ui-click-trigger": "",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onBlur,
+		onCompositionEnd,
+		onCompositionStart,
+		onFocus,
+		onInput,
+		onKeyDown,
+		onMouseDown,
+		onPointerDown,
+		onPointerMove
+	}, () => {
+		return context.referenceAria();
+	}, stateAttributes, others))];
+}
+function isGecko() {
+	return typeof navigator !== "undefined" && navigator.userAgent.includes("Firefox");
+}
+//#endregion
+//#region src/combobox/utils/handleInputPress.ts
+/**
+* Routes a press anywhere in the input's surroundings back to the input, so clicking the padding
+* of an input group or the empty space beside the chips focuses and opens the combobox.
+*/
+function handleInputPress(event, context, disabled, readOnly, shouldIgnoreTarget) {
+	if (event.baseUIHandlerPrevented || readOnly) return;
+	const target = event.target;
+	const targetElement = isElement(target) ? target : null;
+	if (targetElement !== event.currentTarget && (shouldIgnoreTarget?.(targetElement) || isInteractiveElement(targetElement))) return;
+	event.preventDefault();
+	if (disabled) return;
+	context.focusInput();
+	if (context.openOnInputClick()) context.setOpen(true, createChangeEventDetails(inputPress, event));
+}
+//#endregion
+//#region src/combobox/input-group/ComboboxInputGroup.tsx
+/** A wrapper for the input and its associated controls. */
+function ComboboxInputGroup(props) {
+	const context = useComboboxRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		...context.field.state(),
+		open: context.store.open(),
+		disabled: context.disabled(),
+		readOnly: context.readOnly(),
+		popupSide: context.store.resolvedPopupSide(),
+		listEmpty: context.listEmpty(),
+		placeholder: context.selectionMode() === "none" ? false : !context.hasSelectedValue()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxControlStateMapping));
+	const others = omit(allProps, "as", "class", "onMouseDown", "ref", "style");
+	const onMouseDown = composeEventHandlers(() => internalProps.onMouseDown, () => (event) => handleInputPress(event, context, context.disabled(), context.readOnly(), (target) => contains(context.store.chipsContainerElement, target)));
+	onCleanup(() => {
+		if (untrack(context.inputGroupElement) === element) context.setInputGroupElement(null);
+	});
+	let element = null;
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((value) => {
+			element = value;
+			context.setInputGroupElement(value);
+		}), internalProps.ref],
+		role: "group",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onMouseDown
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/combobox/icon/ComboboxIcon.tsx
+/** An icon indicating that the trigger opens the popup. */
+function ComboboxIcon(props) {
+	const context = useComboboxRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({ open: context.store.open() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), triggerOpenStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return Show({
+		get when() {
+			return props.as;
+		},
+		get fallback() {
+			return ssrElement("span", () => {
+				return mergeProps({
+					"aria-hidden": "true",
+					get ["class"]() {
+						return classValue();
+					},
+					get style() {
+						return styleValue();
+					}
+				}, stateAttributes, others);
+			}, () => {
+				return () => {
+					return escape(props.children ?? "▼");
+				};
+			}, true);
+		},
+		children: (component) => Dynamic(mergeProps({
+			get component() {
+				return component();
+			},
+			ref: [internalProps.ref],
+			"aria-hidden": "true",
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			}
+		}, stateAttributes, others, { get children() {
+			return props.children ?? "▼";
+		} }))
+	});
+}
+//#endregion
+//#region src/combobox/clear/ComboboxClear.tsx
+/** Clears the value when clicked. */
+function ComboboxClear(props) {
+	const context = useComboboxRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? true);
+	const disabled = createMemo(() => context.field.disabled() || context.disabled() || (internalProps.disabled ?? false));
+	const visible = createMemo(() => {
+		const mode = context.selectionMode();
+		if (mode === "none") return context.inputValue() !== "";
+		if (mode === "single") return context.selectedValue() != null;
+		return context.hasSelectionChips();
+	});
+	const transition = createTransitionStatus(() => visible());
+	const shouldRender = createMemo(() => (internalProps.keepMounted ?? false) || transition.mounted());
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		disabled: disabled(),
+		visible: visible(),
+		transitionStatus: transition.transitionStatus()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxClearStateMapping));
+	const others = omit(allProps, "as", "class", "disabled", "keepMounted", "nativeButton", "onClick", "onKeyDown", "onKeyUp", "onMouseDown", "ref", "style");
+	let element = null;
+	createEffect(() => ({
+		visible: visible(),
+		status: transition.transitionStatus(),
+		element
+	}), (current) => {
+		if (current.visible || current.status !== "ending" || !current.element) return;
+		const controller = new AbortController();
+		runOnceAnimationsFinish(current.element, () => {
+			if (!untrack(visible)) transition.setMounted(false);
+		}, controller.signal);
+		return () => controller.abort();
+	});
+	function handleClick(event) {
+		if (disabled() || context.readOnly()) return;
+		const type = context.store.keyboardActive ? keyboard : pointer;
+		context.setInputValue("", createChangeEventDetails(clearPress, event));
+		if (context.selectionMode() !== "none") {
+			context.setSelectedValue(Array.isArray(context.selectedValue()) ? [] : null, createChangeEventDetails(clearPress, event));
+			context.setIndices({
+				activeIndex: null,
+				selectedIndex: null,
+				type
+			});
+		} else context.setIndices({
+			activeIndex: null,
+			type
+		});
+		context.focusInput();
+	}
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => handleClick);
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyDown));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyUp));
+	const onMouseDown = composeEventHandlers(() => internalProps.onMouseDown, () => (event) => event.preventDefault());
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "button";
+				},
+				ref: [((value) => {
+					element = value;
+					context.store.clearElement = value;
+				}), internalProps.ref],
+				get type() {
+					return nativeButton() ? "button" : void 0;
+				},
+				tabindex: -1,
+				get disabled() {
+					return nativeButton() && disabled() ? true : void 0;
+				},
+				get ["aria-disabled"]() {
+					return !nativeButton() && disabled() ? "true" : void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onClick,
+				onKeyDown,
+				onKeyUp,
+				onMouseDown
+			}, stateAttributes, others, { get children() {
+				return props.children ?? "x";
+			} }));
+		}
+	});
+}
+//#endregion
+//#region src/combobox/collection/ComboboxCollection.tsx
+/**
+* Renders the filtered list items, or the items of the enclosing `<Combobox.Group items>`.
+* Doesn't render its own HTML element.
+*
+* If rendering a flat list, pass the same function as a child of `List`, which wraps it
+* implicitly.
+*/
+function ComboboxCollection(props) {
+	const context = useComboboxRootContext();
+	const group = useComboboxGroupCollectionContext();
+	const items = createMemo(() => group?.items() ?? context.filteredItems());
+	return For({
+		get each() {
+			return items();
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+//#endregion
+//#region src/combobox/list/ComboboxList.tsx
+/**
+* A list container for the items.
+*
+* A function child is implicitly wrapped in `<Combobox.Collection>`, so a flat list can be
+* rendered without naming the collection part.
+*/
+function ComboboxList(props) {
+	const context = useComboboxRootContext();
+	const positioner = useComboboxPositionerContext(true);
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({ empty: context.listEmpty() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const others = omit(allProps, "as", "children", "class", "id", "onKeyDown", "ref", "style");
+	function handleKeyDown(event) {
+		if (context.disabled() || context.readOnly()) return;
+		context.store.keyboardActive = true;
+		if (event.key !== "Enter") return;
+		const activeIndex = context.store.activeIndex();
+		if (activeIndex == null) return;
+		event.preventDefault();
+		event.stopPropagation();
+		context.clickHighlightedItem(activeIndex, event);
+	}
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => handleKeyDown);
+	const [listElement, setListElement] = createSignal(null, { ownedWrite: true });
+	createEffect(listElement, (element) => {
+		if (!element) return;
+		const markPointerActive = () => {
+			context.store.keyboardActive = false;
+		};
+		const markKeyboardActive = () => {
+			context.store.keyboardActive = true;
+		};
+		element.addEventListener("pointermove", markPointerActive, true);
+		element.addEventListener("keydown", markKeyboardActive, true);
+		return () => {
+			element.removeEventListener("pointermove", markPointerActive, true);
+			element.removeEventListener("keydown", markKeyboardActive, true);
+		};
+	});
+	onCleanup(() => {
+		const element = untrack(listElement);
+		if (context.store.listElement() === element) context.store.setListElement(null);
+		if (!positioner && context.store.state.positionerElement === element) context.store.setPositionerElement(null);
+	});
+	const children = createMemo(() => {
+		const child = props.children;
+		if (typeof child === "function" && !isSolidAccessor(child)) return ComboboxCollection({ children: child });
+		return child;
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			setListElement(element);
+			context.store.setListElement(element);
+			if (!positioner) context.store.setPositionerElement(element);
+		}), internalProps.ref],
+		get id() {
+			return internalProps.id ?? context.store.context.floatingId;
+		},
+		get role() {
+			return context.grid() ? "grid" : "listbox";
+		},
+		tabindex: -1,
+		get ["aria-multiselectable"]() {
+			return context.multiple() ? "true" : void 0;
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onKeyDown
+	}, others, { get children() {
+		return children();
+	} }));
+}
+//#endregion
+//#region src/combobox/utils/createInitialLiveRegionTextMutation.ts
+var LIVE_REGION_MARKER = "⁠";
+function findLastTextNode(root) {
+	const walker = root.ownerDocument.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+	let lastTextNode = null;
+	while (walker.nextNode()) {
+		const textNode = walker.currentNode;
+		if (textNode.nodeValue !== "") lastTextNode = textNode;
+	}
+	return lastTextNode;
+}
+function isIOS() {
+	if (typeof navigator === "undefined") return false;
+	const platform = navigator.platform.toLowerCase();
+	return /^i(os$|p)/.test(platform) || platform === "macintel" && navigator.maxTouchPoints > 1;
+}
+/**
+* Marks the first rendered text of a polite live region so screen readers announce content that
+* was already present when the region mounted. Later text updates announce on their own.
+*/
+function createInitialLiveRegionTextMutation(element) {
+	createEffect(element, (root) => {
+		if (!root || isIOS()) return;
+		const textNode = findLastTextNode(root);
+		if (!textNode) return;
+		const originalValue = textNode.data;
+		const markedValue = `${originalValue}${LIVE_REGION_MARKER}`;
+		textNode.nodeValue = markedValue;
+		const restore = () => {
+			if (textNode.nodeValue === markedValue) textNode.nodeValue = originalValue;
+		};
+		const timer = setTimeout(restore, 200);
+		return () => {
+			clearTimeout(timer);
+			restore();
+		};
+	});
+}
+//#endregion
+//#region src/combobox/status/ComboboxStatus.tsx
+/**
+* Displays a status message whose content changes are announced politely, which is useful for
+* the loading state of an asynchronously fetched list.
+*
+* The root element must stay mounted for screen readers to announce consistently, so hide or
+* conditionally render its children rather than the component itself.
+*/
+function ComboboxStatus(props) {
+	const internalProps = props;
+	const allProps = props;
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	createInitialLiveRegionTextMutation(element);
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((value) => setElement(value)), internalProps.ref],
+		role: "status",
+		"aria-live": "polite",
+		"aria-atomic": "true",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others));
+}
+//#endregion
+//#region src/combobox/portal/ComboboxPortalContext.ts
+var MISSING_CONTEXT$2 = Symbol("ComboboxPortalContext");
+var ComboboxPortalContext = createContext(MISSING_CONTEXT$2);
+/** The enclosing portal's `keepMounted`, which the positioner needs while it stays mounted. */
+function useComboboxPortalContext() {
+	const context = useContext(ComboboxPortalContext);
+	if (context === MISSING_CONTEXT$2) throw new Error("Base UI: <Combobox.Portal> is missing.");
+	return context;
+}
+//#endregion
+//#region src/combobox/portal/ComboboxPortal.tsx
+/**
+* Moves the popup to a different part of the DOM. By default the portal element is appended to
+* `<body>`.
+*/
+function ComboboxPortal(props) {
+	const context = useComboboxRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const keepMounted = createMemo(() => internalProps.keepMounted ?? false);
+	const shouldRender = createMemo(() => context.presence.mounted() || keepMounted() || context.store.forceMounted());
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "container", "keepMounted", "ref", "style");
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return ComboboxPortalContext({
+				get value() {
+					return keepMounted();
+				},
+				get children() {
+					return PopupPortal(mergeProps({
+						get as() {
+							return props.as;
+						},
+						get container() {
+							return internalProps.container;
+						},
+						ref: (element) => setRef(internalProps.ref, element),
+						get ["class"]() {
+							return classValue();
+						},
+						get style() {
+							return styleValue();
+						}
+					}, others, { get children() {
+						return props.children;
+					} }));
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region src/combobox/backdrop/ComboboxBackdrop.tsx
+/** An overlay displayed beneath the popup. */
+function ComboboxBackdrop(props) {
+	const context = useComboboxRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		transitionStatus: context.store.track().transitionStatus
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({
+		"user-select": "none",
+		"-webkit-user-select": "none"
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxBackdropStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		role: "presentation",
+		get hidden() {
+			return !context.presence.mounted();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/combobox/positioner/ComboboxPositioner.tsx
+/**
+* Dropdowns can grow tall enough to reach the opposite viewport edge, so they shift within their
+* preferred side and use `var(--available-height)` instead of flipping to a cross axis.
+*/
+var DROPDOWN_COLLISION_AVOIDANCE = {
+	side: "flip",
+	align: "flip",
+	fallbackAxisSide: "none"
+};
+/** Positions the popup against the input, or against the trigger when the input is inside it. */
+function ComboboxPositioner(props) {
+	const keepMounted = useComboboxPortalContext();
+	const context = useComboboxRootContext();
+	const direction = useDirection();
+	const internalProps = props;
+	const allProps = props;
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const anchorElement = createMemo(() => resolveAnchor(internalProps.anchor) ?? (context.store.inputInsidePopup() ? context.triggerElement() : context.inputGroupElement() ?? context.inputElement()) ?? null);
+	const positioning = createAnchorPositioning({
+		reference: anchorElement,
+		floating: element,
+		mounted: () => context.presence.mounted() || keepMounted,
+		direction,
+		positionMethod: () => internalProps.positionMethod ?? "absolute",
+		side: () => internalProps.side ?? "bottom",
+		sideOffset: () => internalProps.sideOffset ?? 0,
+		align: () => internalProps.align ?? "center",
+		alignOffset: () => internalProps.alignOffset ?? 0,
+		collisionBoundary: () => internalProps.collisionBoundary ?? "clipping-ancestors",
+		collisionPadding: () => internalProps.collisionPadding ?? 5,
+		arrowPadding: () => internalProps.arrowPadding ?? 5,
+		sticky: () => internalProps.sticky ?? false,
+		disableAnchorTracking: () => internalProps.disableAnchorTracking ?? false,
+		collisionAvoidance: () => internalProps.collisionAvoidance ?? DROPDOWN_COLLISION_AVOIDANCE
+	});
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		side: positioning.renderedSide(),
+		align: positioning.renderedAlign(),
+		anchorHidden: positioning.anchorHidden(),
+		empty: context.listEmpty()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({
+		...positioning.styles(),
+		"pointer-events": context.store.open() ? void 0 : "none",
+		transition: context.store.track().transitionStatus === "starting" ? "none" : void 0
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxPositionerStateMapping));
+	const others = omit(allProps, "align", "alignOffset", "anchor", "arrowPadding", "as", "class", "collisionAvoidance", "collisionBoundary", "collisionPadding", "disableAnchorTracking", "positionMethod", "ref", "side", "sideOffset", "sticky", "style");
+	createAnchoredPopupScrollLock({
+		enabled: () => context.store.open() && context.modal(),
+		touchOpen: () => context.store.openMethod() === "touch",
+		positioner: element,
+		reference: () => context.triggerElement() ?? context.inputElement()
+	});
+	createEffect(positioning.renderedSide, (side) => context.store.setPopupSide(side));
+	onCleanup(() => {
+		if (context.store.state.positionerElement === untrack(element)) context.store.setPositionerElement(null);
+	});
+	const positionerContext = {
+		...positioning,
+		side: positioning.renderedSide,
+		align: positioning.renderedAlign
+	};
+	function ModalBackdrop() {
+		let backdrop = null;
+		onCleanup(() => {
+			if (context.internalBackdropElement() === backdrop) context.setInternalBackdropElement(null);
+		});
+		return InternalBackdrop({
+			ref: (node) => {
+				backdrop = node;
+				context.setInternalBackdropElement(node);
+			},
+			get cutout() {
+				return context.inputGroupElement() ?? context.inputElement() ?? context.triggerElement();
+			},
+			get open() {
+				return context.store.open();
+			}
+		});
+	}
+	return ComboboxPositionerContext({
+		value: positionerContext,
+		get children() {
+			return [Show({
+				get when() {
+					return memo(() => {
+						return !!context.presence.mounted();
+					})() ? context.modal() : context.presence.mounted();
+				},
+				get children() {
+					return ModalBackdrop({});
+				}
+			}), Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => {
+					setElement(value);
+					context.store.setPositionerElement(value);
+				}), internalProps.ref],
+				role: "presentation",
+				get hidden() {
+					return !context.presence.mounted();
+				},
+				get inert() {
+					return !context.store.open() || void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others))];
+		}
+	});
+}
+function resolveAnchor(anchor) {
+	if (typeof anchor === "function") return anchor();
+	if (anchor && "current" in anchor) return anchor.current;
+	return anchor;
+}
+//#endregion
+//#region src/combobox/popup/ComboboxPopup.tsx
+/** A container for the list. */
+function ComboboxPopup(props) {
+	const context = useComboboxRootContext();
+	const positioner = useComboboxPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const popupId = createMemo(() => internalProps.id ?? (context.store.inputInsidePopup() ? getComboboxPopupId(context.id()) : void 0));
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		side: positioner.side(),
+		align: positioner.align(),
+		anchorHidden: positioner.anchorHidden(),
+		transitionStatus: context.store.track().transitionStatus,
+		empty: context.listEmpty(),
+		instant: context.store.track().instantType
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({ transition: state().transitionStatus === "starting" ? "none" : void 0 }, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), comboboxPopupStateMapping));
+	const others = omit(allProps, "as", "class", "finalFocus", "id", "initialFocus", "onFocus", "ref", "style");
+	const focusManagerModal = createMemo(() => !context.store.inputInsidePopup() || context.modal());
+	const resolvedInitialFocus = createMemo(() => {
+		if (internalProps.initialFocus !== void 0) return internalProps.initialFocus;
+		if (!context.store.inputInsidePopup()) return false;
+		return (interactionType) => interactionType === "touch" ? context.store.track().popupElement : context.inputElement();
+	});
+	const resolvedFinalFocus = createMemo(() => {
+		if (internalProps.finalFocus != null) return internalProps.finalFocus;
+		return context.store.inputInsidePopup() ? true : false;
+	});
+	/**
+	* Virtual focus keeps the real focus on the input, so focus landing anywhere in the popup is
+	* handed back. This listens on `focusin` rather than `focus` because focus reaching a
+	* descendant — the list, most often — has to be caught too, and `focus` does not bubble.
+	*/
+	function handleFocusIn(event) {
+		const target = event.target;
+		if (context.store.openMethod() !== "touch" && (contains(context.store.listElement(), target) || target === event.currentTarget)) context.focusInput();
+	}
+	let popupElement = null;
+	createEffect(popupId, (id) => {
+		context.store.setPopupId(popupElement?.id || id);
+		return () => context.store.setPopupId(void 0);
+	});
+	onCleanup(() => {
+		if (context.store.state.popupElement === popupElement) context.store.setPopupElement(null);
+	});
+	return FocusManager({
+		get context() {
+			return context.store.context.floatingRoot;
+		},
+		get tree() {
+			return context.tree;
+		},
+		get disabled() {
+			return !context.presence.mounted();
+		},
+		get modal() {
+			return focusManagerModal();
+		},
+		get openInteractionType() {
+			return context.store.openMethod();
+		},
+		get initialFocus() {
+			return resolvedInitialFocus();
+		},
+		get returnFocus() {
+			return resolvedFinalFocus();
+		},
+		get previousFocusableElement() {
+			return context.triggerElement;
+		},
+		referenceElement: () => context.store.inputInsidePopup() ? context.triggerElement() : context.inputElement(),
+		getInsideElements: () => [context.store.startDismissElement, context.store.endDismissElement],
+		get children() {
+			return [Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((element) => {
+					popupElement = element;
+					context.store.setPopupElement(element);
+				}), internalProps.ref],
+				get id() {
+					return popupId();
+				},
+				get role() {
+					return context.store.inputInsidePopup() ? "dialog" : "presentation";
+				},
+				"data-base-ui-focusable": "",
+				get ["data-rootownerid"]() {
+					return context.node.id;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				get onFocus() {
+					return internalProps.onFocus;
+				},
+				onFocusIn: handleFocusIn
+			}, stateAttributes, others)), Show({
+				get when() {
+					return focusManagerModal();
+				},
+				get children() {
+					return ComboboxInternalDismissButton({ ref: (element) => {
+						untrack(() => {
+							context.store.endDismissElement = element;
+						});
+					} });
+				}
+			})];
+		}
+	});
+}
+//#endregion
+//#region src/combobox/arrow/ComboboxArrow.tsx
+/** Displays an element positioned against the anchor. */
+function ComboboxArrow(props) {
+	const context = useComboboxRootContext();
+	const positioner = useComboboxPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		side: positioner.side(),
+		align: positioner.align(),
+		uncentered: positioner.arrowUncentered()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue(positioner.arrowStyles(), resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), popupStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	let arrow = null;
+	onCleanup(() => {
+		if (arrow) positioner.setArrowElement(null);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			arrow = element;
+			positioner.setArrowElement(element);
+		}), internalProps.ref],
+		"aria-hidden": "true",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/combobox/group/ComboboxGroupContext.ts
+var MISSING_CONTEXT$1 = Symbol("ComboboxGroupContext");
+var ComboboxGroupContext = createContext(MISSING_CONTEXT$1);
+function useComboboxGroupContext() {
+	const context = useContext(ComboboxGroupContext);
+	if (context === MISSING_CONTEXT$1) throw new Error("Base UI: ComboboxGroupContext is missing. ComboboxGroup parts must be placed within <Combobox.Group>.");
+	return context;
+}
+//#endregion
+//#region src/combobox/group/ComboboxGroup.tsx
+/** Groups related items with the corresponding label. */
+function ComboboxGroup(props) {
+	const internalProps = props;
+	const allProps = props;
+	const [labelId, setLabelId] = createSignal(void 0, { ownedWrite: true });
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "items", "ref", "style");
+	return ComboboxGroupCollectionContext({
+		value: { items: () => internalProps.items },
+		get children() {
+			return ComboboxGroupContext({
+				value: {
+					labelId,
+					setLabelId
+				},
+				get children() {
+					return Dynamic(mergeProps({
+						get component() {
+							return props.as ?? "div";
+						},
+						ref: [internalProps.ref],
+						role: "group",
+						get ["aria-labelledby"]() {
+							return labelId();
+						},
+						get ["class"]() {
+							return classValue();
+						},
+						get style() {
+							return styleValue();
+						}
+					}, others));
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region src/combobox/group-label/ComboboxGroupLabel.tsx
+/** An accessible label automatically associated with its parent group. */
+function ComboboxGroupLabel(props) {
+	const context = useComboboxGroupContext();
+	const internalProps = props;
+	const allProps = props;
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const id = createMemo(() => internalProps.id ?? generatedId);
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "id", "ref", "style");
+	createEffect(id, (currentId) => {
+		context.setLabelId(currentId);
+		return () => {
+			if (context.labelId() === currentId) context.setLabelId(void 0);
+		};
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		get id() {
+			return id();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others));
+}
+//#endregion
+//#region src/combobox/row/ComboboxRowContext.ts
+var ComboboxRowContext = createContext(false);
+/** Whether the enclosing list is a grid row, which turns items into grid cells. */
+function useComboboxRowContext() {
+	return useContext(ComboboxRowContext);
+}
+//#endregion
+//#region src/combobox/item/ComboboxItemContext.ts
+var MISSING_CONTEXT = Symbol("ComboboxItemContext");
+var ComboboxItemContext = createContext(MISSING_CONTEXT);
+function useComboboxItemContext() {
+	const context = useContext(ComboboxItemContext);
+	if (context === MISSING_CONTEXT) throw new Error("Base UI: ComboboxItemContext is missing. ComboboxItem parts must be placed within <Combobox.Item>.");
+	return context;
+}
+//#endregion
+//#region src/combobox/item/ComboboxItem.tsx
+/** An individual item in the list. */
+function ComboboxItem(props) {
+	const context = useComboboxRootContext();
+	const isRow = useComboboxRowContext();
+	const internalProps = props;
+	const allProps = props;
+	const token = Symbol("ComboboxItem");
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const itemValue = createMemo(() => internalProps.value ?? null);
+	const disabled = createMemo(() => context.disabled() || (internalProps.disabled ?? false));
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? false);
+	const selectable = createMemo(() => context.selectionMode() !== "none");
+	/**
+	* An index the item knows without consulting the DOM: either declared directly, or derived
+	* from the filtered items when an external virtualizer only renders a window of rows.
+	*/
+	const declaredIndex = createMemo(() => {
+		if (internalProps.index != null) return internalProps.index;
+		if (!context.virtualized()) return;
+		const derived = findItemIndex(context.flatFilteredItems(), itemValue(), context.comparator());
+		return derived === -1 ? void 0 : derived;
+	});
+	const unregister = context.store.collection.register({
+		token,
+		element,
+		value: itemValue,
+		index: declaredIndex,
+		disabled
+	});
+	const index = createMemo(() => declaredIndex() ?? context.store.collection.indexOf(token));
+	const hasRegistered = createMemo(() => index() !== -1);
+	const id = createMemo(() => hasRegistered() ? `${context.id()}-${index()}` : void 0);
+	const selected = createMemo(() => {
+		if (!selectable()) return false;
+		const current = context.selectedValue();
+		if (Array.isArray(current)) return selectedValueIncludes(current, itemValue(), context.comparator());
+		return compareItemEquality(itemValue(), current, context.comparator());
+	});
+	const highlighted = createMemo(() => context.store.activeIndex() === index());
+	const state = createMemo(() => ({
+		disabled: disabled(),
+		selected: selected(),
+		highlighted: highlighted()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "disabled", "id", "index", "nativeButton", "onClick", "onMouseDown", "onMouseUp", "onPointerDown", "onPointerLeave", "onPointerMove", "ref", "style", "value");
+	function commitSelection(event) {
+		if (context.submitOnItemClick()) {
+			context.handleSelection(event, itemValue());
+			flush();
+			context.requestSubmit();
+			return;
+		}
+		context.handleSelection(event, itemValue());
+	}
+	function handlePointerDown(event) {
+		if (event.isPrimary) context.store.pointerDownItem = event.currentTarget;
+		event.preventDefault();
+	}
+	function handleMouseDown(event) {
+		event.preventDefault();
+	}
+	function handleClick(event) {
+		if (disabled() || context.readOnly()) return;
+		commitSelection(event);
+	}
+	function handleMouseUp(event) {
+		const startedOnItem = context.store.pointerDownItem === event.currentTarget;
+		context.store.pointerDownItem = null;
+		if (disabled() || context.readOnly() || event.button !== 0 || startedOnItem || !highlighted()) return;
+		commitSelection(event);
+	}
+	function handlePointerMove(event) {
+		if (event.pointerType === "touch") return;
+		context.store.keyboardActive = false;
+		if (disabled()) return;
+		context.listNavigation.onItemPointerMove(event, index());
+	}
+	function handlePointerLeave(event) {
+		if (context.keepHighlight()) return;
+		context.listNavigation.onItemPointerLeave(event);
+	}
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => handleClick);
+	const onMouseDown = composeEventHandlers(() => internalProps.onMouseDown, () => handleMouseDown);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => handleMouseUp);
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => handlePointerDown);
+	const onPointerMove = composeEventHandlers(() => internalProps.onPointerMove, () => handlePointerMove);
+	const onPointerLeave = composeEventHandlers(() => internalProps.onPointerLeave, () => handlePointerLeave);
+	createEffect(() => ({
+		registered: hasRegistered(),
+		hasItems: context.hasItems(),
+		index: index(),
+		value: itemValue(),
+		selected: context.selectedValue(),
+		compare: context.comparator()
+	}), (current) => {
+		if (!current.registered || current.hasItems) return;
+		const lastSelected = Array.isArray(current.selected) ? current.selected[current.selected.length - 1] : current.selected;
+		if (compareItemEquality(current.value, lastSelected, current.compare)) untrack(() => context.store.setSelectedIndex(current.index));
+	});
+	createEffect(element, () => context.store.collection.touch());
+	onCleanup(unregister);
+	return ComboboxItemContext({
+		value: {
+			selected,
+			index
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => {
+					setElement(value);
+					context.store.collection.touch();
+				}), internalProps.ref],
+				get id() {
+					return id();
+				},
+				get type() {
+					return nativeButton() ? "button" : void 0;
+				},
+				role: isRow ? "gridcell" : "option",
+				get ["aria-selected"]() {
+					return memo(() => {
+						return !!selectable();
+					})() ? selected() ? "true" : "false" : void 0;
+				},
+				get ["aria-disabled"]() {
+					return disabled() ? "true" : void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onClick,
+				onMouseDown,
+				onMouseUp,
+				onPointerDown,
+				onPointerLeave,
+				onPointerMove
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/combobox/row/ComboboxRow.tsx
+/**
+* A single row of items in a grid list.
+* Enable `grid` on the root component to turn the listbox into a grid.
+*/
+function ComboboxRow(props) {
+	const internalProps = props;
+	const allProps = props;
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return ComboboxRowContext({
+		value: true,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [internalProps.ref],
+				role: "row",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, others));
+		}
+	});
+}
+//#endregion
+//#region src/combobox/empty/ComboboxEmpty.tsx
+/**
+* Renders its children only when the list is empty, announcing the change politely.
+*
+* The root element must stay mounted for screen readers to announce consistently, so hide or
+* conditionally render its children rather than the component itself.
+*/
+function ComboboxEmpty(props) {
+	const context = useComboboxRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "children", "class", "ref", "style");
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	createInitialLiveRegionTextMutation(element);
+	onCleanup(() => {
+		if (context.store.emptyElement === element()) context.store.emptyElement = null;
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((value) => {
+			setElement(value);
+			context.store.emptyElement = value;
+		}), internalProps.ref],
+		role: "status",
+		"aria-live": "polite",
+		"aria-atomic": "true",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others, { get children() {
+		return Show({
+			get when() {
+				return context.listEmpty();
+			},
+			get children() {
+				return props.children;
+			}
+		});
+	} }));
+}
+//#endregion
+//#region src/combobox/separator/ComboboxSeparator.tsx
+/** A visual separator between items or groups. */
+function ComboboxSeparator(props) {
+	const internalProps = props;
+	const allProps = props;
+	const orientation = createMemo(() => internalProps.orientation ?? "horizontal");
+	const state = createMemo(() => ({ orientation: orientation() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "orientation", "ref", "style");
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		role: "presentation",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/combobox/root/utils/useFilteredItems.ts
+/**
+* The internally filtered items, as an accessor so consumers stay reactive to the query.
+*/
+function useFilteredItems() {
+	return useComboboxRootContext().filteredItems;
+}
+//#endregion
+export { getFilter as A, getIndexAfterChipRemoval as C, ComboboxTrigger as D, useRequiredComboboxChipsContext as E, resolveMultipleLabels as M, resolveSelectedLabel as N, AriaCombobox as O, stringifyAsLabel as P, getChipNavigationKeys as S, ComboboxChipsContext as T, ComboboxClear as _, ComboboxItem as a, handleInputPress as b, ComboboxGroup as c, ComboboxPositioner as d, ComboboxBackdrop as f, ComboboxCollection as g, ComboboxList as h, ComboboxRow as i, hasNullItemLabel as j, useComboboxRootContext as k, ComboboxArrow as l, ComboboxStatus as m, ComboboxSeparator as n, useComboboxItemContext as o, ComboboxPortal as p, ComboboxEmpty as r, ComboboxGroupLabel as s, useFilteredItems as t, ComboboxPopup as u, ComboboxIcon as v, ComboboxChipRegistry as w, ComboboxInput as x, ComboboxInputGroup as y };