@wix/site-ui 1.29.0 → 1.31.0

package/dist/NavigationMenu/index.js

@@ -1,7 +1,1024 @@
-import { jsx } from "react/jsx-runtime";
-import { NavigationMenu } from "@base-ui/react/navigation-menu";
+import { jsx, jsxs } from "react/jsx-runtime";
 import clsx from "clsx";
+import { FocusGuard_FocusGuard, disableFocusInside, ownerVisuallyHidden, triggerOpenStateMapping, DROPDOWN_COLLISION_AVOIDANCE, POPUP_COLLISION_AVOIDANCE, getTabbableAfterElement, enableFocusInside, FloatingPortal_FloatingPortal, getPreviousTabbable, isOutsideEvent, getNextTabbable, pressableTriggerOpenStateMapping, popupStateMapping } from "../4388.js";
+import { useAnimationsFinished, stateAttributesMapping_TransitionStatusDataAttributes, useTransitionStatus, transitionStatusMapping, useOpenChangeComplete } from "../880.js";
+import { useNavigationMenuDismissContext, useNavigationMenuRootContext, NavigationMenuPopupCssVars_NavigationMenuPopupCssVars, useNavigationMenuTreeContext, NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars, NavigationMenuItem_NavigationMenuItem, NavigationMenuList_NavigationMenuList, isOutsideMenuEvent, NavigationMenuLink_NavigationMenuLink, NavigationMenuRoot_NavigationMenuRoot, useNavigationMenuItemContext, NAVIGATION_MENU_TRIGGER_IDENTIFIER } from "../6588.js";
+import { useIsoLayoutEffect } from "../6499.js";
+import { useStableCallback } from "../7541.js";
+import { getTarget, contains } from "../4549.js";
+import { inertValue } from "../167.js";
+import { CompositeRoot } from "../9087.js";
+import { useFloatingTree, FloatingNode } from "../285.js";
+import { EMPTY_OBJECT, mergeProps, EMPTY_ARRAY, useRenderElement, esm_formatErrorMessage } from "../8272.js";
+import { useDirection } from "../9863.js";
+import { useTimeout } from "../42.js";
+import { useAnimationFrame } from "../8996.js";
+import { useValueAsRef } from "../4707.js";
+import { getCssDimensions } from "../7642.js";
+import { getWindow, isHTMLElement } from "../3829.js";
+import { addEventListener } from "../4723.js";
+import { focusOut, listNavigation, triggerHover, triggerPress } from "../2418.js";
+import { usePositioner, adaptiveOriginMiddleware_adaptiveOrigin, useFloatingRootContext, useAnchorPositioning } from "../8750.js";
+import { applySafePolygonPointerEventsMutation, useHoverInteractionSharedState, clearSafePolygonPointerEventsMutation } from "../3056.js";
+import { safePolygon, useHoverReferenceInteraction } from "../3670.js";
+import { useClick } from "../5864.js";
+import { createChangeEventDetails } from "../4768.js";
+import { stopEvent } from "../6330.js";
+import { useButton } from "../9189.js";
+import { CompositeItem } from "../951.js";
+import { getEmptyRootContext } from "../4922.js";
+import { mergeCleanups } from "../4495.js";
+import { useBaseUiId, useId } from "../6046.js";
 import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+const stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping,
+    activationDirection (value) {
+        if (!value) return null;
+        return {
+            'data-activation-direction': value
+        };
+    }
+};
+const NavigationMenuContent_NavigationMenuContent = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, keepMounted = false, ...elementProps } = componentProps;
+    const { mounted: popupMounted, viewportElement, value, activationDirection, currentContentRef, viewportTargetElement } = useNavigationMenuRootContext();
+    const { value: itemValue } = useNavigationMenuItemContext();
+    const nodeId = useNavigationMenuTreeContext();
+    const open = popupMounted && value === itemValue;
+    const ref = __rspack_external_react.useRef(null);
+    const [hasMountedInPortal, setHasMountedInPortal] = __rspack_external_react.useState(false);
+    const [focusInside, setFocusInside] = __rspack_external_react.useState(false);
+    const { mounted, setMounted, transitionStatus } = useTransitionStatus(open);
+    if (mounted && !popupMounted) setMounted(false);
+    useOpenChangeComplete({
+        ref,
+        open,
+        onComplete () {
+            if (!open) setMounted(false);
+        }
+    });
+    useIsoLayoutEffect(()=>{
+        if (open && ref.current) currentContentRef.current = ref.current;
+    }, [
+        open,
+        currentContentRef
+    ]);
+    const state = {
+        open,
+        transitionStatus,
+        activationDirection
+    };
+    const handleCurrentContentRef = useStableCallback((node)=>{
+        if (node && open) currentContentRef.current = node;
+    });
+    const commonProps = {
+        onFocus (event) {
+            const target = getTarget(event.nativeEvent);
+            if (target?.hasAttribute('data-base-ui-focus-guard')) return;
+            setFocusInside(true);
+        },
+        onBlur (event) {
+            if (!contains(event.currentTarget, event.relatedTarget)) setFocusInside(false);
+        }
+    };
+    const defaultProps = !open && mounted ? {
+        style: {
+            position: 'absolute',
+            top: 0,
+            left: 0
+        },
+        inert: inertValue(!focusInside),
+        ...commonProps
+    } : commonProps;
+    const portalContainer = viewportTargetElement || viewportElement;
+    const hidden = keepMounted && !mounted;
+    const shouldRenderInline = keepMounted && !portalContainer && !hasMountedInPortal;
+    if (keepMounted && portalContainer && !hasMountedInPortal) setHasMountedInPortal(true);
+    if (shouldRenderInline) return /*#__PURE__*/ jsx(CompositeRoot, {
+        render: render,
+        className: className,
+        style: style,
+        state: state,
+        refs: [
+            forwardedRef
+        ],
+        props: [
+            defaultProps,
+            {
+                hidden: true
+            },
+            elementProps
+        ],
+        stateAttributesMapping: stateAttributesMapping
+    });
+    if (!portalContainer || !mounted && !keepMounted) return null;
+    return /*#__PURE__*/ __rspack_external_react_dom_7136dc57.createPortal(/*#__PURE__*/ jsx(FloatingNode, {
+        id: nodeId,
+        children: /*#__PURE__*/ jsx(CompositeRoot, {
+            render: render,
+            className: className,
+            style: style,
+            state: state,
+            refs: [
+                forwardedRef,
+                ref,
+                handleCurrentContentRef
+            ],
+            props: [
+                defaultProps,
+                hidden ? {
+                    hidden: true
+                } : EMPTY_OBJECT,
+                elementProps
+            ],
+            stateAttributesMapping: stateAttributesMapping
+        })
+    }), portalContainer);
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuContent_NavigationMenuContent.displayName = "NavigationMenuContent";
+const DEFAULT_SIZE = {
+    width: 0,
+    height: 0
+};
+const NavigationMenuTrigger_NavigationMenuTrigger = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, nativeButton = true, disabled, ...elementProps } = componentProps;
+    const { value, setValue, mounted, open, positionerElement, setActivationDirection, setFloatingRootContext, popupElement, viewportElement, transitionStatus, rootRef, beforeOutsideRef, afterOutsideRef, afterInsideRef, beforeInsideRef, prevTriggerElementRef, popupAutoSizeResetRef, currentContentRef, delay, closeDelay, orientation, setViewportInert, nested } = useNavigationMenuRootContext();
+    const { value: itemValue } = useNavigationMenuItemContext();
+    const nodeId = useNavigationMenuTreeContext();
+    const tree = useFloatingTree();
+    const dismissProps = useNavigationMenuDismissContext();
+    const direction = useDirection();
+    const stickIfOpenTimeout = useTimeout();
+    const focusFrame = useAnimationFrame();
+    const mutationFrame = useAnimationFrame();
+    const resizeFrame = useAnimationFrame();
+    const sizeFrame = useAnimationFrame();
+    const [triggerElement, setTriggerElement] = __rspack_external_react.useState(null);
+    const [stickIfOpen, setStickIfOpen] = __rspack_external_react.useState(true);
+    const [pointerType, setPointerType] = __rspack_external_react.useState('');
+    const triggerElementRef = __rspack_external_react.useRef(null);
+    const allowFocusRef = __rspack_external_react.useRef(false);
+    const prevSizeRef = __rspack_external_react.useRef(DEFAULT_SIZE);
+    const skipAutoSizeSyncRef = __rspack_external_react.useRef(false);
+    const isActiveItem = open && value === itemValue;
+    const isActiveItemRef = useValueAsRef(isActiveItem);
+    const interactionsEnabled = positionerElement ? true : !value;
+    const hoverFloatingElement = positionerElement || viewportElement;
+    const hoverInteractionsEnabled = hoverFloatingElement ? true : !value;
+    const runOnceAnimationsFinish = useAnimationsFinished(popupElement, false, false);
+    const handleTriggerElement = __rspack_external_react.useCallback((element)=>{
+        triggerElementRef.current = element;
+        setTriggerElement(element);
+    }, []);
+    const cancelAutoSizeReset = useStableCallback((force = false)=>{
+        if (!force && popupAutoSizeResetRef.current.owner !== itemValue) return;
+        popupAutoSizeResetRef.current.abortController?.abort();
+        popupAutoSizeResetRef.current.abortController = null;
+        popupAutoSizeResetRef.current.owner = null;
+    });
+    useIsoLayoutEffect(()=>{
+        if (isActiveItem) return;
+        mutationFrame.cancel();
+        sizeFrame.cancel();
+        cancelAutoSizeReset();
+    }, [
+        isActiveItem,
+        mutationFrame,
+        sizeFrame,
+        cancelAutoSizeReset
+    ]);
+    function setAutoSizes() {
+        if (!popupElement) return;
+        popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupWidth, 'auto');
+        popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupHeight, 'auto');
+    }
+    function clearFixedSizes() {
+        if (!popupElement || !positionerElement) return;
+        popupElement.style.removeProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupWidth);
+        popupElement.style.removeProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupHeight);
+        positionerElement.style.removeProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerWidth);
+        positionerElement.style.removeProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerHeight);
+    }
+    function setSharedFixedSizes(width, height) {
+        if (!popupElement || !positionerElement) return;
+        popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupWidth, `${width}px`);
+        popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupHeight, `${height}px`);
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerWidth, `${width}px`);
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerHeight, `${height}px`);
+    }
+    function scheduleAutoSizeReset() {
+        cancelAutoSizeReset(true);
+        const abortController = new AbortController();
+        popupAutoSizeResetRef.current.abortController = abortController;
+        popupAutoSizeResetRef.current.owner = itemValue;
+        runOnceAnimationsFinish(()=>{
+            if (popupAutoSizeResetRef.current.abortController !== abortController || popupAutoSizeResetRef.current.owner !== itemValue) return;
+            popupAutoSizeResetRef.current.abortController = null;
+            popupAutoSizeResetRef.current.owner = null;
+            setAutoSizes();
+        }, abortController.signal);
+    }
+    const handleValueChange = useStableCallback((currentWidth, currentHeight, options = {})=>{
+        if (!popupElement || !positionerElement) return;
+        cancelAutoSizeReset(true);
+        const { syncPositioner = false } = options;
+        clearFixedSizes();
+        const { width, height } = getCssDimensions(popupElement);
+        const measuredWidth = width || prevSizeRef.current.width;
+        const measuredHeight = height || prevSizeRef.current.height;
+        if (0 === currentHeight || 0 === currentWidth) {
+            currentWidth = measuredWidth;
+            currentHeight = measuredHeight;
+        }
+        popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupWidth, `${currentWidth}px`);
+        popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupHeight, `${currentHeight}px`);
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerWidth, `${syncPositioner ? currentWidth : measuredWidth}px`);
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerHeight, `${syncPositioner ? currentHeight : measuredHeight}px`);
+        sizeFrame.request(()=>{
+            if (!isActiveItemRef.current) return;
+            popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupWidth, `${measuredWidth}px`);
+            popupElement.style.setProperty(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupHeight, `${measuredHeight}px`);
+            if (syncPositioner) {
+                positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerWidth, `${measuredWidth}px`);
+                positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerHeight, `${measuredHeight}px`);
+            }
+            scheduleAutoSizeReset();
+        });
+    });
+    const handleInterruptedMutationResize = useStableCallback((currentWidth, currentHeight)=>{
+        if (!popupElement || !positionerElement) return;
+        sizeFrame.cancel();
+        mutationFrame.cancel();
+        cancelAutoSizeReset(true);
+        if (0 === currentWidth || 0 === currentHeight) return;
+        setSharedFixedSizes(currentWidth, currentHeight);
+        mutationFrame.request(()=>{
+            mutationFrame.request(()=>{
+                clearFixedSizes();
+                const { width, height } = getCssDimensions(popupElement);
+                const measuredWidth = width || currentWidth || prevSizeRef.current.width;
+                const measuredHeight = height || currentHeight || prevSizeRef.current.height;
+                setSharedFixedSizes(currentWidth, currentHeight);
+                sizeFrame.request(()=>{
+                    if (!isActiveItemRef.current) return;
+                    setSharedFixedSizes(measuredWidth, measuredHeight);
+                    scheduleAutoSizeReset();
+                });
+            });
+        });
+    });
+    const syncCurrentSize = useStableCallback(()=>{
+        if (!popupElement || !positionerElement) return;
+        sizeFrame.cancel();
+        cancelAutoSizeReset(true);
+        clearFixedSizes();
+        const { width, height } = getCssDimensions(popupElement);
+        if (0 === width || 0 === height) return;
+        prevSizeRef.current = {
+            width,
+            height
+        };
+        setAutoSizes();
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerWidth, `${width}px`);
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars_NavigationMenuPositionerCssVars.positionerHeight, `${height}px`);
+    });
+    const getMutationBaseline = useStableCallback(()=>{
+        if (!popupElement) return {
+            size: prevSizeRef.current,
+            syncPositioner: false
+        };
+        const popupWidth = popupElement.style.getPropertyValue(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupWidth);
+        const popupHeight = popupElement.style.getPropertyValue(NavigationMenuPopupCssVars_NavigationMenuPopupCssVars.popupHeight);
+        const isResizing = '' !== popupWidth && 'auto' !== popupWidth && '' !== popupHeight && 'auto' !== popupHeight;
+        if (!isResizing) return {
+            size: prevSizeRef.current,
+            syncPositioner: false
+        };
+        return {
+            size: {
+                width: popupElement.offsetWidth || prevSizeRef.current.width,
+                height: popupElement.offsetHeight || prevSizeRef.current.height
+            },
+            syncPositioner: true
+        };
+    });
+    __rspack_external_react.useEffect(()=>{
+        if (!open) {
+            stickIfOpenTimeout.clear();
+            mutationFrame.cancel();
+            resizeFrame.cancel();
+            sizeFrame.cancel();
+            cancelAutoSizeReset(true);
+            skipAutoSizeSyncRef.current = false;
+            setPointerType('');
+        }
+    }, [
+        stickIfOpenTimeout,
+        open,
+        mutationFrame,
+        resizeFrame,
+        sizeFrame,
+        cancelAutoSizeReset
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!mounted) prevSizeRef.current = DEFAULT_SIZE;
+    }, [
+        mounted
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!popupElement || 'function' != typeof ResizeObserver) return;
+        const resizeObserver = new ResizeObserver(()=>{
+            prevSizeRef.current = {
+                width: popupElement.offsetWidth,
+                height: popupElement.offsetHeight
+            };
+        });
+        resizeObserver.observe(popupElement);
+        return ()=>{
+            resizeObserver.disconnect();
+        };
+    }, [
+        popupElement
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!open || !isActiveItem || !popupElement || !positionerElement) return;
+        const win = getWindow(positionerElement);
+        function handleResize() {
+            resizeFrame.cancel();
+            resizeFrame.request(syncCurrentSize);
+        }
+        const unsubscribe = addEventListener(win, 'resize', handleResize);
+        return ()=>{
+            resizeFrame.cancel();
+            unsubscribe();
+        };
+    }, [
+        open,
+        isActiveItem,
+        popupElement,
+        positionerElement,
+        resizeFrame,
+        syncCurrentSize
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        const observedElement = currentContentRef.current;
+        if (!observedElement || !popupElement || !isActiveItem || 'function' != typeof MutationObserver) return;
+        const mutationObserver = new MutationObserver(()=>{
+            if ('starting' === transitionStatus || popupElement.hasAttribute(stateAttributesMapping_TransitionStatusDataAttributes.startingStyle)) return void syncCurrentSize();
+            const { size, syncPositioner } = getMutationBaseline();
+            if (syncPositioner) return void handleInterruptedMutationResize(size.width, size.height);
+            handleValueChange(size.width, size.height);
+        });
+        mutationObserver.observe(observedElement, {
+            childList: true,
+            subtree: true,
+            characterData: true,
+            attributes: true,
+            attributeFilter: [
+                'hidden'
+            ]
+        });
+        return ()=>{
+            mutationObserver.disconnect();
+        };
+    }, [
+        currentContentRef,
+        popupElement,
+        isActiveItem,
+        transitionStatus,
+        getMutationBaseline,
+        handleInterruptedMutationResize,
+        handleValueChange,
+        syncCurrentSize
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (isActiveItem && open && popupElement && allowFocusRef.current) {
+            allowFocusRef.current = false;
+            focusFrame.request(()=>{
+                beforeOutsideRef.current?.focus();
+            });
+        }
+        return ()=>{
+            focusFrame.cancel();
+        };
+    }, [
+        beforeOutsideRef,
+        focusFrame,
+        isActiveItem,
+        open,
+        popupElement
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (isActiveItemRef.current && open && popupElement) {
+            const hasNestedMenu = currentContentRef.current?.querySelector('[data-nested]') != null;
+            if ('starting' === transitionStatus && hasNestedMenu) {
+                sizeFrame.request(syncCurrentSize);
+                return ()=>{
+                    sizeFrame.cancel();
+                };
+            }
+            if (skipAutoSizeSyncRef.current) {
+                skipAutoSizeSyncRef.current = false;
+                return;
+            }
+            const { width, height } = getCssDimensions(popupElement);
+            handleValueChange(width, height);
+        }
+    }, [
+        currentContentRef,
+        handleValueChange,
+        isActiveItemRef,
+        open,
+        popupElement,
+        sizeFrame,
+        syncCurrentSize,
+        transitionStatus
+    ]);
+    function handleOpenChange(nextOpen, eventDetails) {
+        const isHover = eventDetails.reason === triggerHover;
+        if (!interactionsEnabled) return;
+        if ('touch' === pointerType && isHover) return;
+        if (!nextOpen && value !== itemValue) return;
+        function changeState() {
+            if (isHover) {
+                setStickIfOpen(true);
+                stickIfOpenTimeout.clear();
+                stickIfOpenTimeout.start(500, ()=>{
+                    setStickIfOpen(false);
+                });
+            }
+            if (nextOpen) setValue(itemValue, eventDetails);
+            else {
+                setValue(null, eventDetails);
+                setPointerType('');
+            }
+        }
+        if (isHover) __rspack_external_react_dom_7136dc57.flushSync(changeState);
+        else changeState();
+    }
+    const context = useFloatingRootContext({
+        open,
+        onOpenChange: handleOpenChange,
+        elements: {
+            reference: triggerElement,
+            floating: hoverFloatingElement
+        }
+    });
+    const hoverInteractionState = useHoverInteractionSharedState(context);
+    const shouldBlockSafePolygonPointerEvents = 'touch' !== pointerType;
+    __rspack_external_react.useEffect(()=>{
+        if (!open) {
+            context.context.dataRef.current.openEvent = void 0;
+            hoverInteractionState.pointerType = void 0;
+            hoverInteractionState.interactedInside = false;
+            hoverInteractionState.restTimeoutPending = false;
+            hoverInteractionState.openChangeTimeout.clear();
+            hoverInteractionState.restTimeout.clear();
+            clearSafePolygonPointerEventsMutation(hoverInteractionState);
+        }
+    }, [
+        context,
+        hoverInteractionState,
+        open
+    ]);
+    const getInlineHandleCloseContext = useStableCallback(()=>{
+        if (!nested || positionerElement || !triggerElementRef.current || !hoverFloatingElement) return null;
+        return getHandleCloseContext(triggerElementRef.current, hoverFloatingElement, nodeId);
+    });
+    function getScope() {
+        if (!nested || !positionerElement) return triggerElementRef.current?.closest('ul') ?? null;
+        return null;
+    }
+    const hoverProps = useHoverReferenceInteraction(context, {
+        enabled: hoverInteractionsEnabled,
+        move: false,
+        handleClose: safePolygon({
+            blockPointerEvents: shouldBlockSafePolygonPointerEvents,
+            getScope
+        }),
+        restMs: mounted && positionerElement ? 0 : delay,
+        delay: {
+            close: closeDelay
+        },
+        triggerElementRef,
+        getHandleCloseContext: getInlineHandleCloseContext
+    });
+    const hover = __rspack_external_react.useMemo(()=>hoverProps ? {
+            reference: hoverProps
+        } : void 0, [
+        hoverProps
+    ]);
+    const click = useClick(context, {
+        enabled: interactionsEnabled,
+        stickIfOpen,
+        toggle: isActiveItem
+    });
+    const referenceProps = __rspack_external_react.useMemo(()=>mergeProps(click.reference, hover?.reference), [
+        click.reference,
+        hover
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (isActiveItem) {
+            setFloatingRootContext(context);
+            prevTriggerElementRef.current = triggerElement;
+        }
+    }, [
+        isActiveItem,
+        context,
+        setFloatingRootContext,
+        prevTriggerElementRef,
+        triggerElement
+    ]);
+    function handleActivation(event) {
+        __rspack_external_react_dom_7136dc57.flushSync(()=>{
+            const currentTarget = isHTMLElement(event.currentTarget) ? event.currentTarget : null;
+            const prevTriggerRect = prevTriggerElementRef.current?.getBoundingClientRect();
+            if (mounted && prevTriggerRect && triggerElement) {
+                const nextTriggerRect = triggerElement.getBoundingClientRect();
+                const isMovingRight = nextTriggerRect.left > prevTriggerRect.left;
+                const isMovingDown = nextTriggerRect.top > prevTriggerRect.top;
+                if ('horizontal' === orientation && nextTriggerRect.left !== prevTriggerRect.left) setActivationDirection(isMovingRight ? 'right' : 'left');
+                else if ('vertical' === orientation && nextTriggerRect.top !== prevTriggerRect.top) setActivationDirection(isMovingDown ? 'down' : 'up');
+            }
+            if ('click' !== event.type && null != value) context.context.dataRef.current.openEvent = void 0;
+            if ('touch' === pointerType && 'click' !== event.type) return;
+            if (null != value) setValue(itemValue, createChangeEventDetails('mouseenter' === event.type ? triggerHover : triggerPress, event.nativeEvent));
+            if ('mouseenter' === event.type && shouldBlockSafePolygonPointerEvents && (!nested || !positionerElement) && hoverFloatingElement && currentTarget) {
+                const applyPointerEventsMutation = ()=>{
+                    const scopeElement = getScope() ?? currentTarget.ownerDocument.body;
+                    applySafePolygonPointerEventsMutation(hoverInteractionState, {
+                        scopeElement,
+                        referenceElement: currentTarget,
+                        floatingElement: hoverFloatingElement
+                    });
+                };
+                if (null != value && value !== itemValue) queueMicrotask(applyPointerEventsMutation);
+                else applyPointerEventsMutation();
+            }
+        });
+    }
+    const handleOpenEvent = useStableCallback((event)=>{
+        if (!popupElement || !positionerElement) return void handleActivation(event);
+        const { width, height } = getCssDimensions(popupElement);
+        const shouldSkipAutoSizeSync = null != value && value !== itemValue && ('click' === event.type || 'touch' !== pointerType);
+        handleActivation(event);
+        if (shouldSkipAutoSizeSync) skipAutoSizeSyncRef.current = true;
+        handleValueChange(width, height);
+    });
+    const state = {
+        open: isActiveItem
+    };
+    function handleSetPointerType(event) {
+        setPointerType(event.pointerType);
+    }
+    function handleTriggerPointerDown(event) {
+        handleSetPointerType(event);
+        clearSafePolygonPointerEventsMutation(hoverInteractionState);
+    }
+    const defaultProps = {
+        tabIndex: 0,
+        onMouseEnter: handleOpenEvent,
+        onClick: handleOpenEvent,
+        onPointerEnter: handleSetPointerType,
+        onPointerDown: handleTriggerPointerDown,
+        'aria-expanded': isActiveItem,
+        'aria-controls': isActiveItem ? popupElement?.id : void 0,
+        [NAVIGATION_MENU_TRIGGER_IDENTIFIER]: '',
+        onFocus () {
+            if (!isActiveItem) return;
+            setViewportInert(false);
+        },
+        onMouseMove () {
+            allowFocusRef.current = false;
+        },
+        onKeyDown (event) {
+            allowFocusRef.current = true;
+            if (nested) return;
+            const verticalOpenKey = 'rtl' === direction ? 'ArrowLeft' : 'ArrowRight';
+            const openHorizontal = 'horizontal' === orientation && 'ArrowDown' === event.key;
+            const openVertical = 'vertical' === orientation && event.key === verticalOpenKey;
+            if (openHorizontal || openVertical) {
+                setValue(itemValue, createChangeEventDetails(listNavigation, event.nativeEvent));
+                handleOpenEvent(event);
+                stopEvent(event);
+            }
+        },
+        onBlur (event) {
+            if (positionerElement && popupElement && isOutsideMenuEvent({
+                currentTarget: event.currentTarget,
+                relatedTarget: event.relatedTarget
+            }, {
+                popupElement,
+                rootRef,
+                tree,
+                nodeId
+            })) setValue(null, createChangeEventDetails(focusOut, event.nativeEvent));
+        }
+    };
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        focusableWhenDisabled: true,
+        native: nativeButton
+    });
+    const referenceElement = hoverFloatingElement;
+    return /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(CompositeItem, {
+                tag: "button",
+                render: render,
+                className: className,
+                style: style,
+                state: state,
+                stateAttributesMapping: pressableTriggerOpenStateMapping,
+                refs: [
+                    forwardedRef,
+                    handleTriggerElement,
+                    buttonRef
+                ],
+                props: [
+                    referenceProps,
+                    dismissProps?.reference || EMPTY_ARRAY,
+                    defaultProps,
+                    elementProps,
+                    getButtonProps
+                ]
+            }),
+            isActiveItem && /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                        ref: beforeOutsideRef,
+                        onFocus: (event)=>{
+                            if (referenceElement && isOutsideEvent(event, referenceElement)) beforeInsideRef.current?.focus();
+                            else {
+                                const prevTabbable = getPreviousTabbable(triggerElement);
+                                prevTabbable?.focus();
+                            }
+                        }
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        "aria-owns": viewportElement?.id,
+                        style: ownerVisuallyHidden
+                    }),
+                    /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                        ref: afterOutsideRef,
+                        onFocus: (event)=>{
+                            if (referenceElement && isOutsideEvent(event, referenceElement)) {
+                                __rspack_external_react_dom_7136dc57.flushSync(()=>{
+                                    setViewportInert(false);
+                                });
+                                const elementToFocus = afterInsideRef.current || triggerElement;
+                                elementToFocus?.focus();
+                            } else {
+                                let nextTabbable = getNextTabbable(triggerElement);
+                                if (nested && !positionerElement && referenceElement && nextTabbable && contains(referenceElement, nextTabbable)) nextTabbable = getTabbableAfterElement(afterInsideRef.current);
+                                nextTabbable?.focus();
+                                if ((!nested || positionerElement) && !contains(rootRef.current, nextTabbable)) setValue(null, createChangeEventDetails(focusOut, event.nativeEvent));
+                            }
+                        }
+                    })
+                ]
+            })
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuTrigger_NavigationMenuTrigger.displayName = "NavigationMenuTrigger";
+function getPlacementFromElements(domReferenceElement, floatingElement) {
+    const referenceRect = domReferenceElement.getBoundingClientRect();
+    const floatingRect = floatingElement.getBoundingClientRect();
+    const referenceCenterX = referenceRect.left + referenceRect.width / 2;
+    const referenceCenterY = referenceRect.top + referenceRect.height / 2;
+    const floatingCenterX = floatingRect.left + floatingRect.width / 2;
+    const floatingCenterY = floatingRect.top + floatingRect.height / 2;
+    const deltaX = floatingCenterX - referenceCenterX;
+    const deltaY = floatingCenterY - referenceCenterY;
+    if (Math.abs(deltaX) >= Math.abs(deltaY)) return deltaX >= 0 ? 'right' : 'left';
+    return deltaY >= 0 ? 'bottom' : 'top';
+}
+function getHandleCloseContext(domReferenceElement, floatingElement, nodeId) {
+    return {
+        placement: getPlacementFromElements(domReferenceElement, floatingElement),
+        elements: {
+            domReference: domReferenceElement,
+            floating: floatingElement
+        },
+        nodeId
+    };
+}
+const NavigationMenuPortalContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) NavigationMenuPortalContext.displayName = "NavigationMenuPortalContext";
+function useNavigationMenuPortalContext() {
+    const value = __rspack_external_react.useContext(NavigationMenuPortalContext);
+    if (void 0 === value) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <NavigationMenu.Portal> is missing.' : esm_formatErrorMessage(40));
+    return value;
+}
+const NavigationMenuPositionerContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) NavigationMenuPositionerContext.displayName = "NavigationMenuPositionerContext";
+function useNavigationMenuPositionerContext(optional = false) {
+    const context = __rspack_external_react.useContext(NavigationMenuPositionerContext);
+    if (!context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: NavigationMenuPositionerContext is missing. NavigationMenuPositioner parts must be placed within <NavigationMenu.Positioner>.' : esm_formatErrorMessage(42));
+    return context;
+}
+const EMPTY_ROOT_CONTEXT = getEmptyRootContext();
+const NavigationMenuPositioner_NavigationMenuPositioner = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { open, mounted, positionerElement, setPositionerElement, floatingRootContext, nested, transitionStatus } = useNavigationMenuRootContext();
+    const { className, render, anchor, positionMethod = 'absolute', side = 'bottom', align = 'center', sideOffset = 0, alignOffset = 0, collisionBoundary = 'clipping-ancestors', collisionPadding = 5, collisionAvoidance = nested ? POPUP_COLLISION_AVOIDANCE : DROPDOWN_COLLISION_AVOIDANCE, arrowPadding = 5, sticky = false, disableAnchorTracking = false, style, ...elementProps } = componentProps;
+    const keepMounted = useNavigationMenuPortalContext();
+    const nodeId = useNavigationMenuTreeContext();
+    const resizeTimeout = useTimeout();
+    const [instant, setInstant] = __rspack_external_react.useState(false);
+    const positionerRef = __rspack_external_react.useRef(null);
+    const prevTriggerElementRef = __rspack_external_react.useRef(null);
+    __rspack_external_react.useEffect(()=>{
+        if (!positionerElement) return;
+        function onFocus(event) {
+            if (positionerElement && isOutsideEvent(event)) {
+                const focusing = 'focusin' === event.type;
+                const manageFocus = focusing ? enableFocusInside : disableFocusInside;
+                manageFocus(positionerElement);
+            }
+        }
+        return mergeCleanups(addEventListener(positionerElement, 'focusin', onFocus, true), addEventListener(positionerElement, 'focusout', onFocus, true));
+    }, [
+        positionerElement
+    ]);
+    const domReference = (floatingRootContext || EMPTY_ROOT_CONTEXT).useState('domReferenceElement');
+    const positioning = useAnchorPositioning({
+        anchor: anchor ?? domReference ?? prevTriggerElementRef,
+        positionMethod,
+        mounted,
+        side,
+        sideOffset,
+        align,
+        alignOffset,
+        arrowPadding,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        disableAnchorTracking,
+        keepMounted,
+        floatingRootContext,
+        collisionAvoidance,
+        nodeId,
+        adaptiveOrigin: adaptiveOriginMiddleware_adaptiveOrigin
+    });
+    const state = {
+        open,
+        side: positioning.side,
+        align: positioning.align,
+        anchorHidden: positioning.anchorHidden,
+        instant
+    };
+    __rspack_external_react.useEffect(()=>{
+        if (!open) return;
+        function handleResize() {
+            __rspack_external_react_dom_7136dc57.flushSync(()=>{
+                setInstant(true);
+            });
+            resizeTimeout.start(100, ()=>{
+                setInstant(false);
+            });
+        }
+        const win = getWindow(positionerElement);
+        return addEventListener(win, 'resize', handleResize);
+    }, [
+        open,
+        resizeTimeout,
+        positionerElement
+    ]);
+    const element = usePositioner(componentProps, state, {
+        styles: positioning.positionerStyles,
+        transitionStatus,
+        props: elementProps,
+        refs: [
+            forwardedRef,
+            setPositionerElement,
+            positionerRef
+        ],
+        hidden: !mounted,
+        inert: !open
+    });
+    return /*#__PURE__*/ jsx(NavigationMenuPositionerContext.Provider, {
+        value: positioning,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuPositioner_NavigationMenuPositioner.displayName = "NavigationMenuPositioner";
+const NavigationMenuViewport_EMPTY_ROOT_CONTEXT = getEmptyRootContext();
+function Guards({ children }) {
+    const { beforeInsideRef, beforeOutsideRef, afterInsideRef, afterOutsideRef, positionerElement, viewportElement, floatingRootContext } = useNavigationMenuRootContext();
+    const hasPositioner = Boolean(useNavigationMenuPositionerContext(true));
+    const referenceElement = positionerElement || viewportElement;
+    if (!floatingRootContext && !hasPositioner) return children;
+    return /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                ref: beforeInsideRef,
+                onFocus: (event)=>{
+                    if (referenceElement && isOutsideEvent(event, referenceElement)) getNextTabbable(referenceElement)?.focus();
+                    else beforeOutsideRef.current?.focus();
+                }
+            }),
+            children,
+            /*#__PURE__*/ jsx(FocusGuard_FocusGuard, {
+                ref: afterInsideRef,
+                onFocus: (event)=>{
+                    if (referenceElement && isOutsideEvent(event, referenceElement)) getPreviousTabbable(referenceElement)?.focus();
+                    else afterOutsideRef.current?.focus();
+                }
+            })
+        ]
+    });
+}
+const NavigationMenuViewport_NavigationMenuViewport = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, children, id: idProp, ...elementProps } = componentProps;
+    const id = useId(idProp);
+    const { setViewportElement, setViewportTargetElement, floatingRootContext, prevTriggerElementRef, viewportInert, setViewportInert } = useNavigationMenuRootContext();
+    const positioning = useNavigationMenuPositionerContext(true);
+    const hasPositioner = Boolean(positioning);
+    const domReference = (floatingRootContext || NavigationMenuViewport_EMPTY_ROOT_CONTEXT).useState('domReferenceElement');
+    useIsoLayoutEffect(()=>{
+        if (domReference) prevTriggerElementRef.current = domReference;
+    }, [
+        domReference,
+        prevTriggerElementRef
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            setViewportElement
+        ],
+        props: [
+            {
+                id,
+                onBlur (event) {
+                    const relatedTarget = event.relatedTarget;
+                    const currentTarget = event.currentTarget;
+                    if (relatedTarget && !contains(currentTarget, relatedTarget) && relatedTarget !== domReference) setViewportInert(true);
+                },
+                ...!hasPositioner && viewportInert && {
+                    inert: inertValue(true)
+                },
+                children: hasPositioner ? children : /*#__PURE__*/ jsx(Guards, {
+                    children: /*#__PURE__*/ jsx("div", {
+                        ref: setViewportTargetElement,
+                        children: children
+                    })
+                })
+            },
+            elementProps
+        ]
+    });
+    return hasPositioner ? /*#__PURE__*/ jsx(Guards, {
+        children: element
+    }) : element;
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuViewport_NavigationMenuViewport.displayName = "NavigationMenuViewport";
+const NavigationMenuBackdrop_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const NavigationMenuBackdrop_NavigationMenuBackdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { open, mounted, transitionStatus } = useNavigationMenuRootContext();
+    const state = {
+        open,
+        transitionStatus
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                role: 'presentation',
+                hidden: !mounted,
+                style: {
+                    userSelect: 'none',
+                    WebkitUserSelect: 'none'
+                }
+            },
+            elementProps
+        ],
+        stateAttributesMapping: NavigationMenuBackdrop_stateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuBackdrop_NavigationMenuBackdrop.displayName = "NavigationMenuBackdrop";
+const NavigationMenuPopup_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const NavigationMenuPopup_NavigationMenuPopup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { open, transitionStatus, setPopupElement } = useNavigationMenuRootContext();
+    const positioning = useNavigationMenuPositionerContext();
+    const direction = useDirection();
+    const id = useBaseUiId(idProp);
+    const state = {
+        open,
+        transitionStatus,
+        side: positioning.side,
+        align: positioning.align,
+        anchorHidden: positioning.anchorHidden
+    };
+    let isOriginSide = 'top' === positioning.side;
+    let isPhysicalLeft = 'left' === positioning.side;
+    if ('rtl' === direction) {
+        isOriginSide = isOriginSide || 'inline-end' === positioning.side;
+        isPhysicalLeft = isPhysicalLeft || 'inline-end' === positioning.side;
+    } else {
+        isOriginSide = isOriginSide || 'inline-start' === positioning.side;
+        isPhysicalLeft = isPhysicalLeft || 'inline-start' === positioning.side;
+    }
+    const element = useRenderElement('nav', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            setPopupElement
+        ],
+        props: [
+            {
+                id,
+                tabIndex: -1,
+                style: isOriginSide ? {
+                    position: 'absolute',
+                    ['top' === positioning.side ? 'bottom' : 'top']: '0',
+                    [isPhysicalLeft ? 'right' : 'left']: '0'
+                } : {}
+            },
+            elementProps
+        ],
+        stateAttributesMapping: NavigationMenuPopup_stateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuPopup_NavigationMenuPopup.displayName = "NavigationMenuPopup";
+const NavigationMenuArrow_NavigationMenuArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { open } = useNavigationMenuRootContext();
+    const { arrowRef, side, align, arrowUncentered, arrowStyles } = useNavigationMenuPositionerContext();
+    const state = {
+        open,
+        side,
+        align,
+        uncentered: arrowUncentered
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            arrowRef
+        ],
+        props: [
+            {
+                style: arrowStyles,
+                'aria-hidden': true
+            },
+            elementProps
+        ],
+        stateAttributesMapping: popupStateMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuArrow_NavigationMenuArrow.displayName = "NavigationMenuArrow";
+const NavigationMenuIcon_NavigationMenuIcon = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { value: itemValue } = useNavigationMenuItemContext();
+    const { open, value } = useNavigationMenuRootContext();
+    const isActiveItem = open && value === itemValue;
+    const state = {
+        open: isActiveItem
+    };
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                'aria-hidden': true,
+                children: '▼'
+            },
+            elementProps
+        ],
+        stateAttributesMapping: triggerOpenStateMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuIcon_NavigationMenuIcon.displayName = "NavigationMenuIcon";
+const NavigationMenuPortal_NavigationMenuPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const { keepMounted = false, ...portalProps } = props;
+    const { mounted } = useNavigationMenuRootContext();
+    const shouldRender = mounted || keepMounted;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(NavigationMenuPortalContext.Provider, {
+        value: keepMounted,
+        children: /*#__PURE__*/ jsx(FloatingPortal_FloatingPortal, {
+            ref: forwardedRef,
+            ...portalProps
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) NavigationMenuPortal_NavigationMenuPortal.displayName = "NavigationMenuPortal";
 const NavigationMenu_module = {
     root: "root-Gth795",
     list: "list-kus7O6",
@@ -9,68 +1026,68 @@ const NavigationMenu_module = {
     popup: "popup-jElt_o",
     link: "link-jrEqu4"
 };
-const List = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.List, {
+const List = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuList_NavigationMenuList, {
         ref: ref,
         className: clsx(NavigationMenu_module.list, className),
         ...props
     }));
-const Item = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Item, {
+const Item = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuItem_NavigationMenuItem, {
         ref: ref,
         className: clsx(NavigationMenu_module.item, className),
         ...props
     }));
-const Content = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Content, {
+const Content = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuContent_NavigationMenuContent, {
         ref: ref,
         className: clsx(NavigationMenu_module.content, className),
         ...props
     }));
-const Trigger = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Trigger, {
+const Trigger = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuTrigger_NavigationMenuTrigger, {
         ref: ref,
         className: clsx(NavigationMenu_module.trigger, className),
         ...props
     }));
-const Positioner = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Positioner, {
+const Positioner = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuPositioner_NavigationMenuPositioner, {
         ref: ref,
         className: clsx(NavigationMenu_module.positioner, className),
         ...props
     }));
-const Viewport = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Viewport, {
+const Viewport = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuViewport_NavigationMenuViewport, {
         ref: ref,
         className: clsx(NavigationMenu_module.viewport, className),
         ...props
     }));
-const Backdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Backdrop, {
+const Backdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuBackdrop_NavigationMenuBackdrop, {
         ref: ref,
         className: clsx(NavigationMenu_module.backdrop, className),
         ...props
     }));
-const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Popup, {
+const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuPopup_NavigationMenuPopup, {
         ref: ref,
         className: clsx(NavigationMenu_module.popup, className),
         ...props
     }));
-const Arrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Arrow, {
+const Arrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuArrow_NavigationMenuArrow, {
         ref: ref,
         className: clsx(NavigationMenu_module.arrow, className),
         ...props
     }));
-const Link = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Link, {
+const Link = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuLink_NavigationMenuLink, {
         ref: ref,
         className: clsx(NavigationMenu_module.link, className),
         ...props
     }));
-const Icon = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Icon, {
+const Icon = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuIcon_NavigationMenuIcon, {
         ref: ref,
         className: clsx(NavigationMenu_module.icon, className),
         ...props
     }));
 function Root({ className, ...props }) {
-    return /*#__PURE__*/ jsx(NavigationMenu.Root, {
+    return /*#__PURE__*/ jsx(NavigationMenuRoot_NavigationMenuRoot, {
         ...props,
         className: clsx(NavigationMenu_module.root, className)
     });
 }
-const NavigationMenu_NavigationMenu = {
+const NavigationMenu = {
     List: List,
     Item: Item,
     Content: Content,
@@ -83,6 +1100,6 @@ const NavigationMenu_NavigationMenu = {
     Link: Link,
     Icon: Icon,
     Root: Root,
-    Portal: NavigationMenu.Portal
+    Portal: NavigationMenuPortal_NavigationMenuPortal
 };
-export { NavigationMenu_NavigationMenu as NavigationMenu };
+export { NavigationMenu };