@wix/site-ui 1.29.0 → 1.31.0

package/dist/Select/index.js

@@ -1,7 +1,1808 @@
-import { jsx } from "react/jsx-runtime";
-import { Select } from "@base-ui/react/select";
+import { jsx, jsxs } from "react/jsx-runtime";
 import clsx from "clsx";
+import { EMPTY_ARRAY, useRefWithInit, EMPTY_OBJECT, mergeProps, useMergedRefs, useRenderElement, esm_formatErrorMessage } from "../8272.js";
+import { Store, createSelector, useStore, useDismiss } from "../5992.js";
+import { defaultItemEquality, removeItem, findItemIndex, stringifyAsLabel, stringifyAsValue, hasNullItemLabel, compareItemEquality, selectedValueIncludes, resolveMultipleLabels, resolveSelectedLabel } from "../7366.js";
+import { useLabelableContext, useFieldRootContext, fieldValidityMapping } from "../1477.js";
+import { getDefaultLabelId, resolveAriaLabelledBy } from "../6825.js";
+import { useLabel } from "../4143.js";
+import { DROPDOWN_COLLISION_AVOIDANCE, triggerOpenStateMapping, FloatingPortal_FloatingPortal, popupStateMapping, pressableTriggerOpenStateMapping } from "../4388.js";
+import { useLabelableId } from "../9048.js";
+import { useValueAsRef } from "../4707.js";
+import { useButton } from "../9189.js";
+import { useStableCallback } from "../7541.js";
+import { useTimeout } from "../42.js";
+import { getFloatingFocusElement } from "../8758.js";
+import { createChangeEventDetails } from "../4768.js";
+import { contains } from "../4549.js";
+import { ownerDocument } from "../9829.js";
+import { getPseudoElementBounds } from "../7373.js";
+import { itemPress, focusOut, outsidePress, cancelOpen, windowResize } from "../2418.js";
+import { transitionStatusMapping, useTransitionStatus, useOpenChangeComplete } from "../880.js";
+import { useIsoLayoutEffect } from "../6499.js";
+import { useAnchoredPopupScrollLock } from "../6247.js";
+import { usePositioner, floating_ui_dom_platform, useAnchorPositioning, getDisabledMountTransitionStyles, useFloatingRootContext } from "../8750.js";
+import { CompositeList } from "../9255.js";
+import { useOpenInteractionType, FloatingFocusManager, InternalBackdrop_InternalBackdrop } from "../3485.js";
+import { inertValue } from "../167.js";
+import { useToolbarRootContext } from "../6107.js";
+import { useDirection } from "../9863.js";
+import { useCSPContext } from "../6003.js";
+import { useAnimationFrame } from "../8996.js";
+import { clamp } from "../3296.js";
+import { getWindow } from "../3829.js";
+import { isWebKit } from "../8971.js";
+import { addEventListener } from "../4723.js";
+import { COMPOSITE_KEYS } from "../1500.js";
+import { styleDisableScrollbar, normalizeScrollOffset, getMaxScrollOffset } from "../6329.js";
+import { rectToClientRect } from "../3319.js";
+import { useCompositeListItem, useCompositeListItem_IndexGuessBehavior } from "../3021.js";
+import { isVirtualClick } from "../6330.js";
+import { useBaseUiId } from "../6046.js";
+import { useFormContext } from "../5085.js";
+import { useControlled } from "../8527.js";
+import { usePreviousValue } from "../7021.js";
+import { useRegisterFieldControl } from "../4281.js";
+import { useValueChanged } from "../2801.js";
+import { useClick } from "../5864.js";
+import { useListNavigation, useTypeahead } from "../5299.js";
+import { FOCUSABLE_POPUP_PROPS, useOnFirstRender } from "../8106.js";
+import { visuallyHiddenInput, visuallyHidden } from "../8225.js";
+import { Separator } from "../9635.js";
 import * as __rspack_external_react from "react";
+const SelectRootContext = /*#__PURE__*/ __rspack_external_react.createContext(null);
+if ("production" !== process.env.NODE_ENV) SelectRootContext.displayName = "SelectRootContext";
+const SelectFloatingContext = /*#__PURE__*/ __rspack_external_react.createContext(null);
+if ("production" !== process.env.NODE_ENV) SelectFloatingContext.displayName = "SelectFloatingContext";
+function useSelectRootContext() {
+    const context = __rspack_external_react.useContext(SelectRootContext);
+    if (null === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: SelectRootContext is missing. Select parts must be placed within <Select.Root>.' : esm_formatErrorMessage(60));
+    return context;
+}
+function useSelectFloatingContext() {
+    const context = __rspack_external_react.useContext(SelectFloatingContext);
+    if (null === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: SelectFloatingContext is missing. Select parts must be placed within <Select.Root>.' : esm_formatErrorMessage(61));
+    return context;
+}
+const selectors = {
+    id: createSelector((state)=>state.id),
+    labelId: createSelector((state)=>state.labelId),
+    modal: createSelector((state)=>state.modal),
+    multiple: createSelector((state)=>state.multiple),
+    items: createSelector((state)=>state.items),
+    itemToStringLabel: createSelector((state)=>state.itemToStringLabel),
+    itemToStringValue: createSelector((state)=>state.itemToStringValue),
+    isItemEqualToValue: createSelector((state)=>state.isItemEqualToValue),
+    value: createSelector((state)=>state.value),
+    hasSelectedValue: createSelector((state)=>{
+        const { value, multiple, itemToStringValue } = state;
+        if (null == value) return false;
+        if (multiple && Array.isArray(value)) return value.length > 0;
+        return '' !== stringifyAsValue(value, itemToStringValue);
+    }),
+    hasNullItemLabel: createSelector((state, enabled)=>enabled ? hasNullItemLabel(state.items) : false),
+    open: createSelector((state)=>state.open),
+    mounted: createSelector((state)=>state.mounted),
+    forceMount: createSelector((state)=>state.forceMount),
+    transitionStatus: createSelector((state)=>state.transitionStatus),
+    openMethod: createSelector((state)=>state.openMethod),
+    activeIndex: createSelector((state)=>state.activeIndex),
+    selectedIndex: createSelector((state)=>state.selectedIndex),
+    isActive: createSelector((state, index)=>state.activeIndex === index),
+    isSelected: createSelector((state, index, itemValue)=>{
+        const comparer = state.isItemEqualToValue;
+        const storeValue = state.value;
+        if (state.multiple) return Array.isArray(storeValue) && storeValue.some((selectedItem)=>compareItemEquality(itemValue, selectedItem, comparer));
+        if (state.selectedIndex === index && null !== state.selectedIndex) return true;
+        return compareItemEquality(itemValue, storeValue, comparer);
+    }),
+    isSelectedByFocus: createSelector((state, index)=>state.selectedIndex === index),
+    popupProps: createSelector((state)=>state.popupProps),
+    triggerProps: createSelector((state)=>state.triggerProps),
+    triggerElement: createSelector((state)=>state.triggerElement),
+    positionerElement: createSelector((state)=>state.positionerElement),
+    listElement: createSelector((state)=>state.listElement),
+    popupSide: createSelector((state)=>state.popupSide),
+    scrollUpArrowVisible: createSelector((state)=>state.scrollUpArrowVisible),
+    scrollDownArrowVisible: createSelector((state)=>state.scrollDownArrowVisible),
+    hasScrollArrows: createSelector((state)=>state.hasScrollArrows)
+};
+const SelectLabel_SelectLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const elementPropsWithoutId = elementProps;
+    delete elementPropsWithoutId.id;
+    const fieldRootContext = useFieldRootContext();
+    const { store } = useSelectRootContext();
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const rootId = useStore(store, selectors.id);
+    const defaultLabelId = getDefaultLabelId(rootId);
+    const labelProps = useLabel({
+        id: defaultLabelId,
+        fallbackControlId: triggerElement?.id ?? rootId,
+        setLabelId (nextLabelId) {
+            store.set('labelId', nextLabelId);
+        }
+    });
+    return useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        state: fieldRootContext.state,
+        props: [
+            labelProps,
+            elementProps
+        ],
+        stateAttributesMapping: fieldValidityMapping
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectLabel_SelectLabel.displayName = "SelectLabel";
+const BOUNDARY_OFFSET = 2;
+const SELECTED_DELAY = 400;
+const stateAttributesMapping = {
+    ...pressableTriggerOpenStateMapping,
+    ...fieldValidityMapping,
+    popupSide: (side)=>side ? {
+            'data-popup-side': side
+        } : null,
+    value: ()=>null
+};
+const SelectTrigger_SelectTrigger = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, id: idProp, disabled: disabledProp = false, nativeButton = true, style, ...elementProps } = componentProps;
+    const { setTouched, setFocused, validationMode, state: fieldState, disabled: fieldDisabled } = useFieldRootContext();
+    const { labelId: fieldLabelId } = useLabelableContext();
+    const { store, setOpen, selectionRef, validation, readOnly, required, alignItemWithTriggerActiveRef, disabled: selectDisabled, keyboardActiveRef } = useSelectRootContext();
+    const disabled = fieldDisabled || selectDisabled || disabledProp;
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const value = useStore(store, selectors.value);
+    const triggerProps = useStore(store, selectors.triggerProps);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const listElement = useStore(store, selectors.listElement);
+    const popupSideValue = useStore(store, selectors.popupSide);
+    const rootId = useStore(store, selectors.id);
+    const selectLabelId = useStore(store, selectors.labelId);
+    const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+    const popupSide = mounted && positionerElement ? popupSideValue : null;
+    const id = idProp ?? rootId;
+    const ariaLabelledBy = resolveAriaLabelledBy(fieldLabelId, selectLabelId);
+    useLabelableId({
+        id
+    });
+    const positionerRef = useValueAsRef(positionerElement);
+    const triggerRef = __rspack_external_react.useRef(null);
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        native: nativeButton
+    });
+    const setTriggerElement = useStableCallback((element)=>{
+        store.set('triggerElement', element);
+    });
+    const mergedRef = useMergedRefs(forwardedRef, triggerRef, buttonRef, setTriggerElement);
+    const timeoutFocus = useTimeout();
+    const timeoutMouseDown = useTimeout();
+    const selectedDelayTimeout = useTimeout();
+    __rspack_external_react.useEffect(()=>{
+        if (open) {
+            selectedDelayTimeout.start(SELECTED_DELAY, ()=>{
+                selectionRef.current.allowUnselectedMouseUp = true;
+                selectionRef.current.allowSelectedMouseUp = true;
+            });
+            return ()=>{
+                selectedDelayTimeout.clear();
+            };
+        }
+        selectionRef.current = {
+            allowSelectedMouseUp: false,
+            allowUnselectedMouseUp: false,
+            dragY: 0
+        };
+        timeoutMouseDown.clear();
+    }, [
+        open,
+        selectionRef,
+        timeoutMouseDown,
+        selectedDelayTimeout
+    ]);
+    const props = mergeProps(triggerProps, {
+        id,
+        role: 'combobox',
+        'aria-expanded': open ? 'true' : 'false',
+        'aria-haspopup': 'listbox',
+        'aria-controls': open ? listElement?.id ?? getFloatingFocusElement(positionerElement)?.id : void 0,
+        'aria-labelledby': ariaLabelledBy,
+        'aria-readonly': readOnly || void 0,
+        'aria-required': required || void 0,
+        tabIndex: disabled ? -1 : 0,
+        ref: mergedRef,
+        onFocus (event) {
+            setFocused(true);
+            if (open && alignItemWithTriggerActiveRef.current) setOpen(false, createChangeEventDetails("none", event.nativeEvent));
+            timeoutFocus.start(0, ()=>{
+                store.set('forceMount', true);
+            });
+        },
+        onBlur (event) {
+            if (contains(positionerElement, event.relatedTarget)) return;
+            setTouched(true);
+            setFocused(false);
+            if ('onBlur' === validationMode) validation.commit(value);
+        },
+        onPointerMove () {
+            keyboardActiveRef.current = false;
+        },
+        onKeyDown () {
+            keyboardActiveRef.current = true;
+        },
+        onMouseDown (event) {
+            if (open) return;
+            const doc = ownerDocument(event.currentTarget);
+            function handleMouseUp(mouseEvent) {
+                if (!triggerRef.current) return;
+                const mouseUpTarget = mouseEvent.target;
+                if (contains(triggerRef.current, mouseUpTarget) || contains(positionerRef.current, mouseUpTarget) || mouseUpTarget === triggerRef.current) return;
+                const bounds = getPseudoElementBounds(triggerRef.current);
+                if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) return;
+                setOpen(false, createChangeEventDetails(cancelOpen, mouseEvent));
+            }
+            timeoutMouseDown.start(0, ()=>{
+                doc.addEventListener('mouseup', handleMouseUp, {
+                    once: true
+                });
+            });
+        }
+    }, validation.getValidationProps, elementProps, getButtonProps);
+    props.role = 'combobox';
+    const state = {
+        ...fieldState,
+        open,
+        disabled,
+        value,
+        readOnly,
+        popupSide,
+        placeholder: !hasSelectedValue
+    };
+    return useRenderElement('button', componentProps, {
+        ref: [
+            forwardedRef,
+            triggerRef
+        ],
+        state,
+        stateAttributesMapping: stateAttributesMapping,
+        props
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectTrigger_SelectTrigger.displayName = "SelectTrigger";
+const SelectValue_stateAttributesMapping = {
+    value: ()=>null
+};
+const SelectValue_SelectValue = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { className, render, children: childrenProp, placeholder, style, ...elementProps } = componentProps;
+    const { store, valueRef } = useSelectRootContext();
+    const value = useStore(store, selectors.value);
+    const items = useStore(store, selectors.items);
+    const itemToStringLabel = useStore(store, selectors.itemToStringLabel);
+    const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+    const shouldCheckNullItemLabel = !hasSelectedValue && null != placeholder && null == childrenProp;
+    const hasNullLabel = useStore(store, selectors.hasNullItemLabel, shouldCheckNullItemLabel);
+    const state = {
+        value,
+        placeholder: !hasSelectedValue
+    };
+    let children = null;
+    children = 'function' == typeof childrenProp ? childrenProp(value) : null != childrenProp ? childrenProp : hasSelectedValue || null == placeholder || hasNullLabel ? Array.isArray(value) ? resolveMultipleLabels(value, items, itemToStringLabel) : resolveSelectedLabel(value, items, itemToStringLabel) : placeholder;
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            valueRef
+        ],
+        props: [
+            {
+                children
+            },
+            elementProps
+        ],
+        stateAttributesMapping: SelectValue_stateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) SelectValue_SelectValue.displayName = "SelectValue";
+const SelectIcon_SelectIcon = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { store } = useSelectRootContext();
+    const open = useStore(store, selectors.open);
+    const state = {
+        open
+    };
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                'aria-hidden': true,
+                children: '▼'
+            },
+            elementProps
+        ],
+        stateAttributesMapping: triggerOpenStateMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) SelectIcon_SelectIcon.displayName = "SelectIcon";
+const SelectBackdrop_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const SelectBackdrop_SelectBackdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { store } = useSelectRootContext();
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const transitionStatus = useStore(store, selectors.transitionStatus);
+    const state = {
+        open,
+        transitionStatus
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                role: 'presentation',
+                hidden: !mounted,
+                style: {
+                    userSelect: 'none',
+                    WebkitUserSelect: 'none'
+                }
+            },
+            elementProps
+        ],
+        stateAttributesMapping: SelectBackdrop_stateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) SelectBackdrop_SelectBackdrop.displayName = "SelectBackdrop";
+const SelectPositionerContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) SelectPositionerContext.displayName = "SelectPositionerContext";
+function useSelectPositionerContext() {
+    const context = __rspack_external_react.useContext(SelectPositionerContext);
+    if (!context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: SelectPositionerContext is missing. SelectPositioner parts must be placed within <Select.Positioner>.' : esm_formatErrorMessage(59));
+    return context;
+}
+function clearStyles(element, originalStyles) {
+    if (element) Object.assign(element.style, originalStyles);
+}
+const LIST_FUNCTIONAL_STYLES = {
+    position: 'relative',
+    maxHeight: '100%',
+    overflowX: 'hidden',
+    overflowY: 'auto'
+};
+const FIXED = {
+    position: 'fixed'
+};
+const SelectPositioner_SelectPositioner = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { anchor, positionMethod = 'absolute', className, render, side = 'bottom', align = 'center', sideOffset = 0, alignOffset = 0, collisionBoundary = 'clipping-ancestors', collisionPadding, arrowPadding = 5, sticky = false, disableAnchorTracking, alignItemWithTrigger = true, collisionAvoidance = DROPDOWN_COLLISION_AVOIDANCE, style, ...elementProps } = componentProps;
+    const { store, listRef, labelsRef, alignItemWithTriggerActiveRef, selectedItemTextRef, valuesRef, initialValueRef, popupRef, setValue } = useSelectRootContext();
+    const floatingRootContext = useSelectFloatingContext();
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const modal = useStore(store, selectors.modal);
+    const value = useStore(store, selectors.value);
+    const openMethod = useStore(store, selectors.openMethod);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const isItemEqualToValue = useStore(store, selectors.isItemEqualToValue);
+    const transitionStatus = useStore(store, selectors.transitionStatus);
+    const scrollUpArrowRef = __rspack_external_react.useRef(null);
+    const scrollDownArrowRef = __rspack_external_react.useRef(null);
+    const [controlledAlignItemWithTrigger, setControlledAlignItemWithTrigger] = __rspack_external_react.useState(alignItemWithTrigger);
+    const alignItemWithTriggerActive = mounted && controlledAlignItemWithTrigger && 'touch' !== openMethod;
+    if (!mounted && controlledAlignItemWithTrigger !== alignItemWithTrigger) setControlledAlignItemWithTrigger(alignItemWithTrigger);
+    useIsoLayoutEffect(()=>{
+        if (!mounted) {
+            if (selectors.scrollUpArrowVisible(store.state)) store.set('scrollUpArrowVisible', false);
+            if (selectors.scrollDownArrowVisible(store.state)) store.set('scrollDownArrowVisible', false);
+        }
+    }, [
+        store,
+        mounted
+    ]);
+    __rspack_external_react.useImperativeHandle(alignItemWithTriggerActiveRef, ()=>alignItemWithTriggerActive);
+    useAnchoredPopupScrollLock((alignItemWithTriggerActive || modal) && open, 'touch' === openMethod, positionerElement, triggerElement);
+    const positioning = useAnchorPositioning({
+        anchor,
+        floatingRootContext,
+        positionMethod,
+        mounted,
+        side,
+        sideOffset,
+        align,
+        alignOffset,
+        arrowPadding,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        disableAnchorTracking: disableAnchorTracking ?? alignItemWithTriggerActive,
+        collisionAvoidance,
+        keepMounted: true
+    });
+    const renderedSide = alignItemWithTriggerActive ? 'none' : positioning.side;
+    const positionerStyles = alignItemWithTriggerActive ? FIXED : positioning.positionerStyles;
+    const state = {
+        open,
+        side: renderedSide,
+        align: positioning.align,
+        anchorHidden: positioning.anchorHidden
+    };
+    useIsoLayoutEffect(()=>{
+        store.set('popupSide', positioning.side);
+    }, [
+        store,
+        positioning.side
+    ]);
+    const setPositionerElement = useStableCallback((element)=>{
+        store.set('positionerElement', element);
+    });
+    const element = usePositioner(componentProps, state, {
+        styles: positionerStyles,
+        transitionStatus,
+        props: elementProps,
+        refs: [
+            forwardedRef,
+            setPositionerElement
+        ],
+        hidden: !mounted,
+        inert: !open
+    });
+    const prevMapSizeRef = __rspack_external_react.useRef(0);
+    const onMapChange = useStableCallback((map)=>{
+        if (0 === map.size && 0 === prevMapSizeRef.current) return;
+        if (0 === valuesRef.current.length) return;
+        const prevSize = prevMapSizeRef.current;
+        prevMapSizeRef.current = map.size;
+        if (map.size === prevSize) return;
+        const eventDetails = createChangeEventDetails("none");
+        if (0 !== prevSize && !store.state.multiple && null !== value) {
+            const selectedValueIndex = findItemIndex(valuesRef.current, value, isItemEqualToValue);
+            if (-1 === selectedValueIndex) {
+                const initialSelectedValue = initialValueRef.current;
+                const hasInitial = null != initialSelectedValue && -1 !== findItemIndex(valuesRef.current, initialSelectedValue, isItemEqualToValue);
+                const nextValue = hasInitial ? initialSelectedValue : null;
+                setValue(nextValue, eventDetails);
+                if (null === nextValue) {
+                    store.set('selectedIndex', null);
+                    selectedItemTextRef.current = null;
+                }
+            }
+        }
+        if (0 !== prevSize && store.state.multiple && Array.isArray(value)) {
+            const hasVisibleItem = (selectedItemValue)=>-1 !== findItemIndex(valuesRef.current, selectedItemValue, isItemEqualToValue);
+            const nextValue = value.filter((selectedItemValue)=>hasVisibleItem(selectedItemValue));
+            if (nextValue.length !== value.length || nextValue.some((selectedItemValue)=>!selectedValueIncludes(value, selectedItemValue, isItemEqualToValue))) {
+                setValue(nextValue, eventDetails);
+                if (0 === nextValue.length) {
+                    store.set('selectedIndex', null);
+                    selectedItemTextRef.current = null;
+                }
+            }
+        }
+        if (open && alignItemWithTriggerActive) {
+            store.update({
+                scrollUpArrowVisible: false,
+                scrollDownArrowVisible: false
+            });
+            const stylesToClear = {
+                height: ''
+            };
+            clearStyles(positionerElement, stylesToClear);
+            clearStyles(popupRef.current, stylesToClear);
+        }
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            ...positioning,
+            side: renderedSide,
+            alignItemWithTriggerActive,
+            setControlledAlignItemWithTrigger,
+            scrollUpArrowRef,
+            scrollDownArrowRef
+        }), [
+        positioning,
+        renderedSide,
+        alignItemWithTriggerActive,
+        setControlledAlignItemWithTrigger
+    ]);
+    return /*#__PURE__*/ jsx(CompositeList, {
+        elementsRef: listRef,
+        labelsRef: labelsRef,
+        onMapChange: onMapChange,
+        children: /*#__PURE__*/ jsxs(SelectPositionerContext.Provider, {
+            value: contextValue,
+            children: [
+                mounted && modal && /*#__PURE__*/ jsx(InternalBackdrop_InternalBackdrop, {
+                    inert: inertValue(!open),
+                    cutout: triggerElement
+                }),
+                element
+            ]
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectPositioner_SelectPositioner.displayName = "SelectPositioner";
+const SelectPopup_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const SelectPopup_SelectPopup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, finalFocus, ...elementProps } = componentProps;
+    const { store, popupRef, onOpenChangeComplete, setOpen, valueRef, firstItemTextRef, selectedItemTextRef, keyboardActiveRef, multiple, handleScrollArrowVisibility, scrollHandlerRef, listRef, highlightItemOnHover } = useSelectRootContext();
+    const { side, align, alignItemWithTriggerActive, isPositioned, setControlledAlignItemWithTrigger, scrollDownArrowRef, scrollUpArrowRef } = useSelectPositionerContext();
+    const insideToolbar = null != useToolbarRootContext(true);
+    const floatingRootContext = useSelectFloatingContext();
+    const direction = useDirection();
+    const { nonce, disableStyleElements } = useCSPContext();
+    const id = useStore(store, selectors.id);
+    const open = useStore(store, selectors.open);
+    const mounted = useStore(store, selectors.mounted);
+    const popupProps = useStore(store, selectors.popupProps);
+    const transitionStatus = useStore(store, selectors.transitionStatus);
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const listElement = useStore(store, selectors.listElement);
+    const reachedMaxHeightRef = __rspack_external_react.useRef(false);
+    const initialPlacedRef = __rspack_external_react.useRef(false);
+    const originalPositionerStylesRef = __rspack_external_react.useRef({});
+    const scrollArrowFrame = useAnimationFrame();
+    const handleScroll = useStableCallback((scroller)=>{
+        if (!positionerElement || !popupRef.current || !initialPlacedRef.current) return;
+        if (reachedMaxHeightRef.current || !alignItemWithTriggerActive) return void handleScrollArrowVisibility();
+        const isTopPositioned = '0px' === positionerElement.style.top;
+        const isBottomPositioned = '0px' === positionerElement.style.bottom;
+        if (!isTopPositioned && !isBottomPositioned) return void handleScrollArrowVisibility();
+        const scale = getScale(positionerElement);
+        const currentHeight = normalizeSize(positionerElement.getBoundingClientRect().height, 'y', scale);
+        const doc = ownerDocument(positionerElement);
+        const positionerStyles = getComputedStyle(positionerElement);
+        const marginTop = parseFloat(positionerStyles.marginTop);
+        const marginBottom = parseFloat(positionerStyles.marginBottom);
+        const maxPopupHeight = getMaxPopupHeight(getComputedStyle(popupRef.current));
+        const maxAvailableHeight = Math.min(doc.documentElement.clientHeight - marginTop - marginBottom, maxPopupHeight);
+        const scrollTop = scroller.scrollTop;
+        const maxScrollTop = getMaxScrollTop(scroller);
+        let nextPositionerHeight = 0;
+        let nextScrollTop = null;
+        let setReachedMax = false;
+        let scrollToMax = false;
+        const setHeight = (height)=>{
+            positionerElement.style.height = `${height}px`;
+        };
+        const handleSmallDiff = (diff, targetScrollTop)=>{
+            const heightDelta = clamp(diff, 0, maxAvailableHeight - currentHeight);
+            if (heightDelta > 0) setHeight(currentHeight + heightDelta);
+            scroller.scrollTop = targetScrollTop;
+            if (maxAvailableHeight - (currentHeight + heightDelta) <= 1) reachedMaxHeightRef.current = true;
+            handleScrollArrowVisibility();
+        };
+        const diff = isTopPositioned ? maxScrollTop - scrollTop : scrollTop;
+        const nextHeight = Math.min(currentHeight + diff, maxAvailableHeight);
+        nextPositionerHeight = nextHeight;
+        if (diff <= 1) return void handleSmallDiff(diff, isTopPositioned ? maxScrollTop : 0);
+        if (maxAvailableHeight - nextHeight > 1) if (isTopPositioned) scrollToMax = true;
+        else nextScrollTop = 0;
+        else {
+            setReachedMax = true;
+            if (isBottomPositioned && scrollTop < maxScrollTop) {
+                const overshoot = currentHeight + diff - maxAvailableHeight;
+                nextScrollTop = scrollTop - (diff - overshoot);
+            }
+        }
+        nextPositionerHeight = Math.ceil(nextPositionerHeight);
+        if (0 !== nextPositionerHeight) setHeight(nextPositionerHeight);
+        if (scrollToMax || null != nextScrollTop) {
+            const nextMaxScrollTop = getMaxScrollTop(scroller);
+            const target = scrollToMax ? nextMaxScrollTop : clamp(nextScrollTop, 0, nextMaxScrollTop);
+            if (Math.abs(scroller.scrollTop - target) > 1) scroller.scrollTop = target;
+        }
+        if (setReachedMax || nextPositionerHeight >= maxAvailableHeight - 1) reachedMaxHeightRef.current = true;
+        handleScrollArrowVisibility();
+    });
+    __rspack_external_react.useImperativeHandle(scrollHandlerRef, ()=>handleScroll, [
+        handleScroll
+    ]);
+    useOpenChangeComplete({
+        open,
+        ref: popupRef,
+        onComplete () {
+            if (open) onOpenChangeComplete?.(true);
+        }
+    });
+    const state = {
+        open,
+        transitionStatus,
+        side,
+        align
+    };
+    useIsoLayoutEffect(()=>{
+        if (!positionerElement || !popupRef.current || Object.keys(originalPositionerStylesRef.current).length) return;
+        originalPositionerStylesRef.current = {
+            top: positionerElement.style.top || '0',
+            left: positionerElement.style.left || '0',
+            right: positionerElement.style.right,
+            height: positionerElement.style.height,
+            bottom: positionerElement.style.bottom,
+            minHeight: positionerElement.style.minHeight,
+            maxHeight: positionerElement.style.maxHeight,
+            marginTop: positionerElement.style.marginTop,
+            marginBottom: positionerElement.style.marginBottom
+        };
+    }, [
+        popupRef,
+        positionerElement
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (open || alignItemWithTriggerActive) return;
+        initialPlacedRef.current = false;
+        reachedMaxHeightRef.current = false;
+        clearStyles(positionerElement, originalPositionerStylesRef.current);
+    }, [
+        open,
+        alignItemWithTriggerActive,
+        positionerElement,
+        popupRef
+    ]);
+    useIsoLayoutEffect(()=>{
+        const popupElement = popupRef.current;
+        if (!open || !triggerElement || !positionerElement || !popupElement || alignItemWithTriggerActive && !isPositioned || 'ending' === store.state.transitionStatus) return;
+        if (!alignItemWithTriggerActive) {
+            initialPlacedRef.current = true;
+            scrollArrowFrame.request(handleScrollArrowVisibility);
+            popupElement.style.removeProperty('--transform-origin');
+            return;
+        }
+        const restoreTransformStyles = unsetTransformStyles(popupElement);
+        popupElement.style.removeProperty('--transform-origin');
+        try {
+            let textElement = selectedItemTextRef.current;
+            if (!textElement?.isConnected) {
+                const hasSelectedValue = selectors.hasSelectedValue(store.state);
+                textElement = !hasSelectedValue && firstItemTextRef.current?.isConnected ? firstItemTextRef.current : null;
+            }
+            const valueElement = valueRef.current;
+            const positionerStyles = getComputedStyle(positionerElement);
+            const popupStyles = getComputedStyle(popupElement);
+            const doc = ownerDocument(triggerElement);
+            const win = getWindow(positionerElement);
+            const scale = getScale(triggerElement);
+            const triggerRect = normalizeRect(triggerElement.getBoundingClientRect(), scale);
+            const positionerRect = normalizeRect(positionerElement.getBoundingClientRect(), scale);
+            const triggerHeight = triggerRect.height;
+            const scroller = listElement || popupElement;
+            const scrollHeight = scroller.scrollHeight;
+            const borderBottom = parseFloat(popupStyles.borderBottomWidth);
+            const marginTop = parseFloat(positionerStyles.marginTop) || 10;
+            const marginBottom = parseFloat(positionerStyles.marginBottom) || 10;
+            const minHeight = parseFloat(positionerStyles.minHeight) || 100;
+            const maxPopupHeight = getMaxPopupHeight(popupStyles);
+            const paddingLeft = 5;
+            const paddingRight = 5;
+            const triggerCollisionThreshold = 20;
+            const viewportHeight = doc.documentElement.clientHeight - marginTop - marginBottom;
+            const viewportWidth = doc.documentElement.clientWidth;
+            const availableSpaceBeneathTrigger = viewportHeight - triggerRect.bottom + triggerHeight;
+            let textRect;
+            let alignedLeft = 'rtl' === direction ? triggerRect.right - positionerRect.width : triggerRect.left;
+            let offsetY = 0;
+            if (textElement && valueElement) {
+                const valueRect = normalizeRect(valueElement.getBoundingClientRect(), scale);
+                textRect = normalizeRect(textElement.getBoundingClientRect(), scale);
+                alignedLeft = positionerRect.left + ('rtl' === direction ? valueRect.right - textRect.right : valueRect.left - textRect.left);
+                const valueCenterFromTriggerTop = valueRect.top - triggerRect.top + valueRect.height / 2;
+                const textCenterFromPositionerTop = textRect.top - positionerRect.top + textRect.height / 2;
+                offsetY = textCenterFromPositionerTop - valueCenterFromTriggerTop;
+            }
+            const idealHeight = availableSpaceBeneathTrigger + offsetY + marginBottom + borderBottom;
+            let height = Math.min(viewportHeight, idealHeight);
+            const maxHeight = viewportHeight - marginTop - marginBottom;
+            const scrollTop = idealHeight - height;
+            const maxRight = viewportWidth - paddingRight;
+            positionerElement.style.left = `${clamp(alignedLeft, paddingLeft, maxRight - positionerRect.width)}px`;
+            positionerElement.style.height = `${height}px`;
+            positionerElement.style.maxHeight = 'auto';
+            positionerElement.style.marginTop = `${marginTop}px`;
+            positionerElement.style.marginBottom = `${marginBottom}px`;
+            popupElement.style.height = '100%';
+            const maxScrollTop = getMaxScrollTop(scroller);
+            const isTopPositioned = scrollTop >= maxScrollTop - 1;
+            if (isTopPositioned) height = Math.min(viewportHeight, positionerRect.height) - (scrollTop - maxScrollTop);
+            const fallbackToAlignPopupToTrigger = triggerRect.top < triggerCollisionThreshold || triggerRect.bottom > viewportHeight - triggerCollisionThreshold || Math.ceil(height) + 1 < Math.min(scrollHeight, minHeight);
+            const isPinchZoomed = (win.visualViewport?.scale ?? 1) !== 1 && isWebKit;
+            if (fallbackToAlignPopupToTrigger || isPinchZoomed) {
+                initialPlacedRef.current = true;
+                clearStyles(positionerElement, originalPositionerStylesRef.current);
+                setControlledAlignItemWithTrigger(false);
+                return;
+            }
+            const initialHeight = Math.max(minHeight, height);
+            if (isTopPositioned) {
+                const topOffset = Math.max(0, viewportHeight - idealHeight);
+                positionerElement.style.top = positionerRect.height >= maxHeight ? '0' : `${topOffset}px`;
+                positionerElement.style.height = `${height}px`;
+                scroller.scrollTop = getMaxScrollTop(scroller);
+            } else {
+                positionerElement.style.bottom = '0';
+                scroller.scrollTop = scrollTop;
+            }
+            if (textRect) {
+                const popupTop = positionerRect.top;
+                const popupHeight = positionerRect.height;
+                const textCenterY = textRect.top + textRect.height / 2;
+                const transformOriginY = popupHeight > 0 ? (textCenterY - popupTop) / popupHeight * 100 : 50;
+                const clampedY = clamp(transformOriginY, 0, 100);
+                popupElement.style.setProperty('--transform-origin', `50% ${clampedY}%`);
+            }
+            if (initialHeight === viewportHeight || height >= maxPopupHeight) reachedMaxHeightRef.current = true;
+            handleScrollArrowVisibility();
+            if (highlightItemOnHover && null === store.state.selectedIndex && null === store.state.activeIndex && null != listRef.current[0]) store.set('activeIndex', 0);
+            initialPlacedRef.current = true;
+        } finally{
+            restoreTransformStyles();
+        }
+    }, [
+        store,
+        open,
+        positionerElement,
+        triggerElement,
+        valueRef,
+        firstItemTextRef,
+        selectedItemTextRef,
+        popupRef,
+        handleScrollArrowVisibility,
+        alignItemWithTriggerActive,
+        setControlledAlignItemWithTrigger,
+        scrollArrowFrame,
+        scrollDownArrowRef,
+        scrollUpArrowRef,
+        listElement,
+        listRef,
+        highlightItemOnHover,
+        direction,
+        isPositioned
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!alignItemWithTriggerActive || !positionerElement || !open) return;
+        const win = getWindow(positionerElement);
+        function handleResize(event) {
+            setOpen(false, createChangeEventDetails(windowResize, event));
+        }
+        return addEventListener(win, 'resize', handleResize);
+    }, [
+        setOpen,
+        alignItemWithTriggerActive,
+        positionerElement,
+        open
+    ]);
+    const defaultProps = {
+        ...listElement ? {
+            role: 'presentation',
+            'aria-orientation': void 0
+        } : {
+            role: 'listbox',
+            'aria-multiselectable': multiple || void 0,
+            id: `${id}-list`
+        },
+        onKeyDown (event) {
+            keyboardActiveRef.current = true;
+            if (insideToolbar && COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+        },
+        onMouseMove () {
+            keyboardActiveRef.current = false;
+        },
+        onScroll (event) {
+            if (listElement) return;
+            handleScroll(event.currentTarget);
+        },
+        ...alignItemWithTriggerActive && {
+            style: listElement ? {
+                height: '100%'
+            } : LIST_FUNCTIONAL_STYLES
+        }
+    };
+    const element = useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            popupRef
+        ],
+        state,
+        stateAttributesMapping: SelectPopup_stateAttributesMapping,
+        props: [
+            popupProps,
+            defaultProps,
+            getDisabledMountTransitionStyles(transitionStatus),
+            {
+                className: !listElement && alignItemWithTriggerActive ? styleDisableScrollbar.className : void 0
+            },
+            elementProps
+        ]
+    });
+    return /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            !disableStyleElements && styleDisableScrollbar.getElement(nonce),
+            /*#__PURE__*/ jsx(FloatingFocusManager, {
+                context: floatingRootContext,
+                modal: false,
+                disabled: !mounted,
+                returnFocus: finalFocus,
+                restoreFocus: true,
+                children: element
+            })
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectPopup_SelectPopup.displayName = "SelectPopup";
+function getMaxPopupHeight(popupStyles) {
+    const maxHeightStyle = popupStyles.maxHeight || '';
+    return maxHeightStyle.endsWith('px') ? parseFloat(maxHeightStyle) || 1 / 0 : 1 / 0;
+}
+function getMaxScrollTop(scroller) {
+    return getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+}
+function getScale(element) {
+    return floating_ui_dom_platform.getScale(element);
+}
+function normalizeSize(size, axis, scale) {
+    return size / scale[axis];
+}
+function normalizeRect(rect, scale) {
+    return rectToClientRect({
+        x: normalizeSize(rect.x, 'x', scale),
+        y: normalizeSize(rect.y, 'y', scale),
+        width: normalizeSize(rect.width, 'x', scale),
+        height: normalizeSize(rect.height, 'y', scale)
+    });
+}
+const TRANSFORM_STYLE_RESETS = [
+    [
+        'transform',
+        'none'
+    ],
+    [
+        'scale',
+        '1'
+    ],
+    [
+        'translate',
+        '0 0'
+    ]
+];
+function unsetTransformStyles(popupElement) {
+    const { style } = popupElement;
+    const originalStyles = {};
+    for (const [property, value] of TRANSFORM_STYLE_RESETS){
+        originalStyles[property] = style.getPropertyValue(property);
+        style.setProperty(property, value, 'important');
+    }
+    return ()=>{
+        for (const [property] of TRANSFORM_STYLE_RESETS){
+            const originalValue = originalStyles[property];
+            if (originalValue) style.setProperty(property, originalValue);
+            else style.removeProperty(property);
+        }
+    };
+}
+const SelectList_SelectList = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { store, scrollHandlerRef } = useSelectRootContext();
+    const { alignItemWithTriggerActive } = useSelectPositionerContext();
+    const hasScrollArrows = useStore(store, selectors.hasScrollArrows);
+    const openMethod = useStore(store, selectors.openMethod);
+    const multiple = useStore(store, selectors.multiple);
+    const id = useStore(store, selectors.id);
+    const defaultProps = {
+        id: `${id}-list`,
+        role: 'listbox',
+        'aria-multiselectable': multiple || void 0,
+        onScroll (event) {
+            scrollHandlerRef.current?.(event.currentTarget);
+        },
+        ...alignItemWithTriggerActive && {
+            style: LIST_FUNCTIONAL_STYLES
+        },
+        className: hasScrollArrows && 'touch' !== openMethod ? styleDisableScrollbar.className : void 0
+    };
+    const setListElement = useStableCallback((element)=>{
+        store.set('listElement', element);
+    });
+    return useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            setListElement
+        ],
+        props: [
+            defaultProps,
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectList_SelectList.displayName = "SelectList";
+const SelectItemContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) SelectItemContext.displayName = "SelectItemContext";
+function useSelectItemContext() {
+    const context = __rspack_external_react.useContext(SelectItemContext);
+    if (!context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: SelectItemContext is missing. SelectItem parts must be placed within <Select.Item>.' : esm_formatErrorMessage(57));
+    return context;
+}
+const SelectItem_SelectItem = /*#__PURE__*/ __rspack_external_react.memo(/*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, value: itemValue = null, label, disabled = false, nativeButton = false, ...elementProps } = componentProps;
+    const textRef = __rspack_external_react.useRef(null);
+    const listItem = useCompositeListItem({
+        label,
+        textRef,
+        indexGuessBehavior: useCompositeListItem_IndexGuessBehavior.GuessFromOrder
+    });
+    const { store, itemProps, setOpen, setValue, selectionRef, typingRef, valuesRef, multiple, selectedItemTextRef } = useSelectRootContext();
+    const highlighted = useStore(store, selectors.isActive, listItem.index);
+    const selected = useStore(store, selectors.isSelected, listItem.index, itemValue);
+    const selectedByFocus = useStore(store, selectors.isSelectedByFocus, listItem.index);
+    const isItemEqualToValue = useStore(store, selectors.isItemEqualToValue);
+    const index = listItem.index;
+    const hasRegistered = -1 !== index;
+    const itemRef = __rspack_external_react.useRef(null);
+    useIsoLayoutEffect(()=>{
+        if (!hasRegistered) return;
+        const values = valuesRef.current;
+        values[index] = itemValue;
+        return ()=>{
+            delete values[index];
+        };
+    }, [
+        hasRegistered,
+        index,
+        itemValue,
+        valuesRef
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!hasRegistered) return;
+        const selectedValue = store.state.value;
+        let selectedCandidate = selectedValue;
+        if (multiple && Array.isArray(selectedValue) && selectedValue.length > 0) selectedCandidate = selectedValue[selectedValue.length - 1];
+        if (void 0 !== selectedCandidate && compareItemEquality(itemValue, selectedCandidate, isItemEqualToValue)) {
+            store.set('selectedIndex', index);
+            if (textRef.current) selectedItemTextRef.current = textRef.current;
+        }
+    }, [
+        hasRegistered,
+        index,
+        multiple,
+        isItemEqualToValue,
+        store,
+        itemValue,
+        selectedItemTextRef
+    ]);
+    const lastKeyRef = __rspack_external_react.useRef(null);
+    const pointerTypeRef = __rspack_external_react.useRef('mouse');
+    const allowMouseSelectionRef = __rspack_external_react.useRef(false);
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        focusableWhenDisabled: true,
+        native: nativeButton,
+        composite: true
+    });
+    const state = {
+        disabled,
+        selected,
+        highlighted
+    };
+    function commitSelection(event) {
+        const selectedValue = store.state.value;
+        if (multiple) {
+            const currentValue = Array.isArray(selectedValue) ? selectedValue : [];
+            const nextValue = selected ? removeItem(currentValue, itemValue, isItemEqualToValue) : [
+                ...currentValue,
+                itemValue
+            ];
+            setValue(nextValue, createChangeEventDetails(itemPress, event));
+        } else {
+            setValue(itemValue, createChangeEventDetails(itemPress, event));
+            setOpen(false, createChangeEventDetails(itemPress, event));
+        }
+    }
+    function resetDragMovement() {
+        selectionRef.current.dragY = 0;
+    }
+    const defaultProps = {
+        role: 'option',
+        'aria-selected': selected,
+        tabIndex: highlighted ? 0 : -1,
+        onKeyDown (event) {
+            lastKeyRef.current = event.key;
+            store.set('activeIndex', index);
+            if (' ' === event.key && typingRef.current) event.preventDefault();
+        },
+        onClick (event) {
+            const isMouseClick = 'click' === event.type && 'touch' !== pointerTypeRef.current;
+            const clickPointerType = event.nativeEvent.pointerType;
+            const isVirtualMouseClick = isMouseClick && isVirtualClick(event.nativeEvent) && (void 0 !== clickPointerType || highlighted);
+            const isInvalidMouseClick = isMouseClick && !isVirtualMouseClick && !allowMouseSelectionRef.current;
+            allowMouseSelectionRef.current = false;
+            if ('keydown' === event.type && null === lastKeyRef.current) return;
+            if (disabled || 'keydown' === event.type && ' ' === lastKeyRef.current && typingRef.current || isInvalidMouseClick) return;
+            lastKeyRef.current = null;
+            commitSelection(event.nativeEvent);
+        },
+        onPointerEnter (event) {
+            pointerTypeRef.current = event.pointerType;
+        },
+        onPointerMove (event) {
+            if ('mouse' === event.pointerType && 1 === event.buttons) {
+                const selection = selectionRef.current;
+                selection.dragY += event.movementY;
+                if (selection.dragY ** 2 >= 64) selection.allowUnselectedMouseUp = true;
+            }
+        },
+        onPointerDown (event) {
+            pointerTypeRef.current = event.pointerType;
+            allowMouseSelectionRef.current = true;
+            resetDragMovement();
+        },
+        onMouseUp () {
+            resetDragMovement();
+            if (disabled || 'touch' === pointerTypeRef.current) return;
+            if (allowMouseSelectionRef.current) return;
+            const disallowSelectedMouseUp = !selectionRef.current.allowSelectedMouseUp && selected;
+            const disallowUnselectedMouseUp = !selectionRef.current.allowUnselectedMouseUp && !selected;
+            if (disallowSelectedMouseUp || disallowUnselectedMouseUp) return;
+            allowMouseSelectionRef.current = true;
+            itemRef.current?.click();
+            allowMouseSelectionRef.current = false;
+        }
+    };
+    const element = useRenderElement('div', componentProps, {
+        ref: [
+            buttonRef,
+            forwardedRef,
+            listItem.ref,
+            itemRef
+        ],
+        state,
+        props: [
+            itemProps,
+            defaultProps,
+            elementProps,
+            getButtonProps
+        ]
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            selected,
+            index,
+            textRef,
+            selectedByFocus,
+            hasRegistered
+        }), [
+        selected,
+        index,
+        textRef,
+        selectedByFocus,
+        hasRegistered
+    ]);
+    return /*#__PURE__*/ jsx(SelectItemContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+}));
+if ("production" !== process.env.NODE_ENV) SelectItem_SelectItem.displayName = "SelectItem";
+const SelectItemIndicator_SelectItemIndicator = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const keepMounted = componentProps.keepMounted ?? false;
+    const { selected } = useSelectItemContext();
+    const shouldRender = keepMounted || selected;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(Inner, {
+        ...componentProps,
+        ref: forwardedRef
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectItemIndicator_SelectItemIndicator.displayName = "SelectItemIndicator";
+const Inner = /*#__PURE__*/ __rspack_external_react.memo(/*#__PURE__*/ __rspack_external_react.forwardRef((componentProps, forwardedRef)=>{
+    const { render, className, style, keepMounted, ...elementProps } = componentProps;
+    const { selected } = useSelectItemContext();
+    const indicatorRef = __rspack_external_react.useRef(null);
+    const { transitionStatus, setMounted } = useTransitionStatus(selected);
+    const state = {
+        selected,
+        transitionStatus
+    };
+    const element = useRenderElement('span', componentProps, {
+        ref: [
+            forwardedRef,
+            indicatorRef
+        ],
+        state,
+        props: [
+            {
+                'aria-hidden': true,
+                children: '✔️'
+            },
+            elementProps
+        ],
+        stateAttributesMapping: transitionStatusMapping
+    });
+    useOpenChangeComplete({
+        open: selected,
+        ref: indicatorRef,
+        onComplete () {
+            if (!selected) setMounted(false);
+        }
+    });
+    return element;
+}));
+if ("production" !== process.env.NODE_ENV) Inner.displayName = "Inner";
+const SelectItemText_SelectItemText = /*#__PURE__*/ __rspack_external_react.memo(/*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { index, textRef, selectedByFocus, hasRegistered } = useSelectItemContext();
+    const { firstItemTextRef, selectedItemTextRef } = useSelectRootContext();
+    const { render, className, style, ...elementProps } = componentProps;
+    const localRef = __rspack_external_react.useCallback((node)=>{
+        if (!node) return;
+        if (hasRegistered && 0 === index) firstItemTextRef.current = node;
+        if (hasRegistered && selectedByFocus) selectedItemTextRef.current = node;
+    }, [
+        firstItemTextRef,
+        selectedItemTextRef,
+        index,
+        selectedByFocus,
+        hasRegistered
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        ref: [
+            localRef,
+            forwardedRef,
+            textRef
+        ],
+        props: elementProps
+    });
+    return element;
+}));
+if ("production" !== process.env.NODE_ENV) SelectItemText_SelectItemText.displayName = "SelectItemText";
+const SelectArrow_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const SelectArrow_SelectArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { store } = useSelectRootContext();
+    const { side, align, arrowRef, arrowStyles, arrowUncentered, alignItemWithTriggerActive } = useSelectPositionerContext();
+    const open = useStore(store, selectors.open, true);
+    const state = {
+        open,
+        side,
+        align,
+        uncentered: arrowUncentered
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            arrowRef,
+            forwardedRef
+        ],
+        props: [
+            {
+                style: arrowStyles,
+                'aria-hidden': true
+            },
+            elementProps
+        ],
+        stateAttributesMapping: SelectArrow_stateAttributesMapping
+    });
+    if (alignItemWithTriggerActive) return null;
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) SelectArrow_SelectArrow.displayName = "SelectArrow";
+const SelectScrollArrow_SelectScrollArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, direction, keepMounted = false, ...elementProps } = componentProps;
+    const isUp = 'up' === direction;
+    const { store, popupRef, listRef, handleScrollArrowVisibility, scrollArrowsMountedCountRef } = useSelectRootContext();
+    const { side, scrollDownArrowRef, scrollUpArrowRef } = useSelectPositionerContext();
+    const visibleSelector = isUp ? selectors.scrollUpArrowVisible : selectors.scrollDownArrowVisible;
+    const stateVisible = useStore(store, visibleSelector);
+    const openMethod = useStore(store, selectors.openMethod);
+    const visible = stateVisible && 'touch' !== openMethod;
+    const timeout = useTimeout();
+    const scrollArrowRef = isUp ? scrollUpArrowRef : scrollDownArrowRef;
+    const { transitionStatus, setMounted } = useTransitionStatus(visible);
+    useIsoLayoutEffect(()=>{
+        scrollArrowsMountedCountRef.current += 1;
+        if (!store.state.hasScrollArrows) store.set('hasScrollArrows', true);
+        return ()=>{
+            scrollArrowsMountedCountRef.current = Math.max(0, scrollArrowsMountedCountRef.current - 1);
+            if (0 === scrollArrowsMountedCountRef.current && store.state.hasScrollArrows) store.set('hasScrollArrows', false);
+        };
+    }, [
+        store,
+        scrollArrowsMountedCountRef
+    ]);
+    useOpenChangeComplete({
+        open: visible,
+        ref: scrollArrowRef,
+        onComplete () {
+            if (!visible) setMounted(false);
+        }
+    });
+    const state = {
+        direction,
+        visible,
+        side,
+        transitionStatus
+    };
+    const defaultProps = {
+        'aria-hidden': true,
+        children: isUp ? '▲' : '▼',
+        style: {
+            position: 'absolute'
+        },
+        onMouseMove (event) {
+            if (0 === event.movementX && 0 === event.movementY || timeout.isStarted()) return;
+            store.set('activeIndex', null);
+            function scrollNextItem() {
+                const scroller = store.state.listElement ?? popupRef.current;
+                if (!scroller) return;
+                store.set('activeIndex', null);
+                handleScrollArrowVisibility();
+                const maxScrollTop = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+                const scrollTop = normalizeScrollOffset(scroller.scrollTop, maxScrollTop);
+                const isScrolledToEdge = scrollTop === (isUp ? 0 : maxScrollTop);
+                const items = listRef.current;
+                if (scrollTop !== scroller.scrollTop) scroller.scrollTop = scrollTop;
+                if (0 === items.length) store.set(isUp ? 'scrollUpArrowVisible' : 'scrollDownArrowVisible', !isScrolledToEdge);
+                if (isScrolledToEdge) return void timeout.clear();
+                if (items.length > 0) {
+                    const scrollArrowHeight = scrollArrowRef.current?.offsetHeight || 0;
+                    scroller.scrollTop = getTargetScrollTop(items, isUp, scrollTop, scroller.clientHeight, scrollArrowHeight, maxScrollTop);
+                }
+                timeout.start(40, scrollNextItem);
+            }
+            timeout.start(40, scrollNextItem);
+        },
+        onMouseLeave () {
+            timeout.clear();
+        }
+    };
+    const element = useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            scrollArrowRef
+        ],
+        state,
+        props: [
+            defaultProps,
+            elementProps
+        ]
+    });
+    const shouldRender = visible || keepMounted;
+    if (!shouldRender) return null;
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) SelectScrollArrow_SelectScrollArrow.displayName = "SelectScrollArrow";
+function getTargetScrollTop(items, isUp, scrollTop, clientHeight, scrollArrowHeight, maxScrollTop) {
+    if (isUp) {
+        let firstVisibleIndex = 0;
+        const visibleTop = scrollTop + scrollArrowHeight - 1;
+        for(let i = 0; i < items.length; i += 1){
+            const item = items[i];
+            if (item && item.offsetTop >= visibleTop) {
+                firstVisibleIndex = i;
+                break;
+            }
+        }
+        const targetIndex = Math.max(0, firstVisibleIndex - 1);
+        const targetItem = items[targetIndex];
+        return targetIndex < firstVisibleIndex && targetItem ? normalizeScrollOffset(targetItem.offsetTop - scrollArrowHeight, maxScrollTop) : 0;
+    }
+    let lastVisibleIndex = items.length - 1;
+    const visibleBottom = scrollTop + clientHeight - scrollArrowHeight + 1;
+    for(let i = 0; i < items.length; i += 1){
+        const item = items[i];
+        if (item && item.offsetTop + item.offsetHeight > visibleBottom) {
+            lastVisibleIndex = Math.max(0, i - 1);
+            break;
+        }
+    }
+    const targetIndex = Math.min(items.length - 1, lastVisibleIndex + 1);
+    const targetItem = items[targetIndex];
+    return targetIndex > lastVisibleIndex && targetItem ? normalizeScrollOffset(targetItem.offsetTop + targetItem.offsetHeight - clientHeight + scrollArrowHeight, maxScrollTop) : maxScrollTop;
+}
+const SelectScrollDownArrow_SelectScrollDownArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    return /*#__PURE__*/ jsx(SelectScrollArrow_SelectScrollArrow, {
+        ...props,
+        ref: forwardedRef,
+        direction: "down"
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectScrollDownArrow_SelectScrollDownArrow.displayName = "SelectScrollDownArrow";
+const SelectScrollUpArrow_SelectScrollUpArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    return /*#__PURE__*/ jsx(SelectScrollArrow_SelectScrollArrow, {
+        ...props,
+        ref: forwardedRef,
+        direction: "up"
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectScrollUpArrow_SelectScrollUpArrow.displayName = "SelectScrollUpArrow";
+const SelectGroupContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) SelectGroupContext.displayName = "SelectGroupContext";
+function useSelectGroupContext() {
+    const context = __rspack_external_react.useContext(SelectGroupContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: SelectGroupContext is missing. SelectGroup parts must be placed within <Select.Group>.' : esm_formatErrorMessage(56));
+    return context;
+}
+const SelectGroup_SelectGroup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const [labelId, setLabelId] = __rspack_external_react.useState();
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            labelId,
+            setLabelId
+        }), [
+        labelId,
+        setLabelId
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                role: 'group',
+                'aria-labelledby': labelId
+            },
+            elementProps
+        ]
+    });
+    return /*#__PURE__*/ jsx(SelectGroupContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectGroup_SelectGroup.displayName = "SelectGroup";
+const SelectGroupLabel_SelectGroupLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { setLabelId } = useSelectGroupContext();
+    const id = useBaseUiId(idProp);
+    useIsoLayoutEffect(()=>{
+        setLabelId(id);
+    }, [
+        id,
+        setLabelId
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                id
+            },
+            elementProps
+        ]
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) SelectGroupLabel_SelectGroupLabel.displayName = "SelectGroupLabel";
+function SelectRoot(props) {
+    const { id, value: valueProp, defaultValue = null, onValueChange, open: openProp, defaultOpen = false, onOpenChange, name: nameProp, form, autoComplete, disabled: disabledProp = false, readOnly = false, required = false, modal = true, actionsRef, inputRef, onOpenChangeComplete, items, multiple = false, itemToStringLabel, itemToStringValue, isItemEqualToValue = defaultItemEquality, highlightItemOnHover = true, children } = props;
+    const { clearErrors } = useFormContext();
+    const { setDirty, setTouched, setFocused, shouldValidateOnChange, validityData, setFilled, name: fieldName, disabled: fieldDisabled, validation, validationMode } = useFieldRootContext();
+    const generatedId = useLabelableId({
+        id
+    });
+    const disabled = fieldDisabled || disabledProp;
+    const name = fieldName ?? nameProp;
+    const [value, setValueUnwrapped] = useControlled({
+        controlled: valueProp,
+        default: multiple ? defaultValue ?? EMPTY_ARRAY : defaultValue,
+        name: 'Select',
+        state: 'value'
+    });
+    const [open, setOpenUnwrapped] = useControlled({
+        controlled: openProp,
+        default: defaultOpen,
+        name: 'Select',
+        state: 'open'
+    });
+    const listRef = __rspack_external_react.useRef([]);
+    const labelsRef = __rspack_external_react.useRef([]);
+    const popupRef = __rspack_external_react.useRef(null);
+    const scrollHandlerRef = __rspack_external_react.useRef(null);
+    const scrollArrowsMountedCountRef = __rspack_external_react.useRef(0);
+    const valueRef = __rspack_external_react.useRef(null);
+    const valuesRef = __rspack_external_react.useRef([]);
+    const typingRef = __rspack_external_react.useRef(false);
+    const keyboardActiveRef = __rspack_external_react.useRef(false);
+    const firstItemTextRef = __rspack_external_react.useRef(null);
+    const selectedItemTextRef = __rspack_external_react.useRef(null);
+    const selectionRef = __rspack_external_react.useRef({
+        allowSelectedMouseUp: false,
+        allowUnselectedMouseUp: false,
+        dragY: 0
+    });
+    const alignItemWithTriggerActiveRef = __rspack_external_react.useRef(false);
+    const { mounted, setMounted, transitionStatus } = useTransitionStatus(open);
+    const { openMethod, triggerProps: interactionTypeProps } = useOpenInteractionType(open);
+    const store = useRefWithInit(()=>new Store({
+            id: generatedId,
+            labelId: void 0,
+            modal,
+            multiple,
+            itemToStringLabel,
+            itemToStringValue,
+            isItemEqualToValue,
+            value,
+            open,
+            mounted,
+            transitionStatus,
+            items,
+            forceMount: false,
+            openMethod: null,
+            activeIndex: null,
+            selectedIndex: null,
+            popupProps: {},
+            triggerProps: {},
+            triggerElement: null,
+            positionerElement: null,
+            listElement: null,
+            popupSide: null,
+            scrollUpArrowVisible: false,
+            scrollDownArrowVisible: false,
+            hasScrollArrows: false
+        })).current;
+    const activeIndex = useStore(store, selectors.activeIndex);
+    const selectedIndex = useStore(store, selectors.selectedIndex);
+    const triggerElement = useStore(store, selectors.triggerElement);
+    const positionerElement = useStore(store, selectors.positionerElement);
+    const previousOpenMethod = usePreviousValue(openMethod);
+    const renderedOpenMethod = openMethod ?? previousOpenMethod;
+    const serializedValue = __rspack_external_react.useMemo(()=>{
+        if (multiple && Array.isArray(value) && 0 === value.length) return '';
+        return stringifyAsValue(value, itemToStringValue);
+    }, [
+        multiple,
+        value,
+        itemToStringValue
+    ]);
+    const fieldStringValue = __rspack_external_react.useMemo(()=>{
+        if (multiple && Array.isArray(value)) return value.map((currentValue)=>stringifyAsValue(currentValue, itemToStringValue));
+        return stringifyAsValue(value, itemToStringValue);
+    }, [
+        multiple,
+        value,
+        itemToStringValue
+    ]);
+    const controlRef = useValueAsRef(store.state.triggerElement);
+    const getStringifiedValueForForm = useStableCallback(()=>fieldStringValue);
+    useRegisterFieldControl(controlRef, generatedId, value, getStringifiedValueForForm);
+    const initialValueRef = __rspack_external_react.useRef(value);
+    const hasSelectedValue = multiple ? Array.isArray(value) && value.length > 0 : null != value;
+    useIsoLayoutEffect(()=>{
+        if (value !== initialValueRef.current) store.set('forceMount', true);
+    }, [
+        store,
+        value
+    ]);
+    useIsoLayoutEffect(()=>{
+        setFilled(hasSelectedValue);
+    }, [
+        hasSelectedValue,
+        setFilled
+    ]);
+    useIsoLayoutEffect(function() {
+        const registry = valuesRef.current;
+        let nextIndex;
+        if (multiple) {
+            const currentValue = Array.isArray(value) ? value : [];
+            if (0 === currentValue.length) nextIndex = null;
+            else {
+                const lastValue = currentValue[currentValue.length - 1];
+                const lastIndex = findItemIndex(registry, lastValue, isItemEqualToValue);
+                nextIndex = -1 === lastIndex ? null : lastIndex;
+            }
+        } else {
+            const index = findItemIndex(registry, value, isItemEqualToValue);
+            nextIndex = -1 === index ? null : index;
+        }
+        if (null === nextIndex) selectedItemTextRef.current = null;
+        if (open) return;
+        store.set('selectedIndex', nextIndex);
+    }, [
+        hasSelectedValue,
+        multiple,
+        open,
+        value,
+        valuesRef,
+        isItemEqualToValue,
+        store,
+        selectedItemTextRef
+    ]);
+    useValueChanged(value, ()=>{
+        clearErrors(name);
+        setDirty(value !== validityData.initialValue);
+        if (shouldValidateOnChange()) validation.commit(value);
+        else validation.commit(value, true);
+    });
+    const setOpen = useStableCallback((nextOpen, eventDetails)=>{
+        onOpenChange?.(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        setOpenUnwrapped(nextOpen);
+        if (!nextOpen && (eventDetails.reason === focusOut || eventDetails.reason === outsidePress)) {
+            setTouched(true);
+            setFocused(false);
+            if ('onBlur' === validationMode) validation.commit(value);
+        }
+        if (!nextOpen && null !== store.state.activeIndex) {
+            const activeOption = listRef.current[store.state.activeIndex];
+            queueMicrotask(()=>{
+                activeOption?.setAttribute('tabindex', '-1');
+            });
+        }
+    });
+    const handleUnmount = useStableCallback(()=>{
+        setMounted(false);
+        store.update({
+            activeIndex: null,
+            openMethod: null
+        });
+        onOpenChangeComplete?.(false);
+    });
+    useOpenChangeComplete({
+        enabled: !actionsRef,
+        open,
+        ref: popupRef,
+        onComplete () {
+            if (!open) handleUnmount();
+        }
+    });
+    __rspack_external_react.useImperativeHandle(actionsRef, ()=>({
+            unmount: handleUnmount
+        }), [
+        handleUnmount
+    ]);
+    const setValue = useStableCallback((nextValue, eventDetails)=>{
+        onValueChange?.(nextValue, eventDetails);
+        if (eventDetails.isCanceled) return;
+        setValueUnwrapped(nextValue);
+    });
+    const handleScrollArrowVisibility = useStableCallback(()=>{
+        const scroller = store.state.listElement || popupRef.current;
+        if (!scroller) return;
+        const maxScrollTop = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+        const scrollTop = normalizeScrollOffset(scroller.scrollTop, maxScrollTop);
+        const shouldShowUp = scrollTop > 0;
+        const shouldShowDown = scrollTop < maxScrollTop;
+        if (store.state.scrollUpArrowVisible !== shouldShowUp) store.set('scrollUpArrowVisible', shouldShowUp);
+        if (store.state.scrollDownArrowVisible !== shouldShowDown) store.set('scrollDownArrowVisible', shouldShowDown);
+    });
+    const floatingContext = useFloatingRootContext({
+        open,
+        onOpenChange: setOpen,
+        elements: {
+            reference: triggerElement,
+            floating: positionerElement
+        }
+    });
+    const click = useClick(floatingContext, {
+        enabled: !readOnly && !disabled,
+        event: 'mousedown'
+    });
+    const dismiss = useDismiss(floatingContext);
+    const listNavigation = useListNavigation(floatingContext, {
+        enabled: !readOnly && !disabled,
+        listRef,
+        activeIndex,
+        selectedIndex,
+        disabledIndices: EMPTY_ARRAY,
+        onNavigate (nextActiveIndex) {
+            if (null === nextActiveIndex && !open) return;
+            store.set('activeIndex', nextActiveIndex);
+        },
+        focusItemOnHover: highlightItemOnHover
+    });
+    const typeahead = useTypeahead(floatingContext, {
+        enabled: !readOnly && !disabled && (open || !multiple),
+        listRef: labelsRef,
+        activeIndex,
+        selectedIndex,
+        onMatch (index) {
+            if (open) store.set('activeIndex', index);
+            else setValue(valuesRef.current[index], createChangeEventDetails('none'));
+        },
+        onTyping (typing) {
+            typingRef.current = typing;
+        }
+    });
+    const mergedTriggerProps = __rspack_external_react.useMemo(()=>{
+        const triggerInteractionProps = mergeProps(typeahead.reference, listNavigation.reference, dismiss.reference, click.reference, interactionTypeProps);
+        if (generatedId) triggerInteractionProps.id = generatedId;
+        return triggerInteractionProps;
+    }, [
+        click.reference,
+        typeahead.reference,
+        listNavigation.reference,
+        dismiss.reference,
+        interactionTypeProps,
+        generatedId
+    ]);
+    const popupProps = __rspack_external_react.useMemo(()=>mergeProps(FOCUSABLE_POPUP_PROPS, typeahead.floating, listNavigation.floating, dismiss.floating), [
+        typeahead.floating,
+        listNavigation.floating,
+        dismiss.floating
+    ]);
+    const itemProps = listNavigation.item ?? EMPTY_OBJECT;
+    useOnFirstRender(()=>{
+        store.update({
+            popupProps,
+            triggerProps: mergedTriggerProps
+        });
+    });
+    useIsoLayoutEffect(()=>{
+        store.update({
+            id: generatedId,
+            modal,
+            multiple,
+            value,
+            open,
+            mounted,
+            transitionStatus,
+            popupProps,
+            triggerProps: mergedTriggerProps,
+            items,
+            itemToStringLabel,
+            itemToStringValue,
+            isItemEqualToValue,
+            openMethod: renderedOpenMethod
+        });
+    }, [
+        store,
+        generatedId,
+        modal,
+        multiple,
+        value,
+        open,
+        mounted,
+        transitionStatus,
+        popupProps,
+        mergedTriggerProps,
+        items,
+        itemToStringLabel,
+        itemToStringValue,
+        isItemEqualToValue,
+        renderedOpenMethod
+    ]);
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            store,
+            name,
+            required,
+            disabled,
+            readOnly,
+            multiple,
+            highlightItemOnHover,
+            setValue,
+            setOpen,
+            listRef,
+            popupRef,
+            scrollHandlerRef,
+            handleScrollArrowVisibility,
+            scrollArrowsMountedCountRef,
+            itemProps,
+            events: floatingContext.context.events,
+            valueRef,
+            valuesRef,
+            labelsRef,
+            typingRef,
+            selectionRef,
+            firstItemTextRef,
+            selectedItemTextRef,
+            validation,
+            onOpenChangeComplete,
+            keyboardActiveRef,
+            alignItemWithTriggerActiveRef,
+            initialValueRef
+        }), [
+        store,
+        name,
+        required,
+        disabled,
+        readOnly,
+        multiple,
+        highlightItemOnHover,
+        setValue,
+        setOpen,
+        itemProps,
+        floatingContext.context.events,
+        validation,
+        onOpenChangeComplete,
+        handleScrollArrowVisibility
+    ]);
+    const ref = useMergedRefs(inputRef, validation.inputRef);
+    const hasMultipleSelection = multiple && Array.isArray(value) && value.length > 0;
+    const hiddenInputName = multiple ? void 0 : name;
+    const hiddenInputs = __rspack_external_react.useMemo(()=>{
+        if (!multiple || !Array.isArray(value) || !name) return null;
+        return value.map((v)=>{
+            const currentSerializedValue = stringifyAsValue(v, itemToStringValue);
+            return /*#__PURE__*/ jsx("input", {
+                type: "hidden",
+                form: form,
+                name: name,
+                value: currentSerializedValue
+            }, currentSerializedValue);
+        });
+    }, [
+        multiple,
+        value,
+        form,
+        name,
+        itemToStringValue
+    ]);
+    return /*#__PURE__*/ jsx(SelectRootContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsxs(SelectFloatingContext.Provider, {
+            value: floatingContext,
+            children: [
+                children,
+                /*#__PURE__*/ jsx("input", {
+                    ...validation.getInputValidationProps({
+                        onFocus () {
+                            store.state.triggerElement?.focus({
+                                focusVisible: true
+                            });
+                        },
+                        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;
+                                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);
+                                    setValue(matchingValue, details);
+                                    if (shouldValidateOnChange()) validation.commit(matchingValue);
+                                }
+                            }
+                            store.set('forceMount', true);
+                            queueMicrotask(handleChange);
+                        }
+                    }),
+                    id: generatedId && null == hiddenInputName ? `${generatedId}-hidden-input` : void 0,
+                    form: form,
+                    name: hiddenInputName,
+                    autoComplete: autoComplete,
+                    value: serializedValue,
+                    disabled: disabled,
+                    required: required && !hasMultipleSelection,
+                    readOnly: readOnly,
+                    ref: ref,
+                    style: name ? visuallyHiddenInput : visuallyHidden,
+                    tabIndex: -1,
+                    "aria-hidden": true,
+                    suppressHydrationWarning: true
+                }),
+                hiddenInputs
+            ]
+        })
+    });
+}
+const SelectPortalContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) SelectPortalContext.displayName = "SelectPortalContext";
+const SelectPortal_SelectPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(portalProps, forwardedRef) {
+    const { store } = useSelectRootContext();
+    const mounted = useStore(store, selectors.mounted);
+    const forceMount = useStore(store, selectors.forceMount);
+    const shouldRender = mounted || forceMount;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(SelectPortalContext.Provider, {
+        value: true,
+        children: /*#__PURE__*/ jsx(FloatingPortal_FloatingPortal, {
+            ref: forwardedRef,
+            ...portalProps
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) SelectPortal_SelectPortal.displayName = "SelectPortal";
 const Select_module = {
     label: "label-UrIm_f",
     trigger: "trigger-UPubf5",
@@ -17,87 +1818,87 @@ const Select_module = {
     scrollUpArrow: "scrollUpArrow-P67Eti",
     groupLabel: "groupLabel-GC3RgN"
 };
-const Label = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Label, {
+const Label = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectLabel_SelectLabel, {
         ref: ref,
         className: clsx(Select_module.label, className),
         ...props
     }));
-const Trigger = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Trigger, {
+const Trigger = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectTrigger_SelectTrigger, {
         ref: ref,
         className: clsx(Select_module.trigger, className),
         ...props
     }));
-const Value = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Value, {
+const Value = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectValue_SelectValue, {
         ref: ref,
         className: clsx(Select_module.value, className),
         ...props
     }));
-const Icon = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Icon, {
+const Icon = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectIcon_SelectIcon, {
         ref: ref,
         className: clsx(Select_module.icon, className),
         ...props
     }));
-const Backdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Backdrop, {
+const Backdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectBackdrop_SelectBackdrop, {
         ref: ref,
         className: clsx(Select_module.backdrop, className),
         ...props
     }));
-const Positioner = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Positioner, {
+const Positioner = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectPositioner_SelectPositioner, {
         ref: ref,
         className: clsx(Select_module.positioner, className),
         ...props
     }));
-const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Popup, {
+const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectPopup_SelectPopup, {
         ref: ref,
         className: clsx(Select_module.popup, className),
         ...props
     }));
-const List = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.List, {
+const List = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectList_SelectList, {
         ref: ref,
         className: clsx(Select_module.list, className),
         ...props
     }));
-const Item = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Item, {
+const Item = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectItem_SelectItem, {
         ref: ref,
         className: clsx(Select_module.item, className),
         ...props
     }));
-const ItemIndicator = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.ItemIndicator, {
+const ItemIndicator = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectItemIndicator_SelectItemIndicator, {
         ref: ref,
         className: clsx(Select_module.itemIndicator, className),
         ...props
     }));
-const ItemText = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.ItemText, {
+const ItemText = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectItemText_SelectItemText, {
         ref: ref,
         className: clsx(Select_module.itemText, className),
         ...props
     }));
-const Arrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Arrow, {
+const Arrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectArrow_SelectArrow, {
         ref: ref,
         className: clsx(Select_module.arrow, className),
         ...props
     }));
-const ScrollDownArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.ScrollDownArrow, {
+const ScrollDownArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectScrollDownArrow_SelectScrollDownArrow, {
         ref: ref,
         className: clsx(Select_module.scrollDownArrow, className),
         ...props
     }));
-const ScrollUpArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.ScrollUpArrow, {
+const ScrollUpArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectScrollUpArrow_SelectScrollUpArrow, {
         ref: ref,
         className: clsx(Select_module.scrollUpArrow, className),
         ...props
     }));
-const Group = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.Group, {
+const Group = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectGroup_SelectGroup, {
         ref: ref,
         className: clsx(Select_module.group, className),
         ...props
     }));
-const GroupLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Select.GroupLabel, {
+const GroupLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(SelectGroupLabel_SelectGroupLabel, {
         ref: ref,
         className: clsx(Select_module.groupLabel, className),
         ...props
     }));
-const Select_Select = {
+const Select = {
     Label: Label,
     Trigger: Trigger,
     Value: Value,
@@ -114,8 +1915,8 @@ const Select_Select = {
     ScrollUpArrow: ScrollUpArrow,
     Group: Group,
     GroupLabel: GroupLabel,
-    Root: Select.Root,
-    Portal: Select.Portal,
-    Separator: Select.Separator
+    Root: SelectRoot,
+    Portal: SelectPortal_SelectPortal,
+    Separator: Separator
 };
-export { Select_Select as Select };
+export { Select };