@wix/site-ui 1.30.0 → 1.32.0

package/dist/6089.js

@@ -0,0 +1,2355 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { esm_formatErrorMessage, EMPTY_OBJECT, EMPTY_ARRAY, useMergedRefs, useRefWithInit, mergeProps, useRenderElement, NOOP } from "./8272.js";
+import { Store, createSelector, useStore, useDismiss } from "./5992.js";
+import { defaultItemEquality, findItemIndex, stringifyAsLabel, hasNullItemLabel, stringifyAsValue, compareItemEquality, isGroupedItems, selectedValueIncludes, removeItem } from "./7366.js";
+import { DROPDOWN_COLLISION_AVOIDANCE, triggerOpenStateMapping, FloatingPortal_FloatingPortal, popupStateMapping, pressableTriggerOpenStateMapping } from "./4388.js";
+import { FieldRootContext, DEFAULT_FIELD_STATE_ATTRIBUTES, DEFAULT_FIELD_ROOT_CONTEXT, useLabelableContext, fieldValidityMapping, useFieldRootContext } from "./1477.js";
+import { getTarget, contains as shadowDom_contains } from "./4549.js";
+import { isElement } from "./3829.js";
+import { isInteractiveElement } from "./8758.js";
+import { createGenericEventDetails, createChangeEventDetails } from "./4768.js";
+import { itemPress, outsidePress, inputClear, closePress, focusOut, inputChange, listNavigation as reason_parts_listNavigation, inputPress, clearPress, escapeKey } from "./2418.js";
+import { useStableCallback } from "./7541.js";
+import { useCompositeListItem, useCompositeListItem_IndexGuessBehavior } from "./3021.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { useButton } from "./9189.js";
+import { visuallyHiddenInput, visuallyHidden } from "./8225.js";
+import { useDirection } from "./9863.js";
+import { useBaseUiId } from "./6046.js";
+import { resolveAriaLabelledBy } from "./6825.js";
+import { isAndroid, isFirefox, isIOS } from "./8971.js";
+import { stopEvent } from "./6330.js";
+import { transitionStatusMapping, useOpenChangeComplete, useTransitionStatus } from "./880.js";
+import { CompositeList } from "./9255.js";
+import { useTimeout } from "./42.js";
+import { usePositioner, useFloatingRootContext, useAnchorPositioning, getDisabledMountTransitionStyles } from "./8750.js";
+import { useAnchoredPopupScrollLock } from "./6247.js";
+import { useOpenInteractionType, FloatingFocusManager, InternalBackdrop_InternalBackdrop } from "./3485.js";
+import { inertValue } from "./167.js";
+import { useLabelableId } from "./9048.js";
+import { useListNavigation, useTypeahead } from "./5299.js";
+import { useClick } from "./5864.js";
+import { ownerDocument } from "./9829.js";
+import { getPseudoElementBounds } from "./7373.js";
+import { useFormContext } from "./5085.js";
+import { useControlled } from "./8527.js";
+import { useValueAsRef } from "./4707.js";
+import { useRegisterFieldControl } from "./4281.js";
+import { useValueChanged } from "./2801.js";
+import { FOCUSABLE_POPUP_PROPS, useOnFirstRender } from "./8106.js";
+import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+const ComboboxRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxRootContext.displayName = "ComboboxRootContext";
+const ComboboxFloatingContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxFloatingContext.displayName = "ComboboxFloatingContext";
+const ComboboxDerivedItemsContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxDerivedItemsContext.displayName = "ComboboxDerivedItemsContext";
+const ComboboxInputValueContext = /*#__PURE__*/ __rspack_external_react.createContext('');
+if ("production" !== process.env.NODE_ENV) ComboboxInputValueContext.displayName = "ComboboxInputValueContext";
+function useComboboxRootContext() {
+    const context = __rspack_external_react.useContext(ComboboxRootContext);
+    if (!context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ComboboxRootContext is missing. Combobox parts must be placed within <Combobox.Root>.' : esm_formatErrorMessage(22));
+    return context;
+}
+function useComboboxFloatingContext() {
+    const context = __rspack_external_react.useContext(ComboboxFloatingContext);
+    if (!context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ComboboxFloatingContext is missing. Combobox parts must be placed within <Combobox.Root>.' : esm_formatErrorMessage(23));
+    return context;
+}
+function useComboboxDerivedItemsContext() {
+    const context = __rspack_external_react.useContext(ComboboxDerivedItemsContext);
+    if (!context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ComboboxItemsContext is missing. Combobox parts must be placed within <Combobox.Root>.' : esm_formatErrorMessage(24));
+    return context;
+}
+function useComboboxInputValueContext() {
+    return __rspack_external_react.useContext(ComboboxInputValueContext);
+}
+const selectors = {
+    id: createSelector((state)=>state.id),
+    labelId: createSelector((state)=>state.labelId),
+    items: createSelector((state)=>state.items),
+    selectedValue: createSelector((state)=>state.selectedValue),
+    hasSelectionChips: createSelector((state)=>{
+        const selectedValue = state.selectedValue;
+        return Array.isArray(selectedValue) && selectedValue.length > 0;
+    }),
+    hasSelectedValue: createSelector((state)=>{
+        const { selectedValue, selectionMode } = state;
+        if (null == selectedValue) return false;
+        if ('multiple' === selectionMode && Array.isArray(selectedValue)) return selectedValue.length > 0;
+        return true;
+    }),
+    hasNullItemLabel: createSelector((state, enabled)=>enabled ? hasNullItemLabel(state.items) : false),
+    open: createSelector((state)=>state.open),
+    mounted: createSelector((state)=>state.mounted),
+    forceMounted: createSelector((state)=>state.forceMounted),
+    inline: createSelector((state)=>state.inline),
+    activeIndex: createSelector((state)=>state.activeIndex),
+    selectedIndex: createSelector((state)=>state.selectedIndex),
+    isActive: createSelector((state, index)=>state.activeIndex === index),
+    isSelected: createSelector((state, itemValue)=>{
+        const comparer = state.isItemEqualToValue;
+        const selectedValue = state.selectedValue;
+        if (Array.isArray(selectedValue)) return selectedValue.some((selectedItem)=>compareItemEquality(itemValue, selectedItem, comparer));
+        return compareItemEquality(itemValue, selectedValue, comparer);
+    }),
+    transitionStatus: createSelector((state)=>state.transitionStatus),
+    popupProps: createSelector((state)=>state.popupProps),
+    inputProps: createSelector((state)=>state.inputProps),
+    triggerProps: createSelector((state)=>state.triggerProps),
+    itemProps: createSelector((state)=>state.itemProps),
+    positionerElement: createSelector((state)=>state.positionerElement),
+    listElement: createSelector((state)=>state.listElement),
+    triggerElement: createSelector((state)=>state.triggerElement),
+    inputElement: createSelector((state)=>state.inputElement),
+    inputGroupElement: createSelector((state)=>state.inputGroupElement),
+    popupSide: createSelector((state)=>state.popupSide),
+    openMethod: createSelector((state)=>state.openMethod),
+    inputInsidePopup: createSelector((state)=>state.inputInsidePopup),
+    inputOwnsFormValue: createSelector((state)=>state.inputOwnsFormValue),
+    selectionMode: createSelector((state)=>state.selectionMode),
+    name: createSelector((state)=>state.name),
+    form: createSelector((state)=>state.form),
+    disabled: createSelector((state)=>state.disabled),
+    readOnly: createSelector((state)=>state.readOnly),
+    required: createSelector((state)=>state.required),
+    grid: createSelector((state)=>state.grid),
+    virtualized: createSelector((state)=>state.virtualized),
+    itemToStringLabel: createSelector((state)=>state.itemToStringLabel),
+    isItemEqualToValue: createSelector((state)=>state.isItemEqualToValue),
+    modal: createSelector((state)=>state.modal),
+    autoHighlight: createSelector((state)=>state.autoHighlight),
+    submitOnItemClick: createSelector((state)=>state.submitOnItemClick)
+};
+const triggerStateAttributesMapping = {
+    ...pressableTriggerOpenStateMapping,
+    ...fieldValidityMapping,
+    popupSide: (side)=>side ? {
+            'data-popup-side': side
+        } : null,
+    listEmpty: (empty)=>empty ? {
+            'data-list-empty': ''
+        } : null
+};
+function handleInputPress(event, store, disabled, readOnly, shouldIgnoreTarget) {
+    if (event.baseUIHandlerPrevented || readOnly) return;
+    const target = getTarget(event.nativeEvent);
+    const targetElement = isElement(target) ? target : null;
+    if (targetElement !== event.currentTarget && (shouldIgnoreTarget?.(targetElement) || isInteractiveElement(targetElement))) return;
+    event.preventDefault();
+    if (disabled) return;
+    store.state.inputRef.current?.focus();
+    if (store.state.openOnInputClick) store.state.setOpen(true, createChangeEventDetails(inputPress, event.nativeEvent));
+}
+const ComboboxInputGroup_ComboboxInputGroup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { state: fieldState } = useFieldRootContext();
+    const store = useComboboxRootContext();
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const popupSideValue = useStore(store, selectors.popupSide);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const comboboxDisabled = useStore(store, selectors.disabled);
+    const readOnly = useStore(store, selectors.readOnly);
+    const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+    const selectionMode = useStore(store, selectors.selectionMode);
+    const popupSide = mounted && positionerElement ? popupSideValue : null;
+    const disabled = comboboxDisabled;
+    const listEmpty = 0 === filteredItems.length;
+    const placeholder = 'none' === selectionMode ? false : !hasSelectedValue;
+    const state = {
+        ...fieldState,
+        open,
+        disabled,
+        readOnly,
+        popupSide,
+        listEmpty,
+        placeholder
+    };
+    const setInputGroupElement = useStableCallback((element)=>{
+        store.set('inputGroupElement', element);
+    });
+    return useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            setInputGroupElement
+        ],
+        props: [
+            {
+                role: 'group',
+                onMouseDown (event) {
+                    handleInputPress(event, store, disabled, readOnly, (target)=>shadowDom_contains(store.state.chipsContainerRef.current, target));
+                }
+            },
+            elementProps
+        ],
+        state,
+        stateAttributesMapping: triggerStateAttributesMapping
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxInputGroup_ComboboxInputGroup.displayName = "ComboboxInputGroup";
+const ComboboxItemContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxItemContext.displayName = "ComboboxItemContext";
+function useComboboxItemContext() {
+    const context = __rspack_external_react.useContext(ComboboxItemContext);
+    if (!context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ComboboxItemContext is missing. ComboboxItem parts must be placed within <Combobox.Item>.' : esm_formatErrorMessage(19));
+    return context;
+}
+const ComboboxRowContext = /*#__PURE__*/ __rspack_external_react.createContext(false);
+if ("production" !== process.env.NODE_ENV) ComboboxRowContext.displayName = "ComboboxRowContext";
+function useComboboxRowContext() {
+    return __rspack_external_react.useContext(ComboboxRowContext);
+}
+const ComboboxItem_ComboboxItem = /*#__PURE__*/ __rspack_external_react.memo(/*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, value: itemValue = null, index: indexProp, disabled = false, nativeButton = false, ...elementProps } = componentProps;
+    const didPointerDownRef = __rspack_external_react.useRef(false);
+    const textRef = __rspack_external_react.useRef(null);
+    const listItem = useCompositeListItem({
+        index: indexProp,
+        textRef,
+        indexGuessBehavior: useCompositeListItem_IndexGuessBehavior.GuessFromOrder
+    });
+    const store = useComboboxRootContext();
+    const isRow = useComboboxRowContext();
+    const { flatFilteredItems, hasItems } = useComboboxDerivedItemsContext();
+    const open = useStore(store, selectors.open);
+    const selectionMode = useStore(store, selectors.selectionMode);
+    const readOnly = useStore(store, selectors.readOnly);
+    const virtualized = useStore(store, selectors.virtualized);
+    const isItemEqualToValue = useStore(store, selectors.isItemEqualToValue);
+    const selectable = 'none' !== selectionMode;
+    const index = indexProp ?? (virtualized ? findItemIndex(flatFilteredItems, itemValue, isItemEqualToValue) : listItem.index);
+    const hasRegistered = -1 !== listItem.index;
+    const rootId = useStore(store, selectors.id);
+    const highlighted = useStore(store, selectors.isActive, index);
+    const matchesSelectedValue = useStore(store, selectors.isSelected, itemValue);
+    const itemProps = useStore(store, selectors.itemProps);
+    const itemRef = __rspack_external_react.useRef(null);
+    const id = null != rootId && hasRegistered ? `${rootId}-${index}` : void 0;
+    const selected = matchesSelectedValue && selectable;
+    useIsoLayoutEffect(()=>{
+        const shouldRun = hasRegistered && (virtualized || null != indexProp);
+        if (!shouldRun) return;
+        const list = store.state.listRef.current;
+        list[index] = itemRef.current;
+        return ()=>{
+            delete list[index];
+        };
+    }, [
+        hasRegistered,
+        virtualized,
+        index,
+        indexProp,
+        store
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!hasRegistered || hasItems) return;
+        const visibleMap = store.state.valuesRef.current;
+        visibleMap[index] = itemValue;
+        if ('none' !== selectionMode) store.state.allValuesRef.current.push(itemValue);
+        return ()=>{
+            delete visibleMap[index];
+        };
+    }, [
+        hasRegistered,
+        hasItems,
+        index,
+        itemValue,
+        store,
+        selectionMode
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!open) {
+            didPointerDownRef.current = false;
+            return;
+        }
+        if (!hasRegistered || hasItems) return;
+        const selectedValue = store.state.selectedValue;
+        const lastSelectedValue = Array.isArray(selectedValue) ? selectedValue[selectedValue.length - 1] : selectedValue;
+        if (compareItemEquality(itemValue, lastSelectedValue, isItemEqualToValue)) store.set('selectedIndex', index);
+    }, [
+        hasRegistered,
+        hasItems,
+        open,
+        store,
+        index,
+        itemValue,
+        isItemEqualToValue
+    ]);
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        focusableWhenDisabled: true,
+        native: nativeButton,
+        composite: true
+    });
+    const state = {
+        disabled,
+        selected,
+        highlighted
+    };
+    function commitSelection(nativeEvent) {
+        function selectItem() {
+            store.state.handleSelection(nativeEvent, itemValue);
+        }
+        if (store.state.submitOnItemClick) {
+            __rspack_external_react_dom_7136dc57.flushSync(selectItem);
+            store.state.requestSubmit();
+        } else selectItem();
+    }
+    const defaultProps = {
+        id,
+        role: isRow ? 'gridcell' : 'option',
+        'aria-selected': selectable ? selected : void 0,
+        tabIndex: void 0,
+        onPointerDownCapture (event) {
+            didPointerDownRef.current = true;
+            event.preventDefault();
+        },
+        onMouseDown (event) {
+            event.preventDefault();
+        },
+        onClick (event) {
+            if (disabled || readOnly) return;
+            commitSelection(event.nativeEvent);
+        },
+        onMouseUp (event) {
+            const pointerStartedOnItem = didPointerDownRef.current;
+            didPointerDownRef.current = false;
+            if (disabled || readOnly || 0 !== event.button || pointerStartedOnItem || !highlighted) return;
+            commitSelection(event.nativeEvent);
+        }
+    };
+    const element = useRenderElement('div', componentProps, {
+        ref: [
+            buttonRef,
+            forwardedRef,
+            listItem.ref,
+            itemRef
+        ],
+        state,
+        props: [
+            itemProps,
+            defaultProps,
+            elementProps,
+            getButtonProps
+        ]
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            selected,
+            textRef
+        }), [
+        selected,
+        textRef
+    ]);
+    return /*#__PURE__*/ jsx(ComboboxItemContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+}));
+if ("production" !== process.env.NODE_ENV) ComboboxItem_ComboboxItem.displayName = "ComboboxItem";
+const ComboboxChipsContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxChipsContext.displayName = "ComboboxChipsContext";
+function useComboboxChipsContext() {
+    return __rspack_external_react.useContext(ComboboxChipsContext);
+}
+const ComboboxPositionerContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxPositionerContext.displayName = "ComboboxPositionerContext";
+function useComboboxPositionerContext(optional) {
+    const context = __rspack_external_react.useContext(ComboboxPositionerContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Combobox.Popup> and <Combobox.Arrow> must be used within the <Combobox.Positioner> component' : esm_formatErrorMessage(21));
+    return context;
+}
+const ComboboxInternalDismissButton_ComboboxInternalDismissButton = /*#__PURE__*/ __rspack_external_react.forwardRef(function(_, forwardedRef) {
+    const store = useComboboxRootContext();
+    const { buttonRef, getButtonProps } = useButton({
+        native: false
+    });
+    const mergedRef = useMergedRefs(forwardedRef, buttonRef);
+    function handleDismiss(event) {
+        store.state.setOpen(false, createChangeEventDetails(closePress, event.nativeEvent, event.currentTarget));
+    }
+    const dismissProps = getButtonProps({
+        onClick: handleDismiss
+    });
+    return /*#__PURE__*/ jsx("span", {
+        ref: mergedRef,
+        ...dismissProps,
+        "aria-label": "Dismiss",
+        tabIndex: void 0,
+        style: visuallyHiddenInput
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxInternalDismissButton_ComboboxInternalDismissButton.displayName = "ComboboxInternalDismissButton";
+const ComboboxInput_ComboboxInput = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, disabled: disabledProp = false, id: idProp, style, ...elementProps } = componentProps;
+    const { state: fieldState, disabled: fieldDisabled, setTouched, setFocused, validationMode, validation } = useFieldRootContext();
+    const { labelId: fieldLabelId } = useLabelableContext();
+    const comboboxChipsContext = useComboboxChipsContext();
+    const positioning = useComboboxPositionerContext(true);
+    const hasPositionerParent = Boolean(positioning);
+    const store = useComboboxRootContext();
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const inputValue = useComboboxInputValueContext();
+    const direction = useDirection();
+    const required = useStore(store, selectors.required);
+    const comboboxDisabled = useStore(store, selectors.disabled);
+    const readOnly = useStore(store, selectors.readOnly);
+    const name = useStore(store, selectors.name);
+    const form = useStore(store, selectors.form);
+    const selectionMode = useStore(store, selectors.selectionMode);
+    const autoHighlightMode = useStore(store, selectors.autoHighlight);
+    const inputProps = useStore(store, selectors.inputProps);
+    const triggerProps = useStore(store, selectors.triggerProps);
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const selectedValue = useStore(store, selectors.selectedValue);
+    const popupSideValue = useStore(store, selectors.popupSide);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const rootId = useStore(store, selectors.id);
+    const inline = useStore(store, selectors.inline);
+    const modal = useStore(store, selectors.modal);
+    const autoHighlightEnabled = Boolean(autoHighlightMode);
+    const popupSide = mounted && positionerElement ? popupSideValue : null;
+    const disabled = fieldDisabled || comboboxDisabled || disabledProp;
+    const listEmpty = 0 === filteredItems.length;
+    const isInsidePopup = hasPositionerParent || inline;
+    const focusManagerModal = !isInsidePopup || modal;
+    const id = useBaseUiId(idProp ?? (isInsidePopup ? void 0 : rootId));
+    const ariaLabelledBy = resolveAriaLabelledBy(fieldLabelId, void 0);
+    const fieldStateForInput = hasPositionerParent ? DEFAULT_FIELD_STATE_ATTRIBUTES : fieldState;
+    const [composingValue, setComposingValue] = __rspack_external_react.useState(null);
+    const isComposingRef = __rspack_external_react.useRef(false);
+    const lastActiveIndexRef = __rspack_external_react.useRef(null);
+    const shouldRestoreActiveIndexRef = __rspack_external_react.useRef(false);
+    const inputOwnsFormValue = 'none' === selectionMode && !hasPositionerParent;
+    const setInputElement = useStableCallback((element)=>{
+        const nextIsInsidePopup = hasPositionerParent || store.state.inline;
+        if (nextIsInsidePopup && !store.state.hasInputValue) store.state.setInputValue('', createChangeEventDetails("none"));
+        store.update({
+            inputElement: element,
+            inputInsidePopup: nextIsInsidePopup,
+            inputOwnsFormValue
+        });
+    });
+    const validationProps = hasPositionerParent || !validation ? elementProps : validation.getValidationProps(elementProps);
+    const state = {
+        ...fieldStateForInput,
+        open,
+        disabled,
+        readOnly,
+        popupSide,
+        listEmpty
+    };
+    function handleKeyDown(event) {
+        if (!comboboxChipsContext) return;
+        let nextIndex;
+        const { highlightedChipIndex } = comboboxChipsContext;
+        const renderedChipsCount = comboboxChipsContext.chipsRef.current.length;
+        const isRtl = 'rtl' === direction;
+        const previousChipKey = isRtl ? 'ArrowRight' : 'ArrowLeft';
+        const nextChipKey = isRtl ? 'ArrowLeft' : 'ArrowRight';
+        if (void 0 !== highlightedChipIndex) {
+            if (event.key === previousChipKey) {
+                event.preventDefault();
+                nextIndex = highlightedChipIndex > 0 ? highlightedChipIndex - 1 : void 0;
+            } else if (event.key === nextChipKey) {
+                event.preventDefault();
+                nextIndex = highlightedChipIndex < renderedChipsCount - 1 ? highlightedChipIndex + 1 : void 0;
+            } else if ('Backspace' === event.key || 'Delete' === event.key) {
+                event.preventDefault();
+                const computedNextIndex = highlightedChipIndex >= selectedValue.length - 1 ? selectedValue.length - 2 : highlightedChipIndex;
+                nextIndex = computedNextIndex >= 0 ? computedNextIndex : void 0;
+                store.state.setIndices({
+                    activeIndex: null,
+                    selectedIndex: null,
+                    type: 'keyboard'
+                });
+            }
+            return nextIndex;
+        }
+        if (event.key === previousChipKey && (event.currentTarget.selectionStart ?? 0) === 0 && selectedValue.length > 0) {
+            event.preventDefault();
+            nextIndex = renderedChipsCount > 0 ? renderedChipsCount - 1 : void 0;
+        } else if ('Backspace' === event.key && '' === event.currentTarget.value && selectedValue.length > 0) {
+            store.state.setIndices({
+                activeIndex: null,
+                selectedIndex: null,
+                type: 'keyboard'
+            });
+            event.preventDefault();
+        }
+        return nextIndex;
+    }
+    const element = useRenderElement('input', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            store.state.inputRef,
+            setInputElement
+        ],
+        props: [
+            inputProps,
+            triggerProps,
+            {
+                type: 'text',
+                value: componentProps.value ?? composingValue ?? inputValue,
+                'aria-readonly': readOnly || void 0,
+                'aria-required': required || void 0,
+                'aria-labelledby': ariaLabelledBy,
+                disabled,
+                readOnly,
+                required: 'none' === selectionMode ? required : void 0,
+                form,
+                ...inputOwnsFormValue && name && {
+                    name
+                },
+                id,
+                onFocus () {
+                    setFocused(true);
+                    if (!inline || !shouldRestoreActiveIndexRef.current) return;
+                    shouldRestoreActiveIndexRef.current = false;
+                    const nextActiveIndex = lastActiveIndexRef.current;
+                    if (null == nextActiveIndex || !Object.hasOwn(store.state.valuesRef.current, nextActiveIndex)) return;
+                    store.state.setIndices({
+                        activeIndex: nextActiveIndex
+                    });
+                },
+                onBlur () {
+                    setTouched(true);
+                    setFocused(false);
+                    const activeIndex = store.state.activeIndex;
+                    if (inline && null !== activeIndex && 'always' !== autoHighlightMode) {
+                        lastActiveIndexRef.current = activeIndex;
+                        shouldRestoreActiveIndexRef.current = true;
+                        store.state.setIndices({
+                            activeIndex: null
+                        });
+                    }
+                    if ('onBlur' === validationMode) {
+                        const valueToValidate = 'none' === selectionMode ? inputValue : selectedValue;
+                        validation.commit(valueToValidate);
+                    }
+                },
+                onCompositionStart (event) {
+                    if (isAndroid) return;
+                    isComposingRef.current = true;
+                    setComposingValue(event.currentTarget.value);
+                },
+                onCompositionEnd (event) {
+                    isComposingRef.current = false;
+                    const next = event.currentTarget.value;
+                    setComposingValue(null);
+                    store.state.setInputValue(next, createChangeEventDetails(inputChange, event.nativeEvent));
+                },
+                onChange (event) {
+                    const inputType = event.nativeEvent.inputType;
+                    const autofillLikeInput = !inputType || 'insertReplacementText' === inputType;
+                    const shouldOpenOnInput = isComposingRef.current || !autofillLikeInput;
+                    if (isComposingRef.current) {
+                        const nextVal = event.currentTarget.value;
+                        setComposingValue(nextVal);
+                        if ('' === nextVal && !store.state.openOnInputClick && !store.state.inputInsidePopup) store.state.setOpen(false, createChangeEventDetails(inputClear, event.nativeEvent));
+                        const trimmed = nextVal.trim();
+                        const shouldMaintainHighlight = autoHighlightEnabled && '' !== trimmed;
+                        if (!readOnly && !disabled && trimmed) {
+                            if (shouldOpenOnInput) {
+                                store.state.setOpen(true, createChangeEventDetails(inputChange, event.nativeEvent));
+                                if (!autoHighlightEnabled) store.state.setIndices({
+                                    activeIndex: null,
+                                    selectedIndex: null,
+                                    type: store.state.keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                                });
+                            }
+                        }
+                        if (open && null !== store.state.activeIndex && !shouldMaintainHighlight) store.state.setIndices({
+                            activeIndex: null,
+                            selectedIndex: null,
+                            type: store.state.keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                        });
+                        return;
+                    }
+                    store.state.setInputValue(event.currentTarget.value, createChangeEventDetails(inputChange, event.nativeEvent));
+                    const empty = '' === event.currentTarget.value;
+                    const clearDetails = createChangeEventDetails(inputClear, event.nativeEvent);
+                    if (empty && !store.state.inputInsidePopup) {
+                        if ('single' === selectionMode) store.state.setSelectedValue(null, clearDetails);
+                        if (!store.state.openOnInputClick) store.state.setOpen(false, clearDetails);
+                    }
+                    const trimmed = event.currentTarget.value.trim();
+                    if (!readOnly && !disabled && trimmed) {
+                        if (shouldOpenOnInput) {
+                            store.state.setOpen(true, createChangeEventDetails(inputChange, event.nativeEvent));
+                            if (!autoHighlightEnabled) store.state.setIndices({
+                                activeIndex: null,
+                                selectedIndex: null,
+                                type: store.state.keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                            });
+                        }
+                    }
+                    if (open && null !== store.state.activeIndex && !autoHighlightEnabled) store.state.setIndices({
+                        activeIndex: null,
+                        selectedIndex: null,
+                        type: store.state.keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                    });
+                },
+                onKeyDown (event) {
+                    if (disabled || readOnly) return;
+                    if (event.ctrlKey || event.shiftKey || event.altKey || event.metaKey) return;
+                    store.state.keyboardActiveRef.current = true;
+                    const input = event.currentTarget;
+                    const scrollAmount = input.scrollWidth - input.clientWidth;
+                    const isRTL = 'rtl' === direction;
+                    if ('Home' === event.key) {
+                        stopEvent(event);
+                        const cursor = isFirefox && isRTL ? input.value.length : 0;
+                        input.setSelectionRange(cursor, cursor);
+                        input.scrollLeft = 0;
+                        return;
+                    }
+                    if ('End' === event.key) {
+                        stopEvent(event);
+                        const cursor = isFirefox && isRTL ? 0 : input.value.length;
+                        input.setSelectionRange(cursor, cursor);
+                        input.scrollLeft = isRTL ? -scrollAmount : scrollAmount;
+                        return;
+                    }
+                    if (!mounted && 'Escape' === event.key) {
+                        const isClear = 'multiple' === selectionMode && Array.isArray(selectedValue) ? 0 === selectedValue.length : null === selectedValue;
+                        const details = createChangeEventDetails(escapeKey, event.nativeEvent);
+                        const value = 'multiple' === selectionMode ? [] : null;
+                        store.state.setInputValue('', details);
+                        store.state.setSelectedValue(value, details);
+                        if (!isClear && !store.state.inline && !details.isPropagationAllowed) event.stopPropagation();
+                        return;
+                    }
+                    if (comboboxChipsContext && 'Backspace' === event.key && '' === input.value && void 0 === comboboxChipsContext.highlightedChipIndex && Array.isArray(selectedValue) && selectedValue.length > 0) {
+                        const renderedChipsCount = comboboxChipsContext.chipsRef.current.length;
+                        const removalIndex = renderedChipsCount > 0 ? renderedChipsCount - 1 : selectedValue.length - 1;
+                        const newValue = selectedValue.filter((_, index)=>index !== removalIndex);
+                        store.state.setIndices({
+                            activeIndex: null,
+                            selectedIndex: null,
+                            type: store.state.keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                        });
+                        store.state.setSelectedValue(newValue, createChangeEventDetails("none", event.nativeEvent));
+                        return;
+                    }
+                    const hadHighlightedChip = comboboxChipsContext?.highlightedChipIndex !== void 0;
+                    const nextIndex = handleKeyDown(event);
+                    comboboxChipsContext?.setHighlightedChipIndex(nextIndex);
+                    if (void 0 !== nextIndex) comboboxChipsContext?.chipsRef.current[nextIndex]?.focus();
+                    else if (hadHighlightedChip) store.state.inputRef.current?.focus();
+                    if (229 === event.which) return;
+                    if ('Enter' === event.key && open) {
+                        const activeIndex = store.state.activeIndex;
+                        const nativeEvent = event.nativeEvent;
+                        if (null === activeIndex) {
+                            if (inline) return;
+                            store.state.setOpen(false, createChangeEventDetails("none", nativeEvent));
+                            return;
+                        }
+                        stopEvent(event);
+                        const listItem = store.state.listRef.current[activeIndex];
+                        if (listItem) {
+                            store.state.selectionEventRef.current = nativeEvent;
+                            listItem.click();
+                            store.state.selectionEventRef.current = null;
+                        }
+                    }
+                },
+                onPointerMove () {
+                    store.state.keyboardActiveRef.current = false;
+                },
+                onPointerDown () {
+                    store.state.keyboardActiveRef.current = false;
+                }
+            },
+            validationProps
+        ],
+        stateAttributesMapping: triggerStateAttributesMapping
+    });
+    const renderedInput = hasPositionerParent ? /*#__PURE__*/ jsx(FieldRootContext.Provider, {
+        value: DEFAULT_FIELD_ROOT_CONTEXT,
+        children: element
+    }) : element;
+    return /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            open && focusManagerModal && /*#__PURE__*/ jsx(ComboboxInternalDismissButton_ComboboxInternalDismissButton, {
+                ref: store.state.startDismissRef
+            }),
+            renderedInput
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxInput_ComboboxInput.displayName = "ComboboxInput";
+const ComboboxIcon_ComboboxIcon = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const element = useRenderElement('span', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                'aria-hidden': true,
+                children: '▼'
+            },
+            elementProps
+        ]
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ComboboxIcon_ComboboxIcon.displayName = "ComboboxIcon";
+const stateAttributesMapping = {
+    ...transitionStatusMapping,
+    ...triggerOpenStateMapping
+};
+const ComboboxClear_ComboboxClear = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, disabled: disabledProp = false, nativeButton = true, keepMounted = false, style, ...elementProps } = componentProps;
+    const { disabled: fieldDisabled } = useFieldRootContext();
+    const store = useComboboxRootContext();
+    const selectionMode = useStore(store, selectors.selectionMode);
+    const comboboxDisabled = useStore(store, selectors.disabled);
+    const readOnly = useStore(store, selectors.readOnly);
+    const open = useStore(store, selectors.open);
+    const selectedValue = useStore(store, selectors.selectedValue);
+    const hasSelectionChips = useStore(store, selectors.hasSelectionChips);
+    const inputValue = useComboboxInputValueContext();
+    let visible = false;
+    visible = 'none' === selectionMode ? '' !== inputValue : 'single' === selectionMode ? null != selectedValue : hasSelectionChips;
+    const disabled = fieldDisabled || comboboxDisabled || disabledProp;
+    const { buttonRef, getButtonProps } = useButton({
+        native: nativeButton,
+        disabled
+    });
+    const { mounted, transitionStatus, setMounted } = useTransitionStatus(visible);
+    const state = {
+        disabled,
+        visible,
+        open,
+        transitionStatus
+    };
+    useOpenChangeComplete({
+        open: visible,
+        ref: store.state.clearRef,
+        onComplete () {
+            if (!visible) setMounted(false);
+        }
+    });
+    const element = useRenderElement('button', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            buttonRef,
+            store.state.clearRef
+        ],
+        props: [
+            {
+                tabIndex: -1,
+                children: 'x',
+                onMouseDown (event) {
+                    event.preventDefault();
+                },
+                onClick (event) {
+                    if (disabled || readOnly) return;
+                    const keyboardActiveRef = store.state.keyboardActiveRef;
+                    store.state.setInputValue('', createChangeEventDetails(clearPress, event.nativeEvent));
+                    if ('none' !== selectionMode) {
+                        store.state.setSelectedValue(Array.isArray(selectedValue) ? [] : null, createChangeEventDetails(clearPress, event.nativeEvent));
+                        store.state.setIndices({
+                            activeIndex: null,
+                            selectedIndex: null,
+                            type: keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                        });
+                    } else store.state.setIndices({
+                        activeIndex: null,
+                        type: keyboardActiveRef.current ? 'keyboard' : 'pointer'
+                    });
+                    store.state.inputRef.current?.focus();
+                }
+            },
+            elementProps,
+            getButtonProps
+        ],
+        stateAttributesMapping: stateAttributesMapping
+    });
+    const shouldRender = keepMounted || mounted;
+    if (!shouldRender) return null;
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ComboboxClear_ComboboxClear.displayName = "ComboboxClear";
+const GroupCollectionContext = /*#__PURE__*/ __rspack_external_react.createContext(null);
+if ("production" !== process.env.NODE_ENV) GroupCollectionContext.displayName = "GroupCollectionContext";
+function useGroupCollectionContext() {
+    return __rspack_external_react.useContext(GroupCollectionContext);
+}
+function GroupCollectionProvider(props) {
+    const { children, items } = props;
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            items
+        }), [
+        items
+    ]);
+    return /*#__PURE__*/ jsx(GroupCollectionContext.Provider, {
+        value: contextValue,
+        children: children
+    });
+}
+function ComboboxCollection(props) {
+    const { children } = props;
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const groupContext = useGroupCollectionContext();
+    const itemsToRender = groupContext ? groupContext.items : filteredItems;
+    if (!itemsToRender) return null;
+    return /*#__PURE__*/ jsx(__rspack_external_react.Fragment, {
+        children: itemsToRender.map(children)
+    });
+}
+const ComboboxList_ComboboxList = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    var _ComboboxCollection;
+    const { render, className, style, children, ...elementProps } = componentProps;
+    const store = useComboboxRootContext();
+    const floatingRootContext = useComboboxFloatingContext();
+    const hasPositionerContext = Boolean(useComboboxPositionerContext(true));
+    const { filteredItems, hasItems } = useComboboxDerivedItemsContext();
+    const selectionMode = useStore(store, selectors.selectionMode);
+    const grid = useStore(store, selectors.grid);
+    const popupProps = useStore(store, selectors.popupProps);
+    const virtualized = useStore(store, selectors.virtualized);
+    const multiple = 'multiple' === selectionMode;
+    const empty = 0 === filteredItems.length;
+    const setPositionerElement = useStableCallback((element)=>{
+        store.set('positionerElement', element);
+    });
+    const setListElement = useStableCallback((element)=>{
+        store.set('listElement', element);
+    });
+    const resolvedChildren = __rspack_external_react.useMemo(()=>{
+        if ('function' == typeof children) return _ComboboxCollection || (_ComboboxCollection = /*#__PURE__*/ jsx(ComboboxCollection, {
+            children: children
+        }));
+        return children;
+    }, [
+        children
+    ]);
+    const state = {
+        empty
+    };
+    const floatingId = floatingRootContext.useState('floatingId');
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            setListElement,
+            hasPositionerContext ? null : setPositionerElement
+        ],
+        props: [
+            popupProps,
+            {
+                children: resolvedChildren,
+                tabIndex: -1,
+                id: floatingId,
+                role: grid ? 'grid' : 'listbox',
+                'aria-multiselectable': multiple ? 'true' : void 0,
+                onKeyDown (event) {
+                    if (store.state.disabled || store.state.readOnly) return;
+                    if ('Enter' === event.key) {
+                        const activeIndex = store.state.activeIndex;
+                        if (null == activeIndex) return;
+                        stopEvent(event);
+                        const nativeEvent = event.nativeEvent;
+                        const listItem = store.state.listRef.current[activeIndex];
+                        if (listItem) {
+                            store.state.selectionEventRef.current = nativeEvent;
+                            listItem.click();
+                            store.state.selectionEventRef.current = null;
+                        }
+                    }
+                },
+                onKeyDownCapture () {
+                    store.state.keyboardActiveRef.current = true;
+                },
+                onPointerMoveCapture () {
+                    store.state.keyboardActiveRef.current = false;
+                }
+            },
+            elementProps
+        ]
+    });
+    if (virtualized) return element;
+    return /*#__PURE__*/ jsx(CompositeList, {
+        elementsRef: store.state.listRef,
+        labelsRef: hasItems ? void 0 : store.state.labelsRef,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxList_ComboboxList.displayName = "ComboboxList";
+const LIVE_REGION_MARKER = '\u2060';
+const INITIAL_LIVE_REGION_TEXT_MUTATION_RESET_DELAY = 200;
+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 useInitialLiveRegionTextMutation() {
+    const timeout = useTimeout();
+    const rootRef = __rspack_external_react.useRef(null);
+    __rspack_external_react.useEffect(()=>{
+        if (isIOS) return;
+        const root = rootRef.current;
+        if (null == root) return;
+        const textNode = findLastTextNode(root);
+        if (null == textNode) return;
+        const originalValue = textNode.nodeValue ?? '';
+        const markedValue = `${originalValue}${LIVE_REGION_MARKER}`;
+        textNode.nodeValue = markedValue;
+        timeout.start(INITIAL_LIVE_REGION_TEXT_MUTATION_RESET_DELAY, ()=>{
+            if (textNode.nodeValue === markedValue) textNode.nodeValue = originalValue;
+        });
+        return ()=>{
+            timeout.clear();
+            if (textNode.nodeValue === markedValue) textNode.nodeValue = originalValue;
+        };
+    }, [
+        rootRef,
+        timeout
+    ]);
+    return rootRef;
+}
+const ComboboxStatus_ComboboxStatus = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, children: childrenProp, ...elementProps } = componentProps;
+    const statusRef = useInitialLiveRegionTextMutation();
+    return useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            statusRef
+        ],
+        props: [
+            {
+                children: childrenProp,
+                role: 'status',
+                'aria-live': 'polite',
+                'aria-atomic': true
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxStatus_ComboboxStatus.displayName = "ComboboxStatus";
+const ComboboxBackdrop_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const ComboboxBackdrop_ComboboxBackdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const store = useComboboxRootContext();
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const transitionStatus = useStore(store, selectors.transitionStatus);
+    const state = {
+        open,
+        transitionStatus
+    };
+    return useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        stateAttributesMapping: ComboboxBackdrop_stateAttributesMapping,
+        props: [
+            {
+                role: 'presentation',
+                hidden: !mounted,
+                style: {
+                    userSelect: 'none',
+                    WebkitUserSelect: 'none'
+                }
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxBackdrop_ComboboxBackdrop.displayName = "ComboboxBackdrop";
+const ComboboxPortalContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxPortalContext.displayName = "ComboboxPortalContext";
+function useComboboxPortalContext() {
+    const context = __rspack_external_react.useContext(ComboboxPortalContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Combobox.Portal> is missing.' : esm_formatErrorMessage(20));
+    return context;
+}
+const ComboboxPositioner_ComboboxPositioner = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, anchor, positionMethod = 'absolute', side = 'bottom', align = 'center', sideOffset = 0, alignOffset = 0, collisionBoundary = 'clipping-ancestors', collisionPadding = 5, arrowPadding = 5, sticky = false, disableAnchorTracking = false, collisionAvoidance = DROPDOWN_COLLISION_AVOIDANCE, style: styleProp, ...elementProps } = componentProps;
+    const store = useComboboxRootContext();
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const floatingRootContext = useComboboxFloatingContext();
+    const keepMounted = useComboboxPortalContext();
+    const modal = useStore(store, selectors.modal);
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const openMethod = useStore(store, selectors.openMethod);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const inputElement = useStore(store, selectors.inputElement);
+    const inputGroupElement = useStore(store, selectors.inputGroupElement);
+    const inputInsidePopup = useStore(store, selectors.inputInsidePopup);
+    const transitionStatus = useStore(store, selectors.transitionStatus);
+    const empty = 0 === filteredItems.length;
+    const resolvedAnchor = anchor ?? (inputInsidePopup ? triggerElement : inputGroupElement ?? inputElement);
+    const positioning = useAnchorPositioning({
+        anchor: resolvedAnchor,
+        floatingRootContext,
+        positionMethod,
+        mounted,
+        side,
+        sideOffset,
+        align,
+        alignOffset,
+        arrowPadding,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        disableAnchorTracking,
+        keepMounted,
+        collisionAvoidance,
+        lazyFlip: true
+    });
+    useAnchoredPopupScrollLock(open && modal, 'touch' === openMethod, positionerElement, triggerElement);
+    const state = {
+        open,
+        side: positioning.side,
+        align: positioning.align,
+        anchorHidden: positioning.anchorHidden,
+        empty
+    };
+    useIsoLayoutEffect(()=>{
+        store.set('popupSide', positioning.side);
+    }, [
+        store,
+        positioning.side
+    ]);
+    const setPositionerElement = useStableCallback((element)=>{
+        store.set('positionerElement', element);
+    });
+    const element = usePositioner(componentProps, state, {
+        styles: positioning.positionerStyles,
+        transitionStatus,
+        props: elementProps,
+        refs: [
+            forwardedRef,
+            setPositionerElement
+        ],
+        hidden: !mounted,
+        inert: !open
+    });
+    return /*#__PURE__*/ jsxs(ComboboxPositionerContext.Provider, {
+        value: positioning,
+        children: [
+            mounted && modal && /*#__PURE__*/ jsx(InternalBackdrop_InternalBackdrop, {
+                inert: inertValue(!open),
+                cutout: inputGroupElement ?? inputElement ?? triggerElement
+            }),
+            element
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxPositioner_ComboboxPositioner.displayName = "ComboboxPositioner";
+const ComboboxPopup_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const ComboboxPopup_ComboboxPopup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, initialFocus, finalFocus, ...elementProps } = componentProps;
+    const store = useComboboxRootContext();
+    const positioning = useComboboxPositionerContext();
+    const floatingRootContext = useComboboxFloatingContext();
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const mounted = useStore(store, selectors.mounted);
+    const open = useStore(store, selectors.open);
+    const openMethod = useStore(store, selectors.openMethod);
+    const transitionStatus = useStore(store, selectors.transitionStatus);
+    const inputInsidePopup = useStore(store, selectors.inputInsidePopup);
+    const inputElement = useStore(store, selectors.inputElement);
+    const modal = useStore(store, selectors.modal);
+    const empty = 0 === filteredItems.length;
+    useOpenChangeComplete({
+        open,
+        ref: store.state.popupRef,
+        onComplete () {
+            if (open) store.state.onOpenChangeComplete(true);
+        }
+    });
+    const state = {
+        open,
+        side: positioning.side,
+        align: positioning.align,
+        anchorHidden: positioning.anchorHidden,
+        transitionStatus,
+        empty
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            store.state.popupRef
+        ],
+        props: [
+            {
+                role: inputInsidePopup ? 'dialog' : 'presentation',
+                tabIndex: -1,
+                onFocus (event) {
+                    const target = getTarget(event.nativeEvent);
+                    if ('touch' !== openMethod && (shadowDom_contains(store.state.listElement, target) || target === event.currentTarget)) store.state.inputRef.current?.focus();
+                }
+            },
+            getDisabledMountTransitionStyles(transitionStatus),
+            elementProps
+        ],
+        stateAttributesMapping: ComboboxPopup_stateAttributesMapping
+    });
+    const computedDefaultInitialFocus = inputInsidePopup ? (interactionType)=>'touch' === interactionType ? store.state.popupRef.current : inputElement : false;
+    const resolvedInitialFocus = void 0 === initialFocus ? computedDefaultInitialFocus : initialFocus;
+    let resolvedFinalFocus;
+    resolvedFinalFocus = null != finalFocus ? finalFocus : inputInsidePopup ? void 0 : false;
+    const focusManagerModal = !inputInsidePopup || modal;
+    return /*#__PURE__*/ jsx(FloatingFocusManager, {
+        context: floatingRootContext,
+        disabled: !mounted,
+        modal: focusManagerModal,
+        openInteractionType: openMethod,
+        initialFocus: resolvedInitialFocus,
+        returnFocus: resolvedFinalFocus,
+        getInsideElements: ()=>[
+                store.state.startDismissRef.current,
+                store.state.endDismissRef.current
+            ],
+        children: /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+            children: [
+                element,
+                focusManagerModal && /*#__PURE__*/ jsx(ComboboxInternalDismissButton_ComboboxInternalDismissButton, {
+                    ref: store.state.endDismissRef
+                })
+            ]
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxPopup_ComboboxPopup.displayName = "ComboboxPopup";
+const ComboboxArrow_ComboboxArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const store = useComboboxRootContext();
+    const { arrowRef, side, align, arrowUncentered, arrowStyles } = useComboboxPositionerContext();
+    const open = useStore(store, selectors.open);
+    const state = {
+        open,
+        side,
+        align,
+        uncentered: arrowUncentered
+    };
+    return useRenderElement('div', componentProps, {
+        ref: [
+            arrowRef,
+            forwardedRef
+        ],
+        stateAttributesMapping: popupStateMapping,
+        state,
+        props: {
+            style: arrowStyles,
+            'aria-hidden': true,
+            ...elementProps
+        }
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxArrow_ComboboxArrow.displayName = "ComboboxArrow";
+const ComboboxGroupContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ComboboxGroupContext.displayName = "ComboboxGroupContext";
+function useComboboxGroupContext() {
+    const context = __rspack_external_react.useContext(ComboboxGroupContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ComboboxGroupContext is missing. ComboboxGroup parts must be placed within <Combobox.Group>.' : esm_formatErrorMessage(18));
+    return context;
+}
+const ComboboxGroup_ComboboxGroup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, items, ...elementProps } = componentProps;
+    const [labelId, setLabelId] = __rspack_external_react.useState();
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            labelId,
+            setLabelId,
+            items
+        }), [
+        labelId,
+        setLabelId,
+        items
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                role: 'group',
+                'aria-labelledby': labelId
+            },
+            elementProps
+        ]
+    });
+    const wrappedElement = /*#__PURE__*/ jsx(ComboboxGroupContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+    if (items) return /*#__PURE__*/ jsx(GroupCollectionProvider, {
+        items: items,
+        children: wrappedElement
+    });
+    return wrappedElement;
+});
+if ("production" !== process.env.NODE_ENV) ComboboxGroup_ComboboxGroup.displayName = "ComboboxGroup";
+const ComboboxGroupLabel_ComboboxGroupLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { setLabelId } = useComboboxGroupContext();
+    const id = useBaseUiId(idProp);
+    useIsoLayoutEffect(()=>{
+        setLabelId(id);
+        return ()=>{
+            setLabelId(void 0);
+        };
+    }, [
+        id,
+        setLabelId
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                id
+            },
+            elementProps
+        ]
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ComboboxGroupLabel_ComboboxGroupLabel.displayName = "ComboboxGroupLabel";
+const ComboboxRow_ComboboxRow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const element = useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                role: 'row'
+            },
+            elementProps
+        ]
+    });
+    return /*#__PURE__*/ jsx(ComboboxRowContext.Provider, {
+        value: true,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxRow_ComboboxRow.displayName = "ComboboxRow";
+const ComboboxEmpty_ComboboxEmpty = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, children: childrenProp, ...elementProps } = componentProps;
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const store = useComboboxRootContext();
+    const emptyRef = useInitialLiveRegionTextMutation();
+    const children = 0 === filteredItems.length ? childrenProp : null;
+    return useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            store.state.emptyRef,
+            emptyRef
+        ],
+        props: [
+            {
+                children,
+                role: 'status',
+                'aria-live': 'polite',
+                'aria-atomic': true
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxEmpty_ComboboxEmpty.displayName = "ComboboxEmpty";
+const BOUNDARY_OFFSET = 2;
+const ComboboxTrigger_ComboboxTrigger = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, nativeButton = true, disabled: disabledProp = false, id: idProp, style, ...elementProps } = componentProps;
+    const { state: fieldState, disabled: fieldDisabled, setTouched, setFocused, validationMode, validation } = useFieldRootContext();
+    const { labelId: fieldLabelId } = useLabelableContext();
+    const store = useComboboxRootContext();
+    const { filteredItems } = useComboboxDerivedItemsContext();
+    const selectionMode = useStore(store, selectors.selectionMode);
+    const comboboxDisabled = useStore(store, selectors.disabled);
+    const readOnly = useStore(store, selectors.readOnly);
+    const required = useStore(store, selectors.required);
+    const mounted = useStore(store, selectors.mounted);
+    const popupSideValue = useStore(store, selectors.popupSide);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const listElement = useStore(store, selectors.listElement);
+    const triggerProps = useStore(store, selectors.triggerProps);
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const inputInsidePopup = useStore(store, selectors.inputInsidePopup);
+    const rootId = useStore(store, selectors.id);
+    const comboboxLabelId = useStore(store, selectors.labelId);
+    const open = useStore(store, selectors.open);
+    const selectedValue = useStore(store, selectors.selectedValue);
+    const activeIndex = useStore(store, selectors.activeIndex);
+    const selectedIndex = useStore(store, selectors.selectedIndex);
+    const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+    const floatingRootContext = useComboboxFloatingContext();
+    const inputValue = useComboboxInputValueContext();
+    const focusTimeout = useTimeout();
+    const disabled = fieldDisabled || comboboxDisabled || disabledProp;
+    const listEmpty = 0 === filteredItems.length;
+    const popupSide = mounted && positionerElement ? popupSideValue : null;
+    useLabelableId({
+        id: inputInsidePopup ? idProp : void 0
+    });
+    const id = inputInsidePopup ? idProp ?? rootId : idProp;
+    const ariaLabelledBy = resolveAriaLabelledBy(fieldLabelId, comboboxLabelId);
+    const currentPointerTypeRef = __rspack_external_react.useRef('');
+    function trackPointerType(event) {
+        currentPointerTypeRef.current = event.pointerType;
+    }
+    const domReference = floatingRootContext.useState('domReferenceElement');
+    __rspack_external_react.useEffect(()=>{
+        if (!inputInsidePopup) return;
+        if (triggerElement && triggerElement !== domReference) floatingRootContext.set('domReferenceElement', triggerElement);
+    }, [
+        triggerElement,
+        domReference,
+        floatingRootContext,
+        inputInsidePopup
+    ]);
+    const { reference: triggerTypeaheadProps } = useTypeahead(floatingRootContext, {
+        enabled: !open && !readOnly && !comboboxDisabled && 'single' === selectionMode,
+        listRef: store.state.labelsRef,
+        activeIndex,
+        selectedIndex,
+        onMatch (index) {
+            const nextSelectedValue = store.state.valuesRef.current[index];
+            if (void 0 !== nextSelectedValue) store.state.setSelectedValue(nextSelectedValue, createChangeEventDetails('none'));
+        }
+    });
+    const { reference: triggerClickProps } = useClick(floatingRootContext, {
+        enabled: !readOnly && !comboboxDisabled,
+        event: 'mousedown'
+    });
+    const { buttonRef, getButtonProps } = useButton({
+        native: nativeButton,
+        disabled
+    });
+    const state = {
+        ...fieldState,
+        open,
+        disabled,
+        popupSide,
+        listEmpty,
+        placeholder: 'none' === selectionMode ? false : !hasSelectedValue
+    };
+    const setTriggerElement = useStableCallback((element)=>{
+        store.set('triggerElement', element);
+    });
+    const element = useRenderElement('button', componentProps, {
+        ref: [
+            forwardedRef,
+            buttonRef,
+            setTriggerElement
+        ],
+        state,
+        props: [
+            triggerProps,
+            triggerClickProps,
+            triggerTypeaheadProps,
+            {
+                id,
+                tabIndex: inputInsidePopup ? 0 : -1,
+                role: inputInsidePopup ? 'combobox' : void 0,
+                'aria-expanded': open ? 'true' : 'false',
+                'aria-haspopup': inputInsidePopup ? 'dialog' : 'listbox',
+                'aria-controls': open ? listElement?.id : void 0,
+                'aria-required': inputInsidePopup ? required || void 0 : void 0,
+                'aria-labelledby': ariaLabelledBy,
+                onPointerDown: trackPointerType,
+                onPointerEnter: trackPointerType,
+                onFocus () {
+                    setFocused(true);
+                    if (disabled || readOnly) return;
+                    focusTimeout.start(0, store.state.forceMount);
+                },
+                onBlur (event) {
+                    if (shadowDom_contains(positionerElement, event.relatedTarget)) return;
+                    setTouched(true);
+                    setFocused(false);
+                    if ('onBlur' === validationMode) {
+                        const valueToValidate = 'none' === selectionMode ? inputValue : selectedValue;
+                        validation.commit(valueToValidate);
+                    }
+                },
+                onMouseDown (event) {
+                    if (disabled || readOnly) return;
+                    if (!inputInsidePopup) floatingRootContext.set('domReferenceElement', event.currentTarget);
+                    store.state.forceMount();
+                    if ('touch' !== currentPointerTypeRef.current) {
+                        store.state.inputRef.current?.focus();
+                        if (!inputInsidePopup) event.preventDefault();
+                    }
+                    if (open) return;
+                    const doc = ownerDocument(event.currentTarget);
+                    function handleMouseUp(mouseEvent) {
+                        if (!triggerElement) return;
+                        const mouseUpTarget = getTarget(mouseEvent);
+                        const positioner = store.state.positionerElement;
+                        const list = store.state.listElement;
+                        if (shadowDom_contains(triggerElement, mouseUpTarget) || shadowDom_contains(positioner, mouseUpTarget) || shadowDom_contains(list, mouseUpTarget) || mouseUpTarget === triggerElement) return;
+                        const bounds = getPseudoElementBounds(triggerElement);
+                        const withinHorizontal = mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET;
+                        const withinVertical = mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET;
+                        if (withinHorizontal && withinVertical) return;
+                        store.state.setOpen(false, createChangeEventDetails('cancel-open', mouseEvent));
+                    }
+                    if (inputInsidePopup) doc.addEventListener('mouseup', handleMouseUp, {
+                        once: true
+                    });
+                },
+                onKeyDown (event) {
+                    if (disabled || readOnly) return;
+                    if ('ArrowDown' === event.key || 'ArrowUp' === event.key) {
+                        stopEvent(event);
+                        store.state.setOpen(true, createChangeEventDetails(reason_parts_listNavigation, event.nativeEvent));
+                        store.state.inputRef.current?.focus();
+                    }
+                }
+            },
+            validation ? validation.getValidationProps(elementProps) : elementProps,
+            getButtonProps
+        ],
+        stateAttributesMapping: triggerStateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ComboboxTrigger_ComboboxTrigger.displayName = "ComboboxTrigger";
+function utils_createCollatorItemFilter(collatorFilter, itemToStringLabel) {
+    return (item, query)=>{
+        if (null == item) return false;
+        const itemString = stringifyAsLabel(item, itemToStringLabel);
+        return collatorFilter.contains(itemString, query);
+    };
+}
+function utils_createSingleSelectionCollatorFilter(collatorFilter, itemToStringLabel, selectedValue) {
+    return (item, query)=>{
+        if (null == item) return false;
+        if (!query) return true;
+        const itemString = stringifyAsLabel(item, itemToStringLabel);
+        const selectedString = null != selectedValue ? stringifyAsLabel(selectedValue, itemToStringLabel) : '';
+        if (selectedString && collatorFilter.contains(selectedString, query) && selectedString.length === query.length) return true;
+        return collatorFilter.contains(itemString, query);
+    };
+}
+const filterCache = new Map();
+function filter_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 i = 0; i <= itemString.length - query.length; i += 1)if (0 === collator.compare(itemString.slice(i, i + query.length), query)) return true;
+            return false;
+        },
+        startsWith (item, query, itemToString) {
+            if (!query) return true;
+            const itemString = stringifyAsLabel(item, itemToString);
+            return 0 === collator.compare(itemString.slice(0, query.length), query);
+        },
+        endsWith (item, query, itemToString) {
+            if (!query) return true;
+            const itemString = stringifyAsLabel(item, itemToString);
+            const queryLength = query.length;
+            return itemString.length >= queryLength && 0 === collator.compare(itemString.slice(itemString.length - queryLength), query);
+        }
+    };
+    filterCache.set(cacheKey, filter);
+    return filter;
+}
+function stringifyLocale(locale) {
+    if (Array.isArray(locale)) return locale.map((value)=>stringifyLocale(value)).join(',');
+    if (null == locale) return '';
+    return String(locale);
+}
+const useCoreFilter = filter_getFilter;
+const NO_ACTIVE_VALUE = Symbol('none');
+const INITIAL_LAST_HIGHLIGHT = {
+    value: NO_ACTIVE_VALUE,
+    index: -1
+};
+function AriaCombobox(props) {
+    const { id: idProp, onOpenChangeComplete: onOpenChangeCompleteProp, defaultSelectedValue = null, selectedValue: selectedValueProp, onSelectedValueChange, defaultInputValue: defaultInputValueProp, inputValue: inputValueProp, open: openProp, defaultOpen = false, selectionMode = 'none', onItemHighlighted: onItemHighlightedProp, name: nameProp, form, disabled: disabledProp = false, readOnly = false, required = false, inputRef: inputRefProp, grid = false, items, filteredItems: filteredItemsProp, filter: filterProp, openOnInputClick = true, autoHighlight = false, keepHighlight = false, highlightItemOnHover = true, loopFocus = true, itemToStringLabel, itemToStringValue, isItemEqualToValue = defaultItemEquality, virtualized = false, inline: inlineProp = false, fillInputOnItemPress = true, modal = false, limit = -1, autoComplete = 'list', formAutoComplete, locale, submitOnItemClick = false } = props;
+    const { clearErrors } = useFormContext();
+    const { setDirty, validityData, shouldValidateOnChange, setFilled, name: fieldName, disabled: fieldDisabled, setTouched, setFocused, validationMode, validation } = useFieldRootContext();
+    const direction = useDirection();
+    const id = useLabelableId({
+        id: idProp
+    });
+    const collatorFilter = useCoreFilter({
+        locale
+    });
+    const [queryChangedAfterOpen, setQueryChangedAfterOpen] = __rspack_external_react.useState(false);
+    const [closeQuery, setCloseQuery] = __rspack_external_react.useState(null);
+    const listRef = __rspack_external_react.useRef([]);
+    const labelsRef = __rspack_external_react.useRef([]);
+    const popupRef = __rspack_external_react.useRef(null);
+    const inputRef = __rspack_external_react.useRef(null);
+    const startDismissRef = __rspack_external_react.useRef(null);
+    const endDismissRef = __rspack_external_react.useRef(null);
+    const emptyRef = __rspack_external_react.useRef(null);
+    const keyboardActiveRef = __rspack_external_react.useRef(true);
+    const hadInputClearRef = __rspack_external_react.useRef(false);
+    const chipsContainerRef = __rspack_external_react.useRef(null);
+    const clearRef = __rspack_external_react.useRef(null);
+    const selectionEventRef = __rspack_external_react.useRef(null);
+    const lastHighlightRef = __rspack_external_react.useRef(INITIAL_LAST_HIGHLIGHT);
+    const pendingQueryHighlightRef = __rspack_external_react.useRef(null);
+    const valuesRef = __rspack_external_react.useRef([]);
+    const allValuesRef = __rspack_external_react.useRef([]);
+    const disabled = fieldDisabled || disabledProp;
+    const name = fieldName ?? nameProp;
+    const multiple = 'multiple' === selectionMode;
+    const single = 'single' === selectionMode;
+    const hasInputValue = void 0 !== inputValueProp || void 0 !== defaultInputValueProp;
+    const hasItems = void 0 !== items;
+    const hasFilteredItemsProp = void 0 !== filteredItemsProp;
+    let autoHighlightMode;
+    autoHighlightMode = 'always' === autoHighlight ? 'always' : autoHighlight ? 'input-change' : false;
+    const [selectedValue, setSelectedValueUnwrapped] = useControlled({
+        controlled: selectedValueProp,
+        default: multiple ? defaultSelectedValue ?? EMPTY_ARRAY : defaultSelectedValue,
+        name: 'Combobox',
+        state: 'selectedValue'
+    });
+    const filter = __rspack_external_react.useMemo(()=>{
+        if (null === filterProp) return ()=>true;
+        if (void 0 !== filterProp) return filterProp;
+        if (single && !queryChangedAfterOpen) return utils_createSingleSelectionCollatorFilter(collatorFilter, itemToStringLabel, selectedValue);
+        return utils_createCollatorItemFilter(collatorFilter, itemToStringLabel);
+    }, [
+        filterProp,
+        single,
+        selectedValue,
+        queryChangedAfterOpen,
+        collatorFilter,
+        itemToStringLabel
+    ]);
+    const initialDefaultInputValue = useRefWithInit(()=>{
+        if (hasInputValue) return defaultInputValueProp ?? '';
+        if (single) return stringifyAsLabel(selectedValue, itemToStringLabel);
+        return '';
+    }).current;
+    const [inputValue, setInputValueUnwrapped] = useControlled({
+        controlled: inputValueProp,
+        default: initialDefaultInputValue,
+        name: 'Combobox',
+        state: 'inputValue'
+    });
+    const [open, setOpenUnwrapped] = useControlled({
+        controlled: openProp,
+        default: defaultOpen,
+        name: 'Combobox',
+        state: 'open'
+    });
+    const isGrouped = isGroupedItems(items);
+    const query = closeQuery ?? ('' === inputValue ? '' : String(inputValue).trim());
+    const selectedLabelString = single ? stringifyAsLabel(selectedValue, itemToStringLabel) : '';
+    const shouldBypassFiltering = single && !queryChangedAfterOpen && '' !== query && '' !== selectedLabelString && selectedLabelString.length === query.length && collatorFilter.contains(selectedLabelString, query);
+    const filterQuery = shouldBypassFiltering ? '' : query;
+    const shouldIgnoreExternalFiltering = hasItems && hasFilteredItemsProp && shouldBypassFiltering;
+    const flatItems = __rspack_external_react.useMemo(()=>{
+        if (!items) return EMPTY_ARRAY;
+        if (isGrouped) return items.flatMap((group)=>group.items);
+        return items;
+    }, [
+        items,
+        isGrouped
+    ]);
+    const filteredItems = __rspack_external_react.useMemo(()=>{
+        if (filteredItemsProp && !shouldIgnoreExternalFiltering) return filteredItemsProp;
+        if (!items) return EMPTY_ARRAY;
+        if (isGrouped) {
+            const groupedItems = items;
+            const resultingGroups = [];
+            let currentCount = 0;
+            for (const group of groupedItems){
+                if (limit > -1 && currentCount >= limit) break;
+                const candidateItems = '' === filterQuery ? group.items : group.items.filter((item)=>filter(item, filterQuery, itemToStringLabel));
+                if (0 === candidateItems.length) continue;
+                const remainingLimit = limit > -1 ? limit - currentCount : 1 / 0;
+                const itemsToTake = candidateItems.slice(0, remainingLimit);
+                if (itemsToTake.length > 0) {
+                    const newGroup = {
+                        ...group,
+                        items: itemsToTake
+                    };
+                    resultingGroups.push(newGroup);
+                    currentCount += itemsToTake.length;
+                }
+            }
+            return resultingGroups;
+        }
+        if ('' === filterQuery) return limit > -1 ? flatItems.slice(0, limit) : flatItems;
+        const limitedItems = [];
+        for (const item of flatItems){
+            if (limit > -1 && limitedItems.length >= limit) break;
+            if (filter(item, filterQuery, itemToStringLabel)) limitedItems.push(item);
+        }
+        return limitedItems;
+    }, [
+        filteredItemsProp,
+        shouldIgnoreExternalFiltering,
+        items,
+        isGrouped,
+        filterQuery,
+        limit,
+        filter,
+        itemToStringLabel,
+        flatItems
+    ]);
+    const flatFilteredItems = __rspack_external_react.useMemo(()=>{
+        if (isGrouped) {
+            const groups = filteredItems;
+            return groups.flatMap((g)=>g.items);
+        }
+        return filteredItems;
+    }, [
+        filteredItems,
+        isGrouped
+    ]);
+    const store = useRefWithInit(()=>new Store({
+            id,
+            labelId: void 0,
+            selectedValue,
+            open,
+            filter,
+            query,
+            items,
+            selectionMode,
+            listRef,
+            labelsRef,
+            popupRef,
+            emptyRef,
+            inputRef,
+            startDismissRef,
+            endDismissRef,
+            keyboardActiveRef,
+            chipsContainerRef,
+            clearRef,
+            valuesRef,
+            allValuesRef,
+            selectionEventRef,
+            name,
+            form,
+            disabled,
+            readOnly,
+            required,
+            grid,
+            isGrouped,
+            virtualized,
+            openOnInputClick,
+            itemToStringLabel,
+            isItemEqualToValue,
+            modal,
+            autoHighlight: autoHighlightMode,
+            submitOnItemClick,
+            hasInputValue,
+            mounted: false,
+            forceMounted: false,
+            transitionStatus: 'idle',
+            inline: inlineProp,
+            activeIndex: null,
+            selectedIndex: null,
+            popupProps: {},
+            inputProps: {},
+            triggerProps: {},
+            itemProps: EMPTY_OBJECT,
+            positionerElement: null,
+            listElement: null,
+            triggerElement: null,
+            inputElement: null,
+            inputGroupElement: null,
+            popupSide: null,
+            openMethod: null,
+            inputInsidePopup: true,
+            inputOwnsFormValue: 'none' === selectionMode,
+            onOpenChangeComplete: onOpenChangeCompleteProp || NOOP,
+            setOpen: NOOP,
+            setInputValue: NOOP,
+            setSelectedValue: NOOP,
+            setIndices: NOOP,
+            onItemHighlighted: NOOP,
+            handleSelection: NOOP,
+            forceMount: NOOP,
+            requestSubmit: NOOP
+        })).current;
+    const fieldRawValue = 'none' === selectionMode ? inputValue : selectedValue;
+    const fieldStringValue = __rspack_external_react.useMemo(()=>{
+        if ('none' === selectionMode) return fieldRawValue;
+        if (Array.isArray(selectedValue)) return selectedValue.map((value)=>stringifyAsValue(value, itemToStringValue));
+        return stringifyAsValue(selectedValue, itemToStringValue);
+    }, [
+        fieldRawValue,
+        itemToStringValue,
+        selectionMode,
+        selectedValue
+    ]);
+    const onItemHighlighted = useStableCallback(onItemHighlightedProp);
+    const onOpenChangeComplete = useStableCallback(onOpenChangeCompleteProp);
+    const activeIndex = useStore(store, selectors.activeIndex);
+    const selectedIndex = useStore(store, selectors.selectedIndex);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const listElement = useStore(store, selectors.listElement);
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const inputElement = useStore(store, selectors.inputElement);
+    const inputGroupElement = useStore(store, selectors.inputGroupElement);
+    const inline = useStore(store, selectors.inline);
+    const inputInsidePopup = useStore(store, selectors.inputInsidePopup);
+    const inputOwnsFormValue = useStore(store, selectors.inputOwnsFormValue);
+    const triggerRef = useValueAsRef(triggerElement);
+    const { mounted, setMounted, transitionStatus } = useTransitionStatus(open);
+    const { openMethod, triggerProps } = useOpenInteractionType(open);
+    const getStringifiedValueForForm = useStableCallback(()=>fieldStringValue);
+    useRegisterFieldControl(inputInsidePopup ? triggerRef : inputRef, id, fieldRawValue, getStringifiedValueForForm);
+    const forceMount = useStableCallback(()=>{
+        if (items) labelsRef.current = flatFilteredItems.map((item)=>stringifyAsLabel(item, itemToStringLabel));
+        else store.set('forceMounted', true);
+    });
+    const initialSelectedValueRef = __rspack_external_react.useRef(selectedValue);
+    useIsoLayoutEffect(()=>{
+        if (selectedValue !== initialSelectedValueRef.current) forceMount();
+    }, [
+        forceMount,
+        selectedValue
+    ]);
+    const setIndices = useStableCallback((options)=>{
+        store.update(options);
+        const type = options.type || 'none';
+        if (void 0 === options.activeIndex) return;
+        if (null === options.activeIndex) {
+            if (lastHighlightRef.current !== INITIAL_LAST_HIGHLIGHT) {
+                lastHighlightRef.current = INITIAL_LAST_HIGHLIGHT;
+                onItemHighlighted(void 0, createGenericEventDetails(type, void 0, {
+                    index: -1
+                }));
+            }
+        } else {
+            const activeValue = valuesRef.current[options.activeIndex];
+            lastHighlightRef.current = {
+                value: activeValue,
+                index: options.activeIndex
+            };
+            onItemHighlighted(activeValue, createGenericEventDetails(type, void 0, {
+                index: options.activeIndex
+            }));
+        }
+    });
+    const setInputValue = useStableCallback((next, eventDetails)=>{
+        hadInputClearRef.current = eventDetails.reason === inputClear;
+        props.onInputValueChange?.(next, eventDetails);
+        if (eventDetails.isCanceled) return;
+        if (eventDetails.reason === inputChange) {
+            const event = eventDetails.event;
+            const inputType = event.inputType;
+            const isTypedInput = 'compositionend' === event.type || null != inputType && '' !== inputType && 'insertReplacementText' !== inputType;
+            if (isTypedInput) {
+                const hasQuery = '' !== next.trim();
+                if (hasQuery) setQueryChangedAfterOpen(true);
+                pendingQueryHighlightRef.current = {
+                    hasQuery
+                };
+                if (hasQuery && autoHighlightMode && null == store.state.activeIndex) store.set('activeIndex', 0);
+            }
+        }
+        setInputValueUnwrapped(next);
+    });
+    const setOpen = useStableCallback((nextOpen, eventDetails)=>{
+        if (open === nextOpen) return;
+        if ('escape-key' === eventDetails.reason && hasItems && 0 === flatFilteredItems.length && !store.state.emptyRef.current) eventDetails.allowPropagation();
+        props.onOpenChange?.(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        if (nextOpen && multiple && inputInsidePopup && !inline && null !== closeQuery) {
+            setQueryChangedAfterOpen(false);
+            setCloseQuery(null);
+            if ('' !== inputValue) setInputValue('', createChangeEventDetails(inputClear, eventDetails.event));
+        }
+        if (!nextOpen && queryChangedAfterOpen) {
+            if (single) {
+                if (!inline) setCloseQuery(query);
+                if ('' === query) setQueryChangedAfterOpen(false);
+            } else if (multiple) {
+                if (!inline) setCloseQuery(query);
+                if (inputInsidePopup) setIndices({
+                    activeIndex: null
+                });
+                if (!inputInsidePopup || inline) setInputValue('', createChangeEventDetails(inputClear, eventDetails.event));
+            }
+        }
+        setOpenUnwrapped(nextOpen);
+        if (!nextOpen && inputInsidePopup && (eventDetails.reason === focusOut || eventDetails.reason === outsidePress)) {
+            setTouched(true);
+            setFocused(false);
+            if ('onBlur' === validationMode) {
+                const valueToValidate = 'none' === selectionMode ? inputValue : selectedValue;
+                validation.commit(valueToValidate);
+            }
+        }
+    });
+    const setSelectedValue = useStableCallback((nextValue, eventDetails)=>{
+        onSelectedValueChange?.(nextValue, eventDetails);
+        if (eventDetails.isCanceled) return;
+        setSelectedValueUnwrapped(nextValue);
+        const shouldFillInput = 'none' === selectionMode && popupRef.current && fillInputOnItemPress || single && !store.state.inputInsidePopup;
+        if (shouldFillInput) setInputValue(stringifyAsLabel(nextValue, itemToStringLabel), createChangeEventDetails(eventDetails.reason, eventDetails.event));
+        if (single && null != nextValue && eventDetails.reason !== inputChange && queryChangedAfterOpen && !inline) setCloseQuery(query);
+    });
+    const handleSelection = useStableCallback((event, passedValue)=>{
+        let itemValue = passedValue;
+        if (void 0 === itemValue) {
+            if (null === activeIndex) return;
+            itemValue = valuesRef.current[activeIndex];
+        }
+        const targetEl = getTarget(event);
+        const overrideEvent = selectionEventRef.current ?? event;
+        selectionEventRef.current = null;
+        const eventDetails = createChangeEventDetails(itemPress, overrideEvent);
+        const href = targetEl?.closest('a')?.getAttribute('href');
+        if (href) {
+            if (href.startsWith('#')) setOpen(false, eventDetails);
+            return;
+        }
+        if (multiple) {
+            const currentSelectedValue = Array.isArray(selectedValue) ? selectedValue : [];
+            const isCurrentlySelected = selectedValueIncludes(currentSelectedValue, itemValue, store.state.isItemEqualToValue);
+            const nextValue = isCurrentlySelected ? removeItem(currentSelectedValue, itemValue, store.state.isItemEqualToValue) : [
+                ...currentSelectedValue,
+                itemValue
+            ];
+            setSelectedValue(nextValue, eventDetails);
+            const wasFiltering = inputRef.current ? '' !== inputRef.current.value.trim() : false;
+            if (!wasFiltering) return;
+            if (store.state.inputInsidePopup) setInputValue('', createChangeEventDetails(inputClear, eventDetails.event));
+            else setOpen(false, eventDetails);
+        } else {
+            setSelectedValue(itemValue, eventDetails);
+            setOpen(false, eventDetails);
+        }
+    });
+    const requestSubmit = useStableCallback(()=>{
+        if (!store.state.submitOnItemClick) return;
+        const formElement = validation.inputRef.current?.form ?? store.state.inputElement?.form;
+        if (formElement && 'function' == typeof formElement.requestSubmit) formElement.requestSubmit();
+    });
+    const handleUnmount = useStableCallback(()=>{
+        setMounted(false);
+        onOpenChangeComplete?.(false);
+        setQueryChangedAfterOpen(false);
+        setCloseQuery(null);
+        'none' === selectionMode ? setIndices({
+            activeIndex: null,
+            selectedIndex: null
+        }) : setIndices({
+            activeIndex: null
+        });
+        if (multiple && inputRef.current && '' !== inputRef.current.value && !hadInputClearRef.current) setInputValue('', createChangeEventDetails(inputClear));
+        if (single) if (store.state.inputInsidePopup) {
+            if (inputRef.current && '' !== inputRef.current.value) setInputValue('', createChangeEventDetails(inputClear));
+        } else {
+            const stringVal = stringifyAsLabel(selectedValue, itemToStringLabel);
+            if (inputRef.current && inputRef.current.value !== stringVal) {
+                const reason = '' === stringVal ? inputClear : "none";
+                setInputValue(stringVal, createChangeEventDetails(reason));
+            }
+        }
+    });
+    const resolvedPopupRef = __rspack_external_react.useMemo(()=>{
+        if (inline && positionerElement) return {
+            current: positionerElement.closest('[role="dialog"]')
+        };
+        return popupRef;
+    }, [
+        inline,
+        positionerElement
+    ]);
+    useOpenChangeComplete({
+        enabled: !props.actionsRef,
+        open,
+        ref: resolvedPopupRef,
+        onComplete () {
+            if (!open) handleUnmount();
+        }
+    });
+    __rspack_external_react.useImperativeHandle(props.actionsRef, ()=>({
+            unmount: handleUnmount
+        }), [
+        handleUnmount
+    ]);
+    useIsoLayoutEffect(function() {
+        if (open || 'none' === selectionMode) return;
+        const registry = items ? flatItems : allValuesRef.current;
+        if (multiple) {
+            const currentValue = Array.isArray(selectedValue) ? selectedValue : [];
+            const lastValue = currentValue[currentValue.length - 1];
+            const lastIndex = findItemIndex(registry, lastValue, isItemEqualToValue);
+            setIndices({
+                selectedIndex: -1 === lastIndex ? null : lastIndex
+            });
+        } else {
+            const index = findItemIndex(registry, selectedValue, isItemEqualToValue);
+            setIndices({
+                selectedIndex: -1 === index ? null : index
+            });
+        }
+    }, [
+        open,
+        selectedValue,
+        items,
+        selectionMode,
+        flatItems,
+        multiple,
+        isItemEqualToValue,
+        setIndices
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (items) {
+            valuesRef.current = flatFilteredItems;
+            listRef.current.length = flatFilteredItems.length;
+        }
+    }, [
+        items,
+        flatFilteredItems
+    ]);
+    useIsoLayoutEffect(()=>{
+        const pendingHighlight = pendingQueryHighlightRef.current;
+        if (pendingHighlight) {
+            if (pendingHighlight.hasQuery) {
+                if (autoHighlightMode) store.set('activeIndex', 0);
+            } else if ('always' === autoHighlightMode) store.set('activeIndex', 0);
+            pendingQueryHighlightRef.current = null;
+        }
+        if (!open && !inline) return;
+        const shouldUseFlatFilteredItems = hasItems || hasFilteredItemsProp;
+        const candidateItems = shouldUseFlatFilteredItems ? flatFilteredItems : valuesRef.current;
+        const storeActiveIndex = store.state.activeIndex;
+        if (null == storeActiveIndex) {
+            if ('always' === autoHighlightMode && candidateItems.length > 0) return void store.set('activeIndex', 0);
+            if (lastHighlightRef.current !== INITIAL_LAST_HIGHLIGHT) {
+                lastHighlightRef.current = INITIAL_LAST_HIGHLIGHT;
+                store.state.onItemHighlighted(void 0, createGenericEventDetails("none", void 0, {
+                    index: -1
+                }));
+            }
+            return;
+        }
+        if (storeActiveIndex >= candidateItems.length) {
+            if (lastHighlightRef.current !== INITIAL_LAST_HIGHLIGHT) {
+                lastHighlightRef.current = INITIAL_LAST_HIGHLIGHT;
+                store.state.onItemHighlighted(void 0, createGenericEventDetails("none", void 0, {
+                    index: -1
+                }));
+            }
+            store.set('activeIndex', null);
+            return;
+        }
+        const itemValue = candidateItems[storeActiveIndex];
+        const previouslyHighlightedItemValue = lastHighlightRef.current.value;
+        const isSameItem = previouslyHighlightedItemValue !== NO_ACTIVE_VALUE && compareItemEquality(itemValue, previouslyHighlightedItemValue, store.state.isItemEqualToValue);
+        if (lastHighlightRef.current.index !== storeActiveIndex || !isSameItem) {
+            lastHighlightRef.current = {
+                value: itemValue,
+                index: storeActiveIndex
+            };
+            store.state.onItemHighlighted(itemValue, createGenericEventDetails("none", void 0, {
+                index: storeActiveIndex
+            }));
+        }
+    }, [
+        activeIndex,
+        autoHighlightMode,
+        hasFilteredItemsProp,
+        hasItems,
+        flatFilteredItems,
+        inline,
+        open,
+        store
+    ]);
+    useIsoLayoutEffect(()=>{
+        if ('none' === selectionMode) return void setFilled('' !== String(inputValue));
+        setFilled(multiple ? Array.isArray(selectedValue) && selectedValue.length > 0 : null != selectedValue);
+    }, [
+        setFilled,
+        selectionMode,
+        inputValue,
+        selectedValue,
+        multiple
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (hasItems && autoHighlightMode && 0 === flatFilteredItems.length) setIndices({
+            activeIndex: null
+        });
+    }, [
+        hasItems,
+        autoHighlightMode,
+        flatFilteredItems.length,
+        setIndices
+    ]);
+    useValueChanged(query, ()=>{
+        if (!open || '' === query || query === String(initialDefaultInputValue)) return;
+        setQueryChangedAfterOpen(true);
+    });
+    useValueChanged(selectedValue, ()=>{
+        if ('none' === selectionMode) return;
+        clearErrors(name);
+        setDirty(selectedValue !== validityData.initialValue);
+        if (shouldValidateOnChange()) validation.commit(selectedValue);
+        else validation.commit(selectedValue, true);
+        if (single && !hasInputValue && !inputInsidePopup) {
+            const nextInputValue = stringifyAsLabel(selectedValue, itemToStringLabel);
+            if (inputValue !== nextInputValue) setInputValue(nextInputValue, createChangeEventDetails("none"));
+        }
+    });
+    useValueChanged(inputValue, ()=>{
+        if ('none' !== selectionMode) return;
+        clearErrors(name);
+        setDirty(inputValue !== validityData.initialValue);
+        if (shouldValidateOnChange()) validation.commit(inputValue);
+        else validation.commit(inputValue, true);
+    });
+    useValueChanged(items, ()=>{
+        if (!single || hasInputValue || inputInsidePopup || queryChangedAfterOpen) return;
+        const nextInputValue = stringifyAsLabel(selectedValue, itemToStringLabel);
+        if (inputValue !== nextInputValue) setInputValue(nextInputValue, createChangeEventDetails("none"));
+    });
+    const floatingRootContext = useFloatingRootContext({
+        open: inline ? true : open,
+        onOpenChange: setOpen,
+        elements: {
+            reference: inputInsidePopup ? triggerElement : inputElement,
+            floating: positionerElement
+        }
+    });
+    let ariaHasPopup;
+    let ariaExpanded;
+    if (!inline) {
+        ariaHasPopup = grid ? 'grid' : 'listbox';
+        ariaExpanded = open ? 'true' : 'false';
+    }
+    const role = __rspack_external_react.useMemo(()=>{
+        const isPlainInput = inputElement?.tagName === 'INPUT';
+        const shouldTreatAsInput = null == inputElement || isPlainInput;
+        const shouldApplyAria = shouldTreatAsInput || open;
+        const reference = shouldTreatAsInput ? {
+            autoComplete: 'off',
+            spellCheck: 'false',
+            autoCorrect: 'off',
+            autoCapitalize: 'none'
+        } : {};
+        if (shouldApplyAria) {
+            reference.role = 'combobox';
+            reference['aria-expanded'] = ariaExpanded;
+            reference['aria-haspopup'] = ariaHasPopup;
+            reference['aria-controls'] = open ? listElement?.id : void 0;
+            reference['aria-autocomplete'] = autoComplete;
+        }
+        return {
+            reference,
+            floating: {
+                role: 'presentation'
+            }
+        };
+    }, [
+        inputElement,
+        open,
+        ariaExpanded,
+        ariaHasPopup,
+        listElement?.id,
+        autoComplete
+    ]);
+    const click = useClick(floatingRootContext, {
+        enabled: !readOnly && !disabled && openOnInputClick,
+        event: 'mousedown-only',
+        toggle: false,
+        touchOpenDelay: inputInsidePopup ? 0 : 100,
+        reason: inputPress
+    });
+    const dismiss = useDismiss(floatingRootContext, {
+        enabled: !readOnly && !disabled && !inline,
+        outsidePressEvent: {
+            mouse: 'sloppy',
+            touch: 'intentional'
+        },
+        bubbles: inline ? true : void 0,
+        outsidePress (event) {
+            const target = getTarget(event);
+            return !shadowDom_contains(triggerElement, target) && !shadowDom_contains(clearRef.current, target) && !shadowDom_contains(chipsContainerRef.current, target) && !shadowDom_contains(inputGroupElement, target);
+        }
+    });
+    const listNavigation = useListNavigation(floatingRootContext, {
+        enabled: !readOnly && !disabled,
+        id,
+        listRef,
+        activeIndex,
+        selectedIndex,
+        virtual: true,
+        loopFocus,
+        allowEscape: loopFocus && !autoHighlightMode,
+        focusItemOnOpen: queryChangedAfterOpen || 'none' === selectionMode && !autoHighlightMode ? false : 'auto',
+        focusItemOnHover: highlightItemOnHover,
+        resetOnPointerLeave: !keepHighlight,
+        cols: grid ? 2 : 1,
+        orientation: grid ? 'horizontal' : void 0,
+        rtl: 'rtl' === direction,
+        disabledIndices: EMPTY_ARRAY,
+        onNavigate (nextActiveIndex, event) {
+            if (!event && !open || 'ending' === transitionStatus) return;
+            event ? setIndices({
+                activeIndex: nextActiveIndex,
+                type: keyboardActiveRef.current ? 'keyboard' : 'pointer'
+            }) : setIndices({
+                activeIndex: nextActiveIndex
+            });
+        }
+    });
+    const inputProps = __rspack_external_react.useMemo(()=>mergeProps(listNavigation.reference, dismiss.reference, click.reference, role.reference), [
+        listNavigation.reference,
+        dismiss.reference,
+        click.reference,
+        role.reference
+    ]);
+    const popupProps = __rspack_external_react.useMemo(()=>mergeProps(FOCUSABLE_POPUP_PROPS, listNavigation.floating, dismiss.floating, role.floating), [
+        listNavigation.floating,
+        dismiss.floating,
+        role.floating
+    ]);
+    const itemProps = __rspack_external_react.useMemo(()=>{
+        const listNavigationItemProps = listNavigation.item;
+        if (!listNavigationItemProps) return EMPTY_OBJECT;
+        return {
+            ...listNavigationItemProps,
+            onFocus: void 0
+        };
+    }, [
+        listNavigation.item
+    ]);
+    useOnFirstRender(()=>{
+        store.update({
+            inline: inlineProp,
+            popupProps,
+            inputProps,
+            triggerProps,
+            itemProps,
+            setOpen,
+            setInputValue,
+            setSelectedValue,
+            setIndices,
+            onItemHighlighted,
+            handleSelection,
+            forceMount,
+            requestSubmit
+        });
+    });
+    useIsoLayoutEffect(()=>{
+        store.update({
+            id,
+            selectedValue,
+            open,
+            mounted,
+            transitionStatus,
+            items,
+            inline: inlineProp,
+            popupProps,
+            inputProps,
+            triggerProps,
+            openMethod,
+            itemProps,
+            selectionMode,
+            name,
+            form,
+            disabled,
+            readOnly,
+            required,
+            grid,
+            isGrouped,
+            virtualized,
+            onOpenChangeComplete,
+            openOnInputClick,
+            itemToStringLabel,
+            modal,
+            autoHighlight: autoHighlightMode,
+            isItemEqualToValue,
+            submitOnItemClick,
+            hasInputValue,
+            requestSubmit,
+            inputOwnsFormValue: 'none' === selectionMode && (inlineProp || !store.state.inputInsidePopup)
+        });
+    }, [
+        store,
+        id,
+        selectedValue,
+        open,
+        mounted,
+        transitionStatus,
+        items,
+        popupProps,
+        inputProps,
+        itemProps,
+        openMethod,
+        triggerProps,
+        selectionMode,
+        name,
+        disabled,
+        readOnly,
+        required,
+        validation,
+        grid,
+        isGrouped,
+        virtualized,
+        onOpenChangeComplete,
+        openOnInputClick,
+        itemToStringLabel,
+        modal,
+        isItemEqualToValue,
+        submitOnItemClick,
+        hasInputValue,
+        inlineProp,
+        requestSubmit,
+        autoHighlightMode,
+        form
+    ]);
+    const hiddenInputRef = useMergedRefs(inputRefProp, validation.inputRef);
+    const itemsContextValue = __rspack_external_react.useMemo(()=>({
+            query,
+            hasItems,
+            filteredItems,
+            flatFilteredItems
+        }), [
+        query,
+        hasItems,
+        filteredItems,
+        flatFilteredItems
+    ]);
+    const serializedValue = __rspack_external_react.useMemo(()=>{
+        if (Array.isArray(fieldRawValue)) return '';
+        return stringifyAsValue(fieldRawValue, itemToStringValue);
+    }, [
+        fieldRawValue,
+        itemToStringValue
+    ]);
+    const hasMultipleSelection = multiple && Array.isArray(selectedValue) && selectedValue.length > 0;
+    const hiddenInputName = multiple || 'none' === selectionMode && inputOwnsFormValue ? void 0 : name;
+    const hiddenInputs = __rspack_external_react.useMemo(()=>{
+        if (!multiple || !Array.isArray(selectedValue) || !name) return null;
+        return selectedValue.map((value)=>{
+            const currentSerializedValue = stringifyAsValue(value, itemToStringValue);
+            return /*#__PURE__*/ jsx("input", {
+                type: "hidden",
+                form: form,
+                name: name,
+                value: currentSerializedValue
+            }, currentSerializedValue);
+        });
+    }, [
+        multiple,
+        selectedValue,
+        form,
+        name,
+        itemToStringValue
+    ]);
+    const children = /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            props.children,
+            /*#__PURE__*/ jsx("input", {
+                ...validation.getInputValidationProps({
+                    onFocus () {
+                        if (inputInsidePopup) return void triggerElement?.focus();
+                        (inputRef.current || triggerElement)?.focus();
+                    },
+                    onChange (event) {
+                        if (event.nativeEvent.defaultPrevented || disabled || readOnly) return void event.preventBaseUIHandler?.();
+                        const nextValue = event.currentTarget.value;
+                        const details = createChangeEventDetails("none", event.nativeEvent);
+                        function handleChange() {
+                            if (multiple) return;
+                            if ('none' === selectionMode) {
+                                setDirty(nextValue !== validityData.initialValue);
+                                setInputValue(nextValue, details);
+                                if (shouldValidateOnChange()) validation.commit(nextValue);
+                                return;
+                            }
+                            const matchingValue = valuesRef.current.find((v)=>{
+                                const candidateValue = stringifyAsValue(v, itemToStringValue);
+                                if (candidateValue.toLowerCase() === nextValue.toLowerCase()) return true;
+                                const candidateLabel = stringifyAsLabel(v, itemToStringLabel);
+                                if (candidateLabel.toLowerCase() === nextValue.toLowerCase()) return true;
+                                return false;
+                            });
+                            if (null != matchingValue) {
+                                setDirty(matchingValue !== validityData.initialValue);
+                                setSelectedValue?.(matchingValue, details);
+                                if (shouldValidateOnChange()) validation.commit(matchingValue);
+                            }
+                        }
+                        if (items) handleChange();
+                        else {
+                            forceMount();
+                            queueMicrotask(handleChange);
+                        }
+                    }
+                }),
+                id: id && null == hiddenInputName ? `${id}-hidden-input` : void 0,
+                form: form,
+                name: hiddenInputName,
+                autoComplete: formAutoComplete,
+                disabled: disabled,
+                required: required && !hasMultipleSelection,
+                readOnly: readOnly,
+                value: serializedValue,
+                ref: hiddenInputRef,
+                style: hiddenInputName ? visuallyHiddenInput : visuallyHidden,
+                tabIndex: -1,
+                "aria-hidden": true,
+                suppressHydrationWarning: true
+            }),
+            hiddenInputs
+        ]
+    });
+    return /*#__PURE__*/ jsx(ComboboxRootContext.Provider, {
+        value: store,
+        children: /*#__PURE__*/ jsx(ComboboxFloatingContext.Provider, {
+            value: floatingRootContext,
+            children: /*#__PURE__*/ jsx(ComboboxDerivedItemsContext.Provider, {
+                value: itemsContextValue,
+                children: /*#__PURE__*/ jsx(ComboboxInputValueContext.Provider, {
+                    value: inputValue,
+                    children: children
+                })
+            })
+        })
+    });
+}
+const ComboboxPortal_ComboboxPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const { keepMounted = false, ...portalProps } = props;
+    const store = useComboboxRootContext();
+    const mounted = useStore(store, selectors.mounted);
+    const forceMounted = useStore(store, selectors.forceMounted);
+    const shouldRender = mounted || keepMounted || forceMounted;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(ComboboxPortalContext.Provider, {
+        value: keepMounted,
+        children: /*#__PURE__*/ jsx(FloatingPortal_FloatingPortal, {
+            ref: forwardedRef,
+            ...portalProps
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) ComboboxPortal_ComboboxPortal.displayName = "ComboboxPortal";
+export { AriaCombobox, ComboboxArrow_ComboboxArrow, ComboboxBackdrop_ComboboxBackdrop, ComboboxChipsContext, ComboboxClear_ComboboxClear, ComboboxCollection, ComboboxEmpty_ComboboxEmpty, ComboboxGroupLabel_ComboboxGroupLabel, ComboboxGroup_ComboboxGroup, ComboboxIcon_ComboboxIcon, ComboboxInputGroup_ComboboxInputGroup, ComboboxInput_ComboboxInput, ComboboxItem_ComboboxItem, ComboboxList_ComboboxList, ComboboxPopup_ComboboxPopup, ComboboxPortal_ComboboxPortal, ComboboxPositioner_ComboboxPositioner, ComboboxRow_ComboboxRow, ComboboxStatus_ComboboxStatus, ComboboxTrigger_ComboboxTrigger, handleInputPress, selectors, useComboboxChipsContext, useComboboxInputValueContext, useComboboxItemContext, useComboboxRootContext, useCoreFilter };