@wix/site-ui 1.30.0 → 1.32.0

package/dist/6882.js

@@ -0,0 +1,1562 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { EMPTY_OBJECT, EMPTY_ARRAY, useMergedRefs, useRefWithInit, warn, mergeProps, useRenderElement, esm_formatErrorMessage } from "./8272.js";
+import { isLastTraversableNode, getParentNode, isHTMLElement } from "./3829.js";
+import { DROPDOWN_COLLISION_AVOIDANCE, triggerOpenStateMapping, FloatingPortal_FloatingPortal, popupStateMapping, POPUP_COLLISION_AVOIDANCE } from "./4388.js";
+import { useAnimationsFinished, useTransitionStatus, transitionStatusMapping, useOpenChangeComplete } from "./880.js";
+import { itemPress, siblingOpen, outsidePress, imperativeAction, triggerFocus, focusOut, listNavigation as reason_parts_listNavigation, triggerHover, triggerPress, escapeKey } from "./2418.js";
+import { usePositioner, adaptiveOriginMiddleware_adaptiveOrigin, useAnchorPositioning, getDisabledMountTransitionStyles } from "./8750.js";
+import { createChangeEventDetails } from "./4768.js";
+import { useTimeout } from "./42.js";
+import { useIsoLayoutEffect, SafeReact } from "./6499.js";
+import { useAnchoredPopupScrollLock } from "./6247.js";
+import { useOpenInteractionType, FloatingFocusManager, InternalBackdrop_InternalBackdrop } from "./3485.js";
+import { inertValue } from "./167.js";
+import { useFloatingParentNodeId, FloatingNode, FloatingTree, useFloatingNodeId, FloatingTreeStore } from "./285.js";
+import { CompositeList } from "./9255.js";
+import { useToolbarRootContext } from "./6107.js";
+import { useHoverFloatingInteraction } from "./3056.js";
+import { COMPOSITE_KEYS } from "./1500.js";
+import { useBaseUiId, useId } from "./6046.js";
+import { isMac } from "./8971.js";
+import { useButton } from "./9189.js";
+import { useCompositeListItem } from "./3021.js";
+import { useControlled } from "./8527.js";
+import { useStableCallback } from "./7541.js";
+import { useSyncedFloatingRootContext, useTriggerRegistration, useImplicitActiveTrigger, useOpenStateTransitions, usePopupInteractionProps, FOCUSABLE_POPUP_PROPS, useOnFirstRender } from "./8106.js";
+import { isElementDisabled } from "./3140.js";
+import { safePolygon, useHoverReferenceInteraction } from "./3670.js";
+import { useClick } from "./5864.js";
+import { popupStoreSelectors, createInitialPopupStoreState } from "./6535.js";
+import { useDismiss, PopupTriggerMap, createSelector, fastComponent, ReactStore } from "./5992.js";
+import { useMenubarContext } from "./7564.js";
+import { useDirection } from "./9863.js";
+import { useListNavigation, useTypeahead } from "./5299.js";
+import * as __rspack_external_react from "react";
+const ContextMenuRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ContextMenuRootContext.displayName = "ContextMenuRootContext";
+function useContextMenuRootContext(optional = true) {
+    const context = __rspack_external_react.useContext(ContextMenuRootContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ContextMenuRootContext is missing. ContextMenu parts must be placed within <ContextMenu.Root>.' : esm_formatErrorMessage(25));
+    return context;
+}
+const MenuRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuRootContext.displayName = "MenuRootContext";
+function useMenuRootContext(optional) {
+    const context = __rspack_external_react.useContext(MenuRootContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>.' : esm_formatErrorMessage(36));
+    return context;
+}
+function findRootOwnerId(node) {
+    if (isHTMLElement(node) && node.hasAttribute('data-rootownerid')) return node.getAttribute('data-rootownerid') ?? void 0;
+    if (isLastTraversableNode(node)) return;
+    return findRootOwnerId(getParentNode(node));
+}
+const stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const MenuBackdrop_MenuBackdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { store } = useMenuRootContext();
+    const open = store.useState('open');
+    const mounted = store.useState('mounted');
+    const transitionStatus = store.useState('transitionStatus');
+    const lastOpenChangeReason = store.useState('lastOpenChangeReason');
+    const contextMenuContext = useContextMenuRootContext();
+    const state = {
+        open,
+        transitionStatus
+    };
+    return useRenderElement('div', componentProps, {
+        ref: contextMenuContext?.backdropRef ? [
+            forwardedRef,
+            contextMenuContext.backdropRef
+        ] : forwardedRef,
+        state,
+        stateAttributesMapping: stateAttributesMapping,
+        props: [
+            {
+                role: 'presentation',
+                hidden: !mounted,
+                style: {
+                    pointerEvents: lastOpenChangeReason === triggerHover ? 'none' : void 0,
+                    userSelect: 'none',
+                    WebkitUserSelect: 'none'
+                }
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuBackdrop_MenuBackdrop.displayName = "MenuBackdrop";
+const MenuPositionerContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuPositionerContext.displayName = "MenuPositionerContext";
+function useMenuPositionerContext(optional) {
+    const context = __rspack_external_react.useContext(MenuPositionerContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenuPositionerContext is missing. MenuPositioner parts must be placed within <Menu.Positioner>.' : esm_formatErrorMessage(33));
+    return context;
+}
+const MenuPortalContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuPortalContext.displayName = "MenuPortalContext";
+function useMenuPortalContext() {
+    const value = __rspack_external_react.useContext(MenuPortalContext);
+    if (void 0 === value) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Menu.Portal> is missing.' : esm_formatErrorMessage(32));
+    return value;
+}
+const MenuPositioner_MenuPositioner = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { anchor: anchorProp, positionMethod: positionMethodProp = 'absolute', className, render, side, align: alignProp, sideOffset: sideOffsetProp = 0, alignOffset: alignOffsetProp = 0, collisionBoundary = 'clipping-ancestors', collisionPadding = 5, arrowPadding = 5, sticky = false, disableAnchorTracking = false, collisionAvoidance: collisionAvoidanceProp = DROPDOWN_COLLISION_AVOIDANCE, style, ...elementProps } = componentProps;
+    const { store } = useMenuRootContext();
+    const keepMounted = useMenuPortalContext();
+    const contextMenuContext = useContextMenuRootContext(true);
+    const parent = store.useState('parent');
+    const floatingRootContext = store.useState('floatingRootContext');
+    const floatingTreeRoot = store.useState('floatingTreeRoot');
+    const mounted = store.useState('mounted');
+    const open = store.useState('open');
+    const modal = store.useState('modal');
+    const openMethod = store.useState('openMethod');
+    const triggerElement = store.useState('activeTriggerElement');
+    const transitionStatus = store.useState('transitionStatus');
+    const positionerElement = store.useState('positionerElement');
+    const instantType = store.useState('instantType');
+    const hasViewport = store.useState('hasViewport');
+    const lastOpenChangeReason = store.useState('lastOpenChangeReason');
+    const floatingNodeId = store.useState('floatingNodeId');
+    const floatingParentNodeId = store.useState('floatingParentNodeId');
+    const domReference = floatingRootContext.useState('domReferenceElement');
+    const previousTriggerRef = __rspack_external_react.useRef(null);
+    const runOnceAnimationsFinish = useAnimationsFinished(positionerElement, false, false);
+    let anchor = anchorProp;
+    let sideOffset = sideOffsetProp;
+    let alignOffset = alignOffsetProp;
+    let align = alignProp;
+    let collisionAvoidance = collisionAvoidanceProp;
+    if ('context-menu' === parent.type) {
+        anchor = anchorProp ?? parent.context?.anchor;
+        align = align ?? 'start';
+        if (!side && 'center' !== align) {
+            alignOffset = componentProps.alignOffset ?? 2;
+            sideOffset = componentProps.sideOffset ?? -5;
+        }
+    }
+    let computedSide = side;
+    let computedAlign = align;
+    if ('menu' === parent.type) {
+        computedSide = computedSide ?? 'inline-end';
+        computedAlign = computedAlign ?? 'start';
+        collisionAvoidance = componentProps.collisionAvoidance ?? POPUP_COLLISION_AVOIDANCE;
+    } else if ('menubar' === parent.type) {
+        computedSide = computedSide ?? 'bottom';
+        computedAlign = computedAlign ?? 'start';
+    }
+    const contextMenu = 'context-menu' === parent.type;
+    const positioner = useAnchorPositioning({
+        anchor,
+        floatingRootContext,
+        positionMethod: contextMenuContext ? 'fixed' : positionMethodProp,
+        mounted,
+        side: computedSide,
+        sideOffset,
+        align: computedAlign,
+        alignOffset,
+        arrowPadding: contextMenu ? 0 : arrowPadding,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        nodeId: floatingNodeId,
+        keepMounted,
+        disableAnchorTracking,
+        collisionAvoidance,
+        shiftCrossAxis: contextMenu && !('side' in collisionAvoidance && 'flip' === collisionAvoidance.side),
+        externalTree: floatingTreeRoot,
+        adaptiveOrigin: hasViewport ? adaptiveOriginMiddleware_adaptiveOrigin : void 0
+    });
+    __rspack_external_react.useEffect(()=>{
+        function onMenuOpenChange(details) {
+            if (details.open) {
+                if (details.parentNodeId === floatingNodeId) store.set('hoverEnabled', false);
+                if (details.nodeId !== floatingNodeId && details.parentNodeId === store.select('floatingParentNodeId')) store.setOpen(false, createChangeEventDetails(siblingOpen));
+            }
+        }
+        floatingTreeRoot.events.on('menuopenchange', onMenuOpenChange);
+        return ()=>{
+            floatingTreeRoot.events.off('menuopenchange', onMenuOpenChange);
+        };
+    }, [
+        store,
+        floatingTreeRoot.events,
+        floatingNodeId
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (null == store.select('floatingParentNodeId')) return;
+        function onParentClose(details) {
+            if (details.open || details.nodeId !== store.select('floatingParentNodeId')) return;
+            const reason = details.reason ?? siblingOpen;
+            store.setOpen(false, createChangeEventDetails(reason));
+        }
+        floatingTreeRoot.events.on('menuopenchange', onParentClose);
+        return ()=>{
+            floatingTreeRoot.events.off('menuopenchange', onParentClose);
+        };
+    }, [
+        floatingTreeRoot.events,
+        store
+    ]);
+    const closeTimeout = useTimeout();
+    __rspack_external_react.useEffect(()=>{
+        if (!open) closeTimeout.clear();
+    }, [
+        open,
+        closeTimeout
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        function onItemHover(event) {
+            if (!open || event.nodeId !== store.select('floatingParentNodeId')) return;
+            if (event.target && triggerElement && triggerElement !== event.target) {
+                const delay = store.select('closeDelay');
+                if (delay > 0) {
+                    if (!closeTimeout.isStarted()) closeTimeout.start(delay, ()=>{
+                        store.setOpen(false, createChangeEventDetails(siblingOpen));
+                    });
+                } else store.setOpen(false, createChangeEventDetails(siblingOpen));
+            } else closeTimeout.clear();
+        }
+        floatingTreeRoot.events.on('itemhover', onItemHover);
+        return ()=>{
+            floatingTreeRoot.events.off('itemhover', onItemHover);
+        };
+    }, [
+        floatingTreeRoot.events,
+        open,
+        triggerElement,
+        store,
+        closeTimeout
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        const eventDetails = {
+            open,
+            nodeId: floatingNodeId,
+            parentNodeId: floatingParentNodeId,
+            reason: store.select('lastOpenChangeReason')
+        };
+        floatingTreeRoot.events.emit('menuopenchange', eventDetails);
+    }, [
+        floatingTreeRoot.events,
+        open,
+        store,
+        floatingNodeId,
+        floatingParentNodeId
+    ]);
+    useIsoLayoutEffect(()=>{
+        const currentTrigger = domReference;
+        const previousTrigger = previousTriggerRef.current;
+        if (currentTrigger) previousTriggerRef.current = currentTrigger;
+        if (previousTrigger && currentTrigger && currentTrigger !== previousTrigger) {
+            store.set('instantType', void 0);
+            const abortController = new AbortController();
+            runOnceAnimationsFinish(()=>{
+                store.set('instantType', 'trigger-change');
+            }, abortController.signal);
+            return ()=>{
+                abortController.abort();
+            };
+        }
+    }, [
+        domReference,
+        runOnceAnimationsFinish,
+        store
+    ]);
+    const state = {
+        open,
+        side: positioner.side,
+        align: positioner.align,
+        anchorHidden: positioner.anchorHidden,
+        nested: 'menu' === parent.type,
+        instant: instantType
+    };
+    const menubarModal = 'menubar' === parent.type && parent.context.modal;
+    const popupModal = modal && lastOpenChangeReason !== triggerHover;
+    useAnchoredPopupScrollLock(open && (menubarModal || popupModal), 'touch' === openMethod, positionerElement, triggerElement);
+    const element = usePositioner(componentProps, state, {
+        styles: positioner.positionerStyles,
+        transitionStatus,
+        props: elementProps,
+        refs: [
+            forwardedRef,
+            store.useStateSetter('positionerElement')
+        ],
+        hidden: !mounted,
+        inert: !open
+    });
+    const shouldRenderBackdrop = mounted && 'menu' !== parent.type && ('menubar' !== parent.type && modal && lastOpenChangeReason !== triggerHover || 'menubar' === parent.type && parent.context.modal);
+    let backdropCutout = null;
+    if ('menubar' === parent.type) backdropCutout = parent.context.contentElement;
+    else if (void 0 === parent.type) backdropCutout = triggerElement;
+    return /*#__PURE__*/ jsxs(MenuPositionerContext.Provider, {
+        value: positioner,
+        children: [
+            shouldRenderBackdrop && /*#__PURE__*/ jsx(InternalBackdrop_InternalBackdrop, {
+                ref: 'context-menu' === parent.type || 'nested-context-menu' === parent.type ? parent.context.internalBackdropRef : null,
+                inert: inertValue(!open),
+                cutout: backdropCutout
+            }),
+            /*#__PURE__*/ jsx(FloatingNode, {
+                id: floatingNodeId,
+                children: /*#__PURE__*/ jsx(CompositeList, {
+                    elementsRef: store.context.itemDomElements,
+                    labelsRef: store.context.itemLabels,
+                    children: element
+                })
+            })
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuPositioner_MenuPositioner.displayName = "MenuPositioner";
+const MenuPopup_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const MenuPopup_MenuPopup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, finalFocus, ...elementProps } = componentProps;
+    const { store } = useMenuRootContext();
+    const { side, align } = useMenuPositionerContext();
+    const insideToolbar = null != useToolbarRootContext(true);
+    const open = store.useState('open');
+    const transitionStatus = store.useState('transitionStatus');
+    const popupProps = store.useState('popupProps');
+    const mounted = store.useState('mounted');
+    const instantType = store.useState('instantType');
+    const triggerElement = store.useState('activeTriggerElement');
+    const parent = store.useState('parent');
+    const lastOpenChangeReason = store.useState('lastOpenChangeReason');
+    const rootId = store.useState('rootId');
+    const floatingContext = store.useState('floatingRootContext');
+    const floatingTreeRoot = store.useState('floatingTreeRoot');
+    const closeDelay = store.useState('closeDelay');
+    const activeTriggerElement = store.useState('activeTriggerElement');
+    const hoverEnabled = store.useState('hoverEnabled');
+    const disabled = store.useState('disabled');
+    const isContextMenu = 'context-menu' === parent.type;
+    useOpenChangeComplete({
+        open,
+        ref: store.context.popupRef,
+        onComplete () {
+            if (open) store.context.onOpenChangeComplete?.(true);
+        }
+    });
+    __rspack_external_react.useEffect(()=>{
+        function handleClose(event) {
+            store.setOpen(false, createChangeEventDetails(event.reason, event.domEvent));
+        }
+        floatingTreeRoot.events.on('close', handleClose);
+        return ()=>{
+            floatingTreeRoot.events.off('close', handleClose);
+        };
+    }, [
+        floatingTreeRoot.events,
+        store
+    ]);
+    useHoverFloatingInteraction(floatingContext, {
+        enabled: hoverEnabled && !disabled && !isContextMenu && 'menubar' !== parent.type,
+        closeDelay
+    });
+    const setPopupElement = __rspack_external_react.useCallback((element)=>{
+        store.set('popupElement', element);
+    }, [
+        store
+    ]);
+    const state = {
+        transitionStatus,
+        side,
+        align,
+        open,
+        nested: 'menu' === parent.type,
+        instant: instantType
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            store.context.popupRef,
+            setPopupElement
+        ],
+        stateAttributesMapping: MenuPopup_stateAttributesMapping,
+        props: [
+            popupProps,
+            {
+                onKeyDown (event) {
+                    if (insideToolbar && COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+                }
+            },
+            getDisabledMountTransitionStyles(transitionStatus),
+            elementProps,
+            {
+                'data-rootownerid': rootId
+            }
+        ]
+    });
+    let returnFocus = void 0 === parent.type || isContextMenu;
+    if (triggerElement || 'menubar' === parent.type && lastOpenChangeReason !== outsidePress) returnFocus = true;
+    return /*#__PURE__*/ jsx(FloatingFocusManager, {
+        context: floatingContext,
+        modal: isContextMenu,
+        disabled: !mounted,
+        returnFocus: void 0 === finalFocus ? returnFocus : finalFocus,
+        initialFocus: 'menu' !== parent.type,
+        restoreFocus: true,
+        externalTree: 'menubar' !== parent.type ? floatingTreeRoot : void 0,
+        previousFocusableElement: activeTriggerElement,
+        nextFocusableElement: void 0 === parent.type ? store.context.triggerFocusTargetRef : void 0,
+        beforeContentFocusGuardRef: void 0 === parent.type ? store.context.beforeContentFocusGuardRef : void 0,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuPopup_MenuPopup.displayName = "MenuPopup";
+const MenuArrow_MenuArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { store } = useMenuRootContext();
+    const { arrowRef, side, align, arrowUncentered, arrowStyles } = useMenuPositionerContext();
+    const open = store.useState('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) MenuArrow_MenuArrow.displayName = "MenuArrow";
+const MenuGroupContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuGroupContext.displayName = "MenuGroupContext";
+function useMenuGroupRootContext() {
+    const context = __rspack_external_react.useContext(MenuGroupContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenuGroupContext is missing. Menu group parts must be used within <Menu.Group> or <Menu.RadioGroup>.' : esm_formatErrorMessage(31));
+    return context;
+}
+const MenuGroup_MenuGroup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const [labelId, setLabelId] = __rspack_external_react.useState(void 0);
+    const element = useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: {
+            role: 'group',
+            'aria-labelledby': labelId,
+            ...elementProps
+        }
+    });
+    return /*#__PURE__*/ jsx(MenuGroupContext.Provider, {
+        value: setLabelId,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuGroup_MenuGroup.displayName = "MenuGroup";
+const MenuGroupLabel_MenuGroupLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const id = useBaseUiId(idProp);
+    const setLabelId = useMenuGroupRootContext();
+    useIsoLayoutEffect(()=>{
+        setLabelId(id);
+        return ()=>{
+            setLabelId(void 0);
+        };
+    }, [
+        setLabelId,
+        id
+    ]);
+    return useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: {
+            id,
+            role: 'presentation',
+            ...elementProps
+        }
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuGroupLabel_MenuGroupLabel.displayName = "MenuGroupLabel";
+function useMenuItemCommonProps(params) {
+    const { closeOnClick, highlighted, id, nodeId, store, typingRef, itemRef, itemMetadata } = params;
+    const { events: menuEvents } = store.useState('floatingTreeRoot');
+    const contextMenuContext = useContextMenuRootContext(true);
+    const isContextMenu = void 0 !== contextMenuContext;
+    return __rspack_external_react.useMemo(()=>({
+            id,
+            role: 'menuitem',
+            tabIndex: highlighted ? 0 : -1,
+            onKeyDown (event) {
+                if (' ' === event.key && typingRef?.current) event.preventDefault();
+            },
+            onMouseMove (event) {
+                if (!nodeId) return;
+                menuEvents.emit('itemhover', {
+                    nodeId,
+                    target: event.currentTarget
+                });
+            },
+            onClick (event) {
+                if (closeOnClick) menuEvents.emit('close', {
+                    domEvent: event,
+                    reason: itemPress
+                });
+            },
+            onMouseUp (event) {
+                if (contextMenuContext) {
+                    const initialCursorPoint = contextMenuContext.initialCursorPointRef.current;
+                    contextMenuContext.initialCursorPointRef.current = null;
+                    if (isContextMenu && initialCursorPoint && Math.abs(event.clientX - initialCursorPoint.x) <= 1 && Math.abs(event.clientY - initialCursorPoint.y) <= 1) return;
+                    if (isContextMenu && !isMac && 2 === event.button) return;
+                }
+                if (itemRef.current && store.context.allowMouseUpTriggerRef.current && (!isContextMenu || 2 === event.button)) {
+                    if (!itemMetadata || 'regular-item' === itemMetadata.type) itemRef.current.click();
+                }
+            }
+        }), [
+        closeOnClick,
+        highlighted,
+        id,
+        menuEvents,
+        nodeId,
+        store,
+        typingRef,
+        itemRef,
+        contextMenuContext,
+        isContextMenu,
+        itemMetadata
+    ]);
+}
+const REGULAR_ITEM = {
+    type: 'regular-item'
+};
+function useMenuItem(params) {
+    const { closeOnClick, disabled = false, highlighted, id, store, typingRef = store.context.typingRef, nativeButton, itemMetadata, nodeId } = params;
+    const itemRef = __rspack_external_react.useRef(null);
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        focusableWhenDisabled: true,
+        native: nativeButton,
+        composite: true
+    });
+    const commonProps = useMenuItemCommonProps({
+        closeOnClick,
+        highlighted,
+        id,
+        nodeId,
+        store,
+        typingRef,
+        itemRef,
+        itemMetadata
+    });
+    const getItemProps = __rspack_external_react.useCallback((externalProps)=>mergeProps(commonProps, {
+            onMouseEnter () {
+                if ('submenu-trigger' !== itemMetadata.type) return;
+                itemMetadata.setActive();
+            }
+        }, externalProps, getButtonProps), [
+        commonProps,
+        getButtonProps,
+        itemMetadata
+    ]);
+    const mergedRef = useMergedRefs(itemRef, buttonRef);
+    return __rspack_external_react.useMemo(()=>({
+            getItemProps,
+            itemRef: mergedRef
+        }), [
+        getItemProps,
+        mergedRef
+    ]);
+}
+const MenuItem_MenuItem = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, id: idProp, label, nativeButton = false, disabled = false, closeOnClick = true, style, ...elementProps } = componentProps;
+    const listItem = useCompositeListItem({
+        label
+    });
+    const menuPositionerContext = useMenuPositionerContext(true);
+    const id = useBaseUiId(idProp);
+    const { store } = useMenuRootContext();
+    const highlighted = store.useState('isActive', listItem.index);
+    const itemProps = store.useState('itemProps');
+    const { getItemProps, itemRef } = useMenuItem({
+        closeOnClick,
+        disabled,
+        highlighted,
+        id,
+        store,
+        nativeButton,
+        nodeId: menuPositionerContext?.context.nodeId,
+        itemMetadata: REGULAR_ITEM
+    });
+    const state = {
+        disabled,
+        highlighted
+    };
+    return useRenderElement('div', componentProps, {
+        state,
+        props: [
+            itemProps,
+            elementProps,
+            getItemProps
+        ],
+        ref: [
+            itemRef,
+            forwardedRef,
+            listItem.ref
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuItem_MenuItem.displayName = "MenuItem";
+const MenuCheckboxItemContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuCheckboxItemContext.displayName = "MenuCheckboxItemContext";
+function useMenuCheckboxItemContext() {
+    const context = __rspack_external_react.useContext(MenuCheckboxItemContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenuCheckboxItemContext is missing. MenuCheckboxItem parts must be placed within <Menu.CheckboxItem>.' : esm_formatErrorMessage(30));
+    return context;
+}
+let MenuCheckboxItemDataAttributes_MenuCheckboxItemDataAttributes = /*#__PURE__*/ function(MenuCheckboxItemDataAttributes) {
+    MenuCheckboxItemDataAttributes["checked"] = "data-checked";
+    MenuCheckboxItemDataAttributes["unchecked"] = "data-unchecked";
+    MenuCheckboxItemDataAttributes["disabled"] = "data-disabled";
+    MenuCheckboxItemDataAttributes["highlighted"] = "data-highlighted";
+    return MenuCheckboxItemDataAttributes;
+}({});
+const itemMapping = {
+    checked (value) {
+        if (value) return {
+            [MenuCheckboxItemDataAttributes_MenuCheckboxItemDataAttributes.checked]: ''
+        };
+        return {
+            [MenuCheckboxItemDataAttributes_MenuCheckboxItemDataAttributes.unchecked]: ''
+        };
+    },
+    ...transitionStatusMapping
+};
+const MenuCheckboxItem_MenuCheckboxItem = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, id: idProp, label, nativeButton = false, disabled = false, closeOnClick = false, checked: checkedProp, defaultChecked, onCheckedChange, style, ...elementProps } = componentProps;
+    const listItem = useCompositeListItem({
+        label
+    });
+    const menuPositionerContext = useMenuPositionerContext(true);
+    const id = useBaseUiId(idProp);
+    const { store } = useMenuRootContext();
+    const highlighted = store.useState('isActive', listItem.index);
+    const itemProps = store.useState('itemProps');
+    const [checked, setChecked] = useControlled({
+        controlled: checkedProp,
+        default: defaultChecked ?? false,
+        name: 'MenuCheckboxItem',
+        state: 'checked'
+    });
+    const { getItemProps, itemRef } = useMenuItem({
+        closeOnClick,
+        disabled,
+        highlighted,
+        id,
+        store,
+        nativeButton,
+        nodeId: menuPositionerContext?.context.nodeId,
+        itemMetadata: REGULAR_ITEM
+    });
+    const state = __rspack_external_react.useMemo(()=>({
+            disabled,
+            highlighted,
+            checked
+        }), [
+        disabled,
+        highlighted,
+        checked
+    ]);
+    function handleClick(event) {
+        const details = createChangeEventDetails(itemPress, event.nativeEvent, void 0, {
+            preventUnmountOnClose () {}
+        });
+        onCheckedChange?.(!checked, details);
+        if (details.isCanceled) return;
+        setChecked((currentlyChecked)=>!currentlyChecked);
+    }
+    const element = useRenderElement('div', componentProps, {
+        state,
+        stateAttributesMapping: itemMapping,
+        props: [
+            itemProps,
+            {
+                role: 'menuitemcheckbox',
+                'aria-checked': checked,
+                onClick: handleClick
+            },
+            elementProps,
+            getItemProps
+        ],
+        ref: [
+            itemRef,
+            forwardedRef,
+            listItem.ref
+        ]
+    });
+    return /*#__PURE__*/ jsx(MenuCheckboxItemContext.Provider, {
+        value: state,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuCheckboxItem_MenuCheckboxItem.displayName = "MenuCheckboxItem";
+const MenuCheckboxItemIndicator_MenuCheckboxItemIndicator = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, keepMounted = false, ...elementProps } = componentProps;
+    const item = useMenuCheckboxItemContext();
+    const indicatorRef = __rspack_external_react.useRef(null);
+    const { transitionStatus, setMounted } = useTransitionStatus(item.checked);
+    useOpenChangeComplete({
+        open: item.checked,
+        ref: indicatorRef,
+        onComplete () {
+            if (!item.checked) setMounted(false);
+        }
+    });
+    const state = {
+        checked: item.checked,
+        disabled: item.disabled,
+        highlighted: item.highlighted,
+        transitionStatus
+    };
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            indicatorRef
+        ],
+        stateAttributesMapping: itemMapping,
+        props: {
+            'aria-hidden': true,
+            ...elementProps
+        },
+        enabled: keepMounted || item.checked
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) MenuCheckboxItemIndicator_MenuCheckboxItemIndicator.displayName = "MenuCheckboxItemIndicator";
+const MenuLinkItem_MenuLinkItem = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, id: idProp, label, closeOnClick = false, style, ...elementProps } = componentProps;
+    const linkRef = __rspack_external_react.useRef(null);
+    const listItem = useCompositeListItem({
+        label
+    });
+    const menuPositionerContext = useMenuPositionerContext(true);
+    const nodeId = menuPositionerContext?.context.nodeId;
+    const id = useBaseUiId(idProp);
+    const { store } = useMenuRootContext();
+    const highlighted = store.useState('isActive', listItem.index);
+    const itemProps = store.useState('itemProps');
+    const typingRef = store.context.typingRef;
+    const { getButtonProps, buttonRef } = useButton({
+        native: false,
+        composite: true
+    });
+    const commonProps = useMenuItemCommonProps({
+        closeOnClick,
+        highlighted,
+        id,
+        nodeId,
+        store,
+        typingRef,
+        itemRef: linkRef
+    });
+    function getItemProps(externalProps) {
+        return mergeProps(commonProps, externalProps, getButtonProps);
+    }
+    const state = {
+        highlighted
+    };
+    return useRenderElement('a', componentProps, {
+        state,
+        props: [
+            itemProps,
+            elementProps,
+            getItemProps
+        ],
+        ref: [
+            linkRef,
+            buttonRef,
+            forwardedRef,
+            listItem.ref
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuLinkItem_MenuLinkItem.displayName = "MenuLinkItem";
+const MenuRadioGroupContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuRadioGroupContext.displayName = "MenuRadioGroupContext";
+function useMenuRadioGroupContext() {
+    const context = __rspack_external_react.useContext(MenuRadioGroupContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenuRadioGroupContext is missing. MenuRadioGroup parts must be placed within <Menu.RadioGroup>.' : esm_formatErrorMessage(34));
+    return context;
+}
+const MenuRadioGroup_MenuRadioGroup = /*#__PURE__*/ __rspack_external_react.memo(/*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, value: valueProp, defaultValue, onValueChange: onValueChangeProp, disabled = false, style, 'aria-labelledby': ariaLabelledByProp, ...elementProps } = componentProps;
+    const [labelId, setLabelId] = __rspack_external_react.useState(void 0);
+    const [value, setValueUnwrapped] = useControlled({
+        controlled: valueProp,
+        default: defaultValue,
+        name: 'MenuRadioGroup'
+    });
+    const setValue = useStableCallback((newValue, eventDetails)=>{
+        onValueChangeProp?.(newValue, eventDetails);
+        if (eventDetails.isCanceled) return;
+        setValueUnwrapped(newValue);
+    });
+    const state = {
+        disabled
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: {
+            role: 'group',
+            'aria-labelledby': ariaLabelledByProp ?? labelId,
+            'aria-disabled': disabled || void 0,
+            ...elementProps
+        }
+    });
+    const context = __rspack_external_react.useMemo(()=>({
+            value,
+            setValue,
+            disabled
+        }), [
+        value,
+        setValue,
+        disabled
+    ]);
+    return /*#__PURE__*/ jsx(MenuGroupContext.Provider, {
+        value: setLabelId,
+        children: /*#__PURE__*/ jsx(MenuRadioGroupContext.Provider, {
+            value: context,
+            children: element
+        })
+    });
+}));
+if ("production" !== process.env.NODE_ENV) MenuRadioGroup_MenuRadioGroup.displayName = "MenuRadioGroup";
+const MenuRadioItemContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuRadioItemContext.displayName = "MenuRadioItemContext";
+function useMenuRadioItemContext() {
+    const context = __rspack_external_react.useContext(MenuRadioItemContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: MenuRadioItemContext is missing. MenuRadioItem parts must be placed within <Menu.RadioItem>.' : esm_formatErrorMessage(35));
+    return context;
+}
+const MenuRadioItem_MenuRadioItem = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, id: idProp, label, nativeButton = false, disabled: disabledProp = false, closeOnClick = false, value, style, ...elementProps } = componentProps;
+    const listItem = useCompositeListItem({
+        label
+    });
+    const menuPositionerContext = useMenuPositionerContext(true);
+    const id = useBaseUiId(idProp);
+    const { store } = useMenuRootContext();
+    const highlighted = store.useState('isActive', listItem.index);
+    const itemProps = store.useState('itemProps');
+    const { value: selectedValue, setValue: setSelectedValue, disabled: groupDisabled } = useMenuRadioGroupContext();
+    const disabled = groupDisabled || disabledProp;
+    const checked = selectedValue === value;
+    const { getItemProps, itemRef } = useMenuItem({
+        closeOnClick,
+        disabled,
+        highlighted,
+        id,
+        store,
+        nativeButton,
+        nodeId: menuPositionerContext?.context.nodeId,
+        itemMetadata: REGULAR_ITEM
+    });
+    const state = __rspack_external_react.useMemo(()=>({
+            disabled,
+            highlighted,
+            checked
+        }), [
+        disabled,
+        highlighted,
+        checked
+    ]);
+    function handleClick(event) {
+        const details = createChangeEventDetails(itemPress, event.nativeEvent, void 0, {
+            preventUnmountOnClose () {}
+        });
+        setSelectedValue(value, details);
+    }
+    const element = useRenderElement('div', componentProps, {
+        state,
+        stateAttributesMapping: itemMapping,
+        props: [
+            itemProps,
+            {
+                role: 'menuitemradio',
+                'aria-checked': checked,
+                onClick: handleClick
+            },
+            elementProps,
+            getItemProps
+        ],
+        ref: [
+            itemRef,
+            forwardedRef,
+            listItem.ref
+        ]
+    });
+    return /*#__PURE__*/ jsx(MenuRadioItemContext.Provider, {
+        value: state,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuRadioItem_MenuRadioItem.displayName = "MenuRadioItem";
+const MenuRadioItemIndicator_MenuRadioItemIndicator = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, keepMounted = false, ...elementProps } = componentProps;
+    const item = useMenuRadioItemContext();
+    const indicatorRef = __rspack_external_react.useRef(null);
+    const { transitionStatus, setMounted } = useTransitionStatus(item.checked);
+    useOpenChangeComplete({
+        open: item.checked,
+        ref: indicatorRef,
+        onComplete () {
+            if (!item.checked) setMounted(false);
+        }
+    });
+    const state = {
+        checked: item.checked,
+        disabled: item.disabled,
+        highlighted: item.highlighted,
+        transitionStatus
+    };
+    const element = useRenderElement('span', componentProps, {
+        state,
+        stateAttributesMapping: itemMapping,
+        ref: [
+            forwardedRef,
+            indicatorRef
+        ],
+        props: {
+            'aria-hidden': true,
+            ...elementProps
+        },
+        enabled: keepMounted || item.checked
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) MenuRadioItemIndicator_MenuRadioItemIndicator.displayName = "MenuRadioItemIndicator";
+const MenuSubmenuRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) MenuSubmenuRootContext.displayName = "MenuSubmenuRootContext";
+function useMenuSubmenuRootContext() {
+    return __rspack_external_react.useContext(MenuSubmenuRootContext);
+}
+const MenuSubmenuTrigger_MenuSubmenuTrigger = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, label, id: idProp, nativeButton = false, openOnHover = true, delay = 100, closeDelay = 0, disabled: disabledProp = false, ...elementProps } = componentProps;
+    const listItem = useCompositeListItem();
+    const menuPositionerContext = useMenuPositionerContext();
+    const { store } = useMenuRootContext();
+    const thisTriggerId = useBaseUiId(idProp);
+    const open = store.useState('open');
+    const floatingRootContext = store.useState('floatingRootContext');
+    const floatingTreeRoot = store.useState('floatingTreeRoot');
+    const popupId = store.useState('triggerPopupId', thisTriggerId);
+    const baseRegisterTrigger = useTriggerRegistration(thisTriggerId, store);
+    const registerTrigger = __rspack_external_react.useCallback((element)=>{
+        const cleanup = baseRegisterTrigger(element);
+        if (null !== element && store.select('open') && null == store.select('activeTriggerId')) store.update({
+            activeTriggerId: thisTriggerId,
+            activeTriggerElement: element,
+            closeDelay
+        });
+        return cleanup;
+    }, [
+        baseRegisterTrigger,
+        closeDelay,
+        store,
+        thisTriggerId
+    ]);
+    const triggerElementRef = __rspack_external_react.useRef(null);
+    const handleTriggerElementRef = __rspack_external_react.useCallback((el)=>{
+        triggerElementRef.current = el;
+        store.set('activeTriggerElement', el);
+    }, [
+        store
+    ]);
+    if ('production' !== process.env.NODE_ENV) useIsoLayoutEffect(()=>{
+        const element = triggerElementRef.current;
+        if (element && isElementDisabled(element) && !disabledProp) {
+            const ownerStackMessage = SafeReact.captureOwnerStack?.() || '';
+            warn(`A disabled element was detected on <Menu.SubmenuTrigger>. To properly disable the trigger, use the \`disabled\` prop on the component instead of setting it on the rendered element.${ownerStackMessage}`);
+        }
+    });
+    const submenuRootContext = useMenuSubmenuRootContext();
+    if (!submenuRootContext?.parentMenu) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>.' : esm_formatErrorMessage(37));
+    store.useSyncedValue('closeDelay', closeDelay);
+    const parentMenuStore = submenuRootContext.parentMenu;
+    const itemProps = parentMenuStore.useState('itemProps');
+    const highlighted = parentMenuStore.useState('isActive', listItem.index);
+    const itemMetadata = __rspack_external_react.useMemo(()=>({
+            type: 'submenu-trigger',
+            setActive () {
+                parentMenuStore.set('activeIndex', listItem.index);
+            }
+        }), [
+        parentMenuStore,
+        listItem.index
+    ]);
+    const rootDisabled = store.useState('disabled');
+    const disabled = disabledProp || rootDisabled;
+    const { getItemProps, itemRef } = useMenuItem({
+        closeOnClick: false,
+        disabled,
+        highlighted,
+        id: thisTriggerId,
+        store,
+        typingRef: parentMenuStore.context.typingRef,
+        nativeButton,
+        itemMetadata,
+        nodeId: menuPositionerContext?.context.nodeId
+    });
+    const hoverEnabled = store.useState('hoverEnabled');
+    const allowMouseEnter = parentMenuStore.useState('allowMouseEnter');
+    const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+        enabled: hoverEnabled && openOnHover && !disabled,
+        handleClose: safePolygon({
+            blockPointerEvents: true
+        }),
+        mouseOnly: true,
+        move: true,
+        restMs: delay,
+        delay: allowMouseEnter ? {
+            open: delay,
+            close: closeDelay
+        } : 0,
+        triggerElementRef,
+        externalTree: floatingTreeRoot,
+        isClosing: ()=>'ending' === store.select('transitionStatus')
+    });
+    const click = useClick(floatingRootContext, {
+        enabled: !disabled,
+        event: 'mousedown',
+        toggle: !openOnHover,
+        ignoreMouse: openOnHover,
+        stickIfOpen: false
+    });
+    const localInteractionProps = click.reference ?? EMPTY_OBJECT;
+    const rootTriggerProps = store.useState('triggerProps', true);
+    delete rootTriggerProps.id;
+    const state = {
+        disabled,
+        highlighted,
+        open
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        stateAttributesMapping: triggerOpenStateMapping,
+        props: [
+            localInteractionProps,
+            hoverProps,
+            rootTriggerProps,
+            itemProps,
+            {
+                'aria-controls': popupId,
+                tabIndex: open || highlighted ? 0 : -1,
+                onBlur () {
+                    if (highlighted) parentMenuStore.set('activeIndex', null);
+                }
+            },
+            elementProps,
+            getItemProps
+        ],
+        ref: [
+            forwardedRef,
+            listItem.ref,
+            itemRef,
+            registerTrigger,
+            handleTriggerElementRef
+        ]
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) MenuSubmenuTrigger_MenuSubmenuTrigger.displayName = "MenuSubmenuTrigger";
+const selectors = {
+    ...popupStoreSelectors,
+    disabled: createSelector((state)=>'menubar' === state.parent.type ? state.parent.context.disabled || state.disabled : state.disabled),
+    modal: createSelector((state)=>(void 0 === state.parent.type || 'context-menu' === state.parent.type) && (state.modal ?? true)),
+    openMethod: createSelector((state)=>state.openMethod),
+    allowMouseEnter: createSelector((state)=>state.allowMouseEnter),
+    stickIfOpen: createSelector((state)=>state.stickIfOpen),
+    parent: createSelector((state)=>state.parent),
+    rootId: createSelector((state)=>{
+        if ('menu' === state.parent.type) return state.parent.store.select('rootId');
+        return void 0 !== state.parent.type ? state.parent.context.rootId : state.rootId;
+    }),
+    activeIndex: createSelector((state)=>state.activeIndex),
+    isActive: createSelector((state, itemIndex)=>state.activeIndex === itemIndex),
+    hoverEnabled: createSelector((state)=>state.hoverEnabled),
+    instantType: createSelector((state)=>state.instantType),
+    lastOpenChangeReason: createSelector((state)=>state.openChangeReason),
+    floatingTreeRoot: createSelector((state)=>{
+        if ('menu' === state.parent.type) return state.parent.store.select('floatingTreeRoot');
+        return state.floatingTreeRoot;
+    }),
+    floatingNodeId: createSelector((state)=>state.floatingNodeId),
+    floatingParentNodeId: createSelector((state)=>state.floatingParentNodeId),
+    itemProps: createSelector((state)=>state.itemProps),
+    closeDelay: createSelector((state)=>state.closeDelay),
+    hasViewport: createSelector((state)=>state.hasViewport),
+    keyboardEventRelay: createSelector((state)=>{
+        if (state.keyboardEventRelay) return state.keyboardEventRelay;
+        if ('menu' === state.parent.type) return state.parent.store.select('keyboardEventRelay');
+    })
+};
+class MenuStore extends ReactStore {
+    constructor(initialState){
+        super({
+            ...createInitialState(),
+            ...initialState
+        }, {
+            positionerRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            popupRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            typingRef: {
+                current: false
+            },
+            itemDomElements: {
+                current: []
+            },
+            itemLabels: {
+                current: []
+            },
+            allowMouseUpTriggerRef: {
+                current: false
+            },
+            triggerFocusTargetRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            beforeContentFocusGuardRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            onOpenChangeComplete: void 0,
+            triggerElements: new PopupTriggerMap()
+        }, selectors);
+        this.unsubscribeParentListener = this.observe('parent', (parent)=>{
+            this.unsubscribeParentListener?.();
+            if ('menu' === parent.type) {
+                let rootId = parent.store.select('rootId');
+                let floatingTreeRoot = parent.store.select('floatingTreeRoot');
+                let keyboardEventRelay = parent.store.select('keyboardEventRelay');
+                this.unsubscribeParentListener = parent.store.subscribe(()=>{
+                    const nextRootId = parent.store.select('rootId');
+                    const nextFloatingTreeRoot = parent.store.select('floatingTreeRoot');
+                    const nextKeyboardEventRelay = parent.store.select('keyboardEventRelay');
+                    if (rootId === nextRootId && floatingTreeRoot === nextFloatingTreeRoot && keyboardEventRelay === nextKeyboardEventRelay) return;
+                    rootId = nextRootId;
+                    floatingTreeRoot = nextFloatingTreeRoot;
+                    keyboardEventRelay = nextKeyboardEventRelay;
+                    this.notifyAll();
+                });
+                this.context.allowMouseUpTriggerRef = parent.store.context.allowMouseUpTriggerRef;
+                return;
+            }
+            if (void 0 !== parent.type) this.context.allowMouseUpTriggerRef = parent.context.allowMouseUpTriggerRef;
+            this.unsubscribeParentListener = null;
+        });
+    }
+    setOpen(open, eventDetails) {
+        this.state.floatingRootContext.context.events.emit('setOpen', {
+            open,
+            eventDetails
+        });
+    }
+    static useStore(externalStore, initialState) {
+        const internalStore = useRefWithInit(()=>new MenuStore(initialState)).current;
+        return externalStore ?? internalStore;
+    }
+    unsubscribeParentListener = null;
+}
+function createInitialState() {
+    return {
+        ...createInitialPopupStoreState(),
+        disabled: false,
+        modal: true,
+        openMethod: null,
+        allowMouseEnter: false,
+        stickIfOpen: true,
+        parent: {
+            type: void 0
+        },
+        rootId: void 0,
+        activeIndex: null,
+        hoverEnabled: true,
+        instantType: void 0,
+        openChangeReason: null,
+        floatingTreeRoot: new FloatingTreeStore(),
+        floatingNodeId: void 0,
+        floatingParentNodeId: null,
+        itemProps: EMPTY_OBJECT,
+        keyboardEventRelay: void 0,
+        closeDelay: 0,
+        hasViewport: false
+    };
+}
+const MenuRoot_MenuRoot = fastComponent(function(props) {
+    const { children, open: openProp, onOpenChange, onOpenChangeComplete, defaultOpen = false, disabled: disabledProp = false, modal: modalProp, loopFocus = true, orientation = 'vertical', actionsRef, closeParentOnEsc = false, handle, triggerId: triggerIdProp, defaultTriggerId: defaultTriggerIdProp = null, highlightItemOnHover = true } = props;
+    const contextMenuContext = useContextMenuRootContext(true);
+    const parentMenuRootContext = useMenuRootContext(true);
+    const menubarContext = useMenubarContext(true);
+    const isSubmenu = useMenuSubmenuRootContext();
+    const parentFromContext = __rspack_external_react.useMemo(()=>{
+        if (isSubmenu && parentMenuRootContext) return {
+            type: 'menu',
+            store: parentMenuRootContext.store
+        };
+        if (menubarContext) return {
+            type: 'menubar',
+            context: menubarContext
+        };
+        if (contextMenuContext && !parentMenuRootContext) return {
+            type: 'context-menu',
+            context: contextMenuContext
+        };
+        return {
+            type: void 0
+        };
+    }, [
+        contextMenuContext,
+        parentMenuRootContext,
+        menubarContext,
+        isSubmenu
+    ]);
+    const store = MenuStore.useStore(handle?.store, {
+        open: defaultOpen,
+        openProp,
+        activeTriggerId: defaultTriggerIdProp,
+        triggerIdProp,
+        parent: parentFromContext
+    });
+    useOnFirstRender(()=>{
+        if (void 0 === openProp && false === store.state.open && true === defaultOpen) store.update({
+            open: true,
+            activeTriggerId: defaultTriggerIdProp
+        });
+    });
+    store.useControlledProp('openProp', openProp);
+    store.useControlledProp('triggerIdProp', triggerIdProp);
+    store.useContextCallback('onOpenChangeComplete', onOpenChangeComplete);
+    const rootId = useId();
+    const floatingId = useId();
+    const floatingTreeRoot = store.useState('floatingTreeRoot');
+    const floatingNodeIdFromContext = useFloatingNodeId(floatingTreeRoot);
+    const floatingParentNodeIdFromContext = useFloatingParentNodeId();
+    const open = store.useState('open');
+    const activeTriggerElement = store.useState('activeTriggerElement');
+    const positionerElement = store.useState('positionerElement');
+    const hoverEnabled = store.useState('hoverEnabled');
+    const disabled = store.useState('disabled');
+    const lastOpenChangeReason = store.useState('lastOpenChangeReason');
+    const parent = store.useState('parent');
+    const activeIndex = store.useState('activeIndex');
+    const payload = store.useState('payload');
+    const floatingParentNodeId = store.useState('floatingParentNodeId');
+    const openEventRef = __rspack_external_react.useRef(null);
+    const allowOutsidePressDismissalRef = __rspack_external_react.useRef('context-menu' !== parent.type);
+    const allowOutsidePressDismissalTimeout = useTimeout();
+    const allowTouchToCloseRef = __rspack_external_react.useRef(true);
+    const allowTouchToCloseTimeout = useTimeout();
+    const nested = null != floatingParentNodeId;
+    if ('production' !== process.env.NODE_ENV) {
+        if (void 0 !== parent.type && void 0 !== modalProp) console.warn('Base UI: The `modal` prop is not supported on nested menus. It will be ignored.');
+    }
+    const { openMethod, triggerProps: interactionTypeProps } = useOpenInteractionType(open);
+    store.useSyncedValues({
+        disabled: disabledProp,
+        modal: void 0 === parent.type ? modalProp : void 0,
+        openMethod,
+        rootId
+    });
+    useImplicitActiveTrigger(store);
+    const { forceUnmount } = useOpenStateTransitions(open, store, ()=>{
+        store.update({
+            allowMouseEnter: false,
+            stickIfOpen: true
+        });
+    });
+    useIsoLayoutEffect(()=>{
+        if (contextMenuContext && !parentMenuRootContext) store.update({
+            parent: {
+                type: 'context-menu',
+                context: contextMenuContext
+            },
+            floatingNodeId: floatingNodeIdFromContext,
+            floatingParentNodeId: floatingParentNodeIdFromContext
+        });
+        else if (parentMenuRootContext) store.update({
+            floatingNodeId: floatingNodeIdFromContext,
+            floatingParentNodeId: floatingParentNodeIdFromContext
+        });
+    }, [
+        contextMenuContext,
+        parentMenuRootContext,
+        floatingNodeIdFromContext,
+        floatingParentNodeIdFromContext,
+        store
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!open) openEventRef.current = null;
+        if ('context-menu' !== parent.type) return;
+        if (!open) {
+            allowOutsidePressDismissalTimeout.clear();
+            allowOutsidePressDismissalRef.current = false;
+            return;
+        }
+        allowOutsidePressDismissalTimeout.start(500, ()=>{
+            allowOutsidePressDismissalRef.current = true;
+        });
+    }, [
+        allowOutsidePressDismissalTimeout,
+        open,
+        parent.type
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!open && !hoverEnabled) store.set('hoverEnabled', true);
+    }, [
+        open,
+        hoverEnabled,
+        store
+    ]);
+    const setOpen = useStableCallback((nextOpen, eventDetails)=>{
+        const reason = eventDetails.reason;
+        if (open === nextOpen && eventDetails.trigger === activeTriggerElement && lastOpenChangeReason === reason) return;
+        eventDetails.preventUnmountOnClose = ()=>{
+            store.set('preventUnmountingOnClose', true);
+        };
+        if (!nextOpen && null == eventDetails.trigger) eventDetails.trigger = activeTriggerElement ?? void 0;
+        onOpenChange?.(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        store.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
+        const nativeEvent = eventDetails.event;
+        if (false === nextOpen && nativeEvent?.type === 'click' && 'touch' === nativeEvent.pointerType && !allowTouchToCloseRef.current) return;
+        if (!nextOpen && null !== activeIndex) {
+            const activeOption = store.context.itemDomElements.current[activeIndex];
+            queueMicrotask(()=>{
+                activeOption?.setAttribute('tabindex', '-1');
+            });
+        }
+        if (nextOpen && reason === triggerFocus) {
+            allowTouchToCloseRef.current = false;
+            allowTouchToCloseTimeout.start(300, ()=>{
+                allowTouchToCloseRef.current = true;
+            });
+        } else {
+            allowTouchToCloseRef.current = true;
+            allowTouchToCloseTimeout.clear();
+        }
+        const isKeyboardClick = (reason === triggerPress || reason === itemPress) && 0 === nativeEvent.detail && nativeEvent?.isTrusted;
+        const isDismissClose = !nextOpen && (reason === escapeKey || null == reason);
+        const updatedState = {
+            open: nextOpen,
+            openChangeReason: reason
+        };
+        openEventRef.current = eventDetails.event ?? null;
+        const newTriggerId = eventDetails.trigger?.id ?? null;
+        if (newTriggerId || nextOpen) {
+            updatedState.activeTriggerId = newTriggerId;
+            updatedState.activeTriggerElement = eventDetails.trigger ?? null;
+        }
+        store.update(updatedState);
+        if ('menubar' === parent.type && (reason === triggerFocus || reason === focusOut || reason === triggerHover || reason === reason_parts_listNavigation || reason === siblingOpen)) store.set('instantType', 'group');
+        else if (isKeyboardClick || isDismissClose) store.set('instantType', isKeyboardClick ? 'click' : 'dismiss');
+        else store.set('instantType', void 0);
+    });
+    const floatingRootContext = useSyncedFloatingRootContext({
+        popupStore: store,
+        floatingId,
+        nested: null != floatingParentNodeIdFromContext,
+        onOpenChange: setOpen
+    });
+    const floatingEvents = floatingRootContext.context.events;
+    __rspack_external_react.useEffect(()=>{
+        const handleSetOpenEvent = ({ open: nextOpen, eventDetails })=>setOpen(nextOpen, eventDetails);
+        floatingEvents.on('setOpen', handleSetOpenEvent);
+        return ()=>{
+            floatingEvents?.off('setOpen', handleSetOpenEvent);
+        };
+    }, [
+        floatingEvents,
+        setOpen
+    ]);
+    const handleImperativeClose = __rspack_external_react.useCallback(()=>{
+        store.setOpen(false, createChangeEventDetails(imperativeAction));
+    }, [
+        store
+    ]);
+    __rspack_external_react.useImperativeHandle(actionsRef, ()=>({
+            unmount: forceUnmount,
+            close: handleImperativeClose
+        }), [
+        forceUnmount,
+        handleImperativeClose
+    ]);
+    let ctx;
+    if ('context-menu' === parent.type) ctx = parent.context;
+    __rspack_external_react.useImperativeHandle(ctx?.positionerRef, ()=>positionerElement, [
+        positionerElement
+    ]);
+    __rspack_external_react.useImperativeHandle(ctx?.actionsRef, ()=>({
+            setOpen
+        }), [
+        setOpen
+    ]);
+    const dismiss = useDismiss(floatingRootContext, {
+        enabled: !disabled,
+        bubbles: {
+            escapeKey: closeParentOnEsc && 'menu' === parent.type
+        },
+        outsidePress () {
+            if ('context-menu' !== parent.type || openEventRef.current?.type === 'contextmenu') return true;
+            return allowOutsidePressDismissalRef.current;
+        },
+        externalTree: nested ? floatingTreeRoot : void 0
+    });
+    const direction = useDirection();
+    const setActiveIndex = __rspack_external_react.useCallback((index)=>{
+        if (store.select('activeIndex') === index) return;
+        store.set('activeIndex', index);
+    }, [
+        store
+    ]);
+    const listNavigation = useListNavigation(floatingRootContext, {
+        enabled: !disabled,
+        listRef: store.context.itemDomElements,
+        activeIndex,
+        nested: void 0 !== parent.type,
+        loopFocus,
+        orientation,
+        parentOrientation: 'menubar' === parent.type ? parent.context.orientation : void 0,
+        rtl: 'rtl' === direction,
+        disabledIndices: EMPTY_ARRAY,
+        onNavigate: setActiveIndex,
+        openOnArrowKeyDown: 'context-menu' !== parent.type,
+        externalTree: nested ? floatingTreeRoot : void 0,
+        focusItemOnHover: highlightItemOnHover
+    });
+    const onTyping = __rspack_external_react.useCallback((nextTyping)=>{
+        store.context.typingRef.current = nextTyping;
+    }, [
+        store
+    ]);
+    const typeahead = useTypeahead(floatingRootContext, {
+        listRef: store.context.itemLabels,
+        elementsRef: store.context.itemDomElements,
+        activeIndex,
+        resetMs: 500,
+        onMatch: (index)=>{
+            if (open && index !== activeIndex) store.set('activeIndex', index);
+        },
+        onTyping
+    });
+    const activeTriggerProps = __rspack_external_react.useMemo(()=>{
+        const mergedProps = mergeProps(typeahead.reference, listNavigation.reference, dismiss.reference, {
+            onMouseMove () {
+                store.set('allowMouseEnter', true);
+            }
+        }, interactionTypeProps);
+        mergedProps['aria-haspopup'] = 'menu';
+        mergedProps['aria-expanded'] = open;
+        return mergedProps;
+    }, [
+        store,
+        typeahead.reference,
+        listNavigation.reference,
+        dismiss.reference,
+        interactionTypeProps,
+        open
+    ]);
+    const inactiveTriggerProps = __rspack_external_react.useMemo(()=>{
+        const mergedProps = mergeProps(listNavigation.trigger, dismiss.trigger, interactionTypeProps);
+        mergedProps['aria-haspopup'] = 'menu';
+        mergedProps['aria-expanded'] = false;
+        return mergedProps;
+    }, [
+        listNavigation.trigger,
+        dismiss.trigger,
+        interactionTypeProps
+    ]);
+    const popupProps = __rspack_external_react.useMemo(()=>mergeProps(FOCUSABLE_POPUP_PROPS, {
+            id: floatingId,
+            role: 'menu',
+            'aria-labelledby': activeTriggerElement?.id,
+            onMouseMove () {
+                store.set('allowMouseEnter', true);
+                if ('menu' === parent.type) store.set('hoverEnabled', false);
+            },
+            onClick () {
+                if (store.select('hoverEnabled')) store.set('hoverEnabled', false);
+            },
+            onKeyDown (event) {
+                const relay = store.select('keyboardEventRelay');
+                if (relay && !event.isPropagationStopped()) relay(event);
+            }
+        }, typeahead.floating, listNavigation.floating, dismiss.floating), [
+        activeTriggerElement,
+        floatingId,
+        parent.type,
+        store,
+        typeahead.floating,
+        listNavigation.floating,
+        dismiss.floating
+    ]);
+    const itemProps = listNavigation.item ?? EMPTY_OBJECT;
+    usePopupInteractionProps(store, {
+        floatingRootContext,
+        activeTriggerProps,
+        inactiveTriggerProps,
+        popupProps,
+        itemProps
+    });
+    const context = __rspack_external_react.useMemo(()=>({
+            store,
+            parent: parentFromContext
+        }), [
+        store,
+        parentFromContext
+    ]);
+    const content = /*#__PURE__*/ jsx(MenuRootContext.Provider, {
+        value: context,
+        children: 'function' == typeof children ? children({
+            payload
+        }) : children
+    });
+    if (void 0 === parent.type || 'context-menu' === parent.type) return /*#__PURE__*/ jsx(FloatingTree, {
+        externalTree: floatingTreeRoot,
+        children: content
+    });
+    return content;
+});
+if ("production" !== process.env.NODE_ENV) MenuRoot_MenuRoot.displayName = "MenuRoot";
+function MenuSubmenuRoot(props) {
+    const parentMenu = useMenuRootContext().store;
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            parentMenu
+        }), [
+        parentMenu
+    ]);
+    return /*#__PURE__*/ jsx(MenuSubmenuRootContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(MenuRoot_MenuRoot, {
+            ...props
+        })
+    });
+}
+const MenuPortal_MenuPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const { keepMounted = false, ...portalProps } = props;
+    const { store } = useMenuRootContext();
+    const mounted = store.useState('mounted');
+    const shouldRender = mounted || keepMounted;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(MenuPortalContext.Provider, {
+        value: keepMounted,
+        children: /*#__PURE__*/ jsx(FloatingPortal_FloatingPortal, {
+            ref: forwardedRef,
+            ...portalProps
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) MenuPortal_MenuPortal.displayName = "MenuPortal";
+export { ContextMenuRootContext, MenuArrow_MenuArrow, MenuBackdrop_MenuBackdrop, MenuCheckboxItemIndicator_MenuCheckboxItemIndicator, MenuCheckboxItem_MenuCheckboxItem, MenuGroupLabel_MenuGroupLabel, MenuGroup_MenuGroup, MenuItem_MenuItem, MenuLinkItem_MenuLinkItem, MenuPopup_MenuPopup, MenuPortal_MenuPortal, MenuPositioner_MenuPositioner, MenuRadioGroup_MenuRadioGroup, MenuRadioItemIndicator_MenuRadioItemIndicator, MenuRadioItem_MenuRadioItem, MenuRootContext, MenuRoot_MenuRoot, MenuStore, MenuSubmenuRoot, MenuSubmenuTrigger_MenuSubmenuTrigger, findRootOwnerId, useContextMenuRootContext, useMenuPositionerContext, useMenuRootContext };