@jobber/components 9.3.0 → 9.5.0

package/dist/MenuSubmenuTrigger-cjs.js

@@ -3,12 +3,11 @@
 var React = require('react');
 var useRenderElement = require('./useRenderElement-cjs.js');
 var useScrollLock = require('./useScrollLock-cjs.js');
-var useButton = require('./useButton-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
 var useCompositeListItem = require('./useCompositeListItem-cjs.js');
-var isElementDisabled = require('./isElementDisabled-cjs.js');
+var SelectGroupLabel = require('./SelectGroupLabel-cjs.js');
 var scrollEdges = require('./scrollEdges-cjs.js');
-var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
+var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var ScrollAreaViewport = require('./ScrollAreaViewport-cjs.js');
 var ReactDOM = require('react-dom');
 
@@ -33,7 +32,7 @@ var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 var ReactDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactDOM);
 
 function resolveValue(value, pointerType) {
-  if (pointerType != null && !useButton.isMouseLikePointerType(pointerType)) {
+  if (pointerType != null && !useScrollLock.isMouseLikePointerType(pointerType)) {
     return 0;
   }
   if (typeof value === 'function') {
@@ -61,7 +60,7 @@ function isHoverOpenEvent(openEventType) {
   return openEventType?.includes('mouse') && openEventType !== 'mousedown';
 }
 
-const isMacSafari = useButton.mac && useScrollLock.webkit;
+const isMacSafari = useScrollLock.mac && useScrollLock.webkit;
 /**
  * Opens the floating element while the reference element has focus, like CSS
  * `:focus`.
@@ -81,20 +80,20 @@ function useFocus(context, props = {}) {
   // Track which reference should be blocked from re-opening after Escape/press dismissal.
   const blockedReferenceRef = React__namespace.useRef(null);
   const keyboardModalityRef = React__namespace.useRef(true);
-  const timeout = useButton.useTimeout();
+  const timeout = useScrollLock.useTimeout();
   React__namespace.useEffect(() => {
     const domReference = store.select('domReferenceElement');
     if (!enabled) {
       return undefined;
     }
-    const win = floatingUi_utils_dom.getWindow(domReference);
+    const win = floatingUi_utils.getWindow(domReference);
 
     // If the reference was focused and the user left the tab/window, and the
     // floating element was not open, the focus should be blocked when they
     // return to the tab/window.
     function onBlur() {
       const currentDomReference = store.select('domReferenceElement');
-      if (!store.select('open') && floatingUi_utils_dom.isHTMLElement(currentDomReference) && currentDomReference === useButton.activeElement(useButton.ownerDocument(currentDomReference))) {
+      if (!store.select('open') && floatingUi_utils.isHTMLElement(currentDomReference) && currentDomReference === useScrollLock.activeElement(useScrollLock.ownerDocument(currentDomReference))) {
         blockFocusRef.current = true;
       }
     }
@@ -104,16 +103,16 @@ function useFocus(context, props = {}) {
     function onPointerDown() {
       keyboardModalityRef.current = false;
     }
-    return useScrollLock.mergeCleanups(useButton.addEventListener(win, 'blur', onBlur), isMacSafari && useButton.addEventListener(win, 'keydown', onKeyDown, true), isMacSafari && useButton.addEventListener(win, 'pointerdown', onPointerDown, true));
+    return useScrollLock.mergeCleanups(useScrollLock.addEventListener(win, 'blur', onBlur), isMacSafari && useScrollLock.addEventListener(win, 'keydown', onKeyDown, true), isMacSafari && useScrollLock.addEventListener(win, 'pointerdown', onPointerDown, true));
   }, [store, enabled]);
   React__namespace.useEffect(() => {
     if (!enabled) {
       return undefined;
     }
     function onOpenChangeLocal(details) {
-      if (details.reason === useButton.triggerPress || details.reason === useButton.escapeKey) {
+      if (details.reason === useScrollLock.triggerPress || details.reason === useScrollLock.escapeKey) {
         const referenceElement = store.select('domReferenceElement');
-        if (floatingUi_utils_dom.isElement(referenceElement)) {
+        if (floatingUi_utils.isElement(referenceElement)) {
           blockedReferenceRef.current = referenceElement;
           blockFocusRef.current = true;
         }
@@ -141,8 +140,8 @@ function useFocus(context, props = {}) {
           }
           resetBlockedFocus();
         }
-        const target = useButton.getTarget(event.nativeEvent);
-        if (floatingUi_utils_dom.isElement(target)) {
+        const target = useScrollLock.getTarget(event.nativeEvent);
+        if (floatingUi_utils.isElement(target)) {
           // Safari fails to match `:focus-visible` if focus was initially
           // outside the document.
           if (isMacSafari && !event.relatedTarget) {
@@ -160,14 +159,14 @@ function useFocus(context, props = {}) {
         } = event;
         const delayValue = typeof delay === 'function' ? delay() : delay;
         if (store.select('open') && movedFromOtherEnabledTrigger || delayValue === 0 || delayValue === undefined) {
-          store.setOpen(true, useButton.createChangeEventDetails(useButton.triggerFocus, nativeEvent, currentTarget));
+          store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.triggerFocus, nativeEvent, currentTarget));
           return;
         }
         timeout.start(delayValue, () => {
           if (blockFocusRef.current) {
             return;
           }
-          store.setOpen(true, useButton.createChangeEventDetails(useButton.triggerFocus, nativeEvent, currentTarget));
+          store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.triggerFocus, nativeEvent, currentTarget));
         });
       },
       onBlur(event) {
@@ -177,12 +176,12 @@ function useFocus(context, props = {}) {
 
         // Hit the non-modal focus management portal guard. Focus will be
         // moved into the floating element immediately after.
-        const movedToFocusGuard = floatingUi_utils_dom.isElement(relatedTarget) && relatedTarget.hasAttribute(useScrollLock.createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';
+        const movedToFocusGuard = floatingUi_utils.isElement(relatedTarget) && relatedTarget.hasAttribute(useScrollLock.createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';
 
         // Wait for the window blur listener to fire.
         timeout.start(0, () => {
           const domReference = store.select('domReferenceElement');
-          const activeEl = useButton.activeElement(useButton.ownerDocument(domReference));
+          const activeEl = useScrollLock.activeElement(useScrollLock.ownerDocument(domReference));
 
           // Focus left the page, keep it open.
           if (!relatedTarget && activeEl === domReference) {
@@ -196,7 +195,7 @@ function useFocus(context, props = {}) {
           // as it will only point to the shadow host of the newly focused element
           // and not the element that actually has received focus if it is located
           // inside a shadow root.
-          if (useButton.contains(dataRef.current.floatingContext?.refs.floating.current, activeEl) || useButton.contains(domReference, activeEl) || movedToFocusGuard) {
+          if (useScrollLock.contains(dataRef.current.floatingContext?.refs.floating.current, activeEl) || useScrollLock.contains(domReference, activeEl) || movedToFocusGuard) {
             return;
           }
 
@@ -207,7 +206,7 @@ function useFocus(context, props = {}) {
           if (useScrollLock.isTargetInsideEnabledTrigger(nextFocusedElement, store.context.triggerElements)) {
             return;
           }
-          store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerFocus, nativeEvent));
+          store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.triggerFocus, nativeEvent));
         });
       }
     };
@@ -229,8 +228,8 @@ class HoverInteraction {
     this.pointerEventsReferenceElement = null;
     this.pointerEventsFloatingElement = null;
     this.restTimeoutPending = false;
-    this.openChangeTimeout = new useButton.Timeout();
-    this.restTimeout = new useButton.Timeout();
+    this.openChangeTimeout = new useScrollLock.Timeout();
+    this.restTimeout = new useScrollLock.Timeout();
     this.handleCloseOptions = undefined;
   }
   static create() {
@@ -287,7 +286,7 @@ function useHoverInteractionSharedState(store) {
   if (!data.hoverInteractionState) {
     data.hoverInteractionState = instance;
   }
-  useButton.useOnMount(data.hoverInteractionState.disposeEffect);
+  useScrollLock.useOnMount(data.hoverInteractionState.disposeEffect);
   return data.hoverInteractionState;
 }
 
@@ -310,17 +309,17 @@ function useHoverFloatingInteraction(context, parameters = {}) {
   const tree = useScrollLock.useFloatingTree();
   const parentId = useScrollLock.useFloatingParentNodeId();
   const instance = useHoverInteractionSharedState(store);
-  const childClosedTimeout = useButton.useTimeout();
-  const isClickLikeOpenEvent$1 = useButton.useStableCallback(() => {
+  const childClosedTimeout = useScrollLock.useTimeout();
+  const isClickLikeOpenEvent$1 = useScrollLock.useStableCallback(() => {
     return isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside);
   });
-  const isHoverOpen = useButton.useStableCallback(() => {
+  const isHoverOpen = useScrollLock.useStableCallback(() => {
     return isHoverOpenEvent(dataRef.current.openEvent?.type);
   });
-  const clearPointerEvents = useButton.useStableCallback(() => {
+  const clearPointerEvents = useScrollLock.useStableCallback(() => {
     clearSafePolygonPointerEventsMutation(instance);
   });
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (!open) {
       instance.pointerType = undefined;
       instance.restTimeoutPending = false;
@@ -331,14 +330,14 @@ function useHoverFloatingInteraction(context, parameters = {}) {
   React__namespace.useEffect(() => {
     return clearPointerEvents;
   }, [clearPointerEvents]);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (!enabled) {
       return undefined;
     }
-    if (open && instance.handleCloseOptions?.blockPointerEvents && isHoverOpen() && floatingUi_utils_dom.isElement(domReferenceElement) && floatingElement) {
+    if (open && instance.handleCloseOptions?.blockPointerEvents && isHoverOpen() && floatingUi_utils.isElement(domReferenceElement) && floatingElement) {
       const ref = domReferenceElement;
       const floatingEl = floatingElement;
-      const doc = useButton.ownerDocument(floatingElement);
+      const doc = useScrollLock.ownerDocument(floatingElement);
       const parentFloating = tree?.nodesRef.current.find(node => node.id === parentId)?.context?.elements.floating;
       if (parentFloating) {
         parentFloating.style.pointerEvents = '';
@@ -371,7 +370,7 @@ function useHoverFloatingInteraction(context, parameters = {}) {
     function closeWithDelay(event) {
       const closeDelay = getDelay(closeDelayProp, 'close', instance.pointerType);
       const close = () => {
-        store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerHover, event));
+        store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event));
         tree?.events.emit('floating.closed', event);
       };
       if (closeDelay) {
@@ -382,7 +381,7 @@ function useHoverFloatingInteraction(context, parameters = {}) {
       }
     }
     function handleInteractInside(event) {
-      const target = useButton.getTarget(event);
+      const target = useScrollLock.getTarget(event);
       if (!useScrollLock.isInteractiveElement(target)) {
         instance.interactedInside = false;
         return;
@@ -407,7 +406,7 @@ function useHoverFloatingInteraction(context, parameters = {}) {
       }
       const currentNodeId = dataRef.current.floatingContext?.nodeId ?? nodeIdProp;
       const relatedTarget = event.relatedTarget;
-      const isMovingIntoDescendantFloating = tree && currentNodeId && floatingUi_utils_dom.isElement(relatedTarget) && useScrollLock.getNodeChildren(tree.nodesRef.current, currentNodeId, false).some(node => useButton.contains(node.context?.elements.floating, relatedTarget));
+      const isMovingIntoDescendantFloating = tree && currentNodeId && floatingUi_utils.isElement(relatedTarget) && useScrollLock.getNodeChildren(tree.nodesRef.current, currentNodeId, false).some(node => useScrollLock.contains(node.context?.elements.floating, relatedTarget));
       if (isMovingIntoDescendantFloating) {
         return;
       }
@@ -429,12 +428,12 @@ function useHoverFloatingInteraction(context, parameters = {}) {
       // Allow the mouseenter event to fire in case child was closed because mouse moved into parent.
       childClosedTimeout.start(0, () => {
         tree.events.off('floating.closed', onNodeClosed);
-        store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerHover, event));
+        store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event));
         tree.events.emit('floating.closed', event);
       });
     }
     const floating = floatingElement;
-    return useScrollLock.mergeCleanups(floating && useButton.addEventListener(floating, 'mouseenter', onFloatingMouseEnter), floating && useButton.addEventListener(floating, 'mouseleave', onFloatingMouseLeave), floating && useButton.addEventListener(floating, 'pointerdown', handleInteractInside, true), () => {
+    return useScrollLock.mergeCleanups(floating && useScrollLock.addEventListener(floating, 'mouseenter', onFloatingMouseEnter), floating && useScrollLock.addEventListener(floating, 'mouseleave', onFloatingMouseLeave), floating && useScrollLock.addEventListener(floating, 'pointerdown', handleInteractInside, true), () => {
       tree?.events.off('floating.closed', onNodeClosed);
     });
   }, [enabled, floatingElement, store, dataRef, closeDelayProp, nodeIdProp, isHoverOpen, isClickLikeOpenEvent$1, clearPointerEvents, instance, tree, parentId, childClosedTimeout]);
@@ -471,42 +470,42 @@ function useHoverReferenceInteraction(context, props = {}) {
   const tree = useScrollLock.useFloatingTree(externalTree);
   const instance = useHoverInteractionSharedState(store);
   const isHoverCloseActiveRef = React__namespace.useRef(false);
-  const handleCloseRef = useButton.useValueAsRef(handleClose);
-  const delayRef = useButton.useValueAsRef(delay);
-  const restMsRef = useButton.useValueAsRef(restMs);
-  const enabledRef = useButton.useValueAsRef(enabled);
-  const shouldOpenRef = useButton.useValueAsRef(shouldOpenProp);
-  const isClosingRef = useButton.useValueAsRef(isClosing);
-  const isClickLikeOpenEvent$1 = useButton.useStableCallback(() => {
+  const handleCloseRef = useScrollLock.useValueAsRef(handleClose);
+  const delayRef = useScrollLock.useValueAsRef(delay);
+  const restMsRef = useScrollLock.useValueAsRef(restMs);
+  const enabledRef = useScrollLock.useValueAsRef(enabled);
+  const shouldOpenRef = useScrollLock.useValueAsRef(shouldOpenProp);
+  const isClosingRef = useScrollLock.useValueAsRef(isClosing);
+  const isClickLikeOpenEvent$1 = useScrollLock.useStableCallback(() => {
     return isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside);
   });
-  const checkShouldOpen = useButton.useStableCallback(() => {
+  const checkShouldOpen = useScrollLock.useStableCallback(() => {
     return shouldOpenRef.current?.() !== false;
   });
-  const isOverInactiveTrigger = useButton.useStableCallback((currentDomReference, currentTarget, target) => {
+  const isOverInactiveTrigger = useScrollLock.useStableCallback((currentDomReference, currentTarget, target) => {
     const allTriggers = store.context.triggerElements;
 
     // Fast path for normal usage where handlers are attached directly to triggers.
     if (allTriggers.hasElement(currentTarget)) {
-      return !currentDomReference || !useButton.contains(currentDomReference, currentTarget);
+      return !currentDomReference || !useScrollLock.contains(currentDomReference, currentTarget);
     }
 
     // Fallback for delegated/wrapper usage where currentTarget may be outside the trigger map.
-    if (!floatingUi_utils_dom.isElement(target)) {
+    if (!floatingUi_utils.isElement(target)) {
       return false;
     }
     const targetElement = target;
-    return allTriggers.hasMatchingElement(trigger => useButton.contains(trigger, targetElement)) && (!currentDomReference || !useButton.contains(currentDomReference, targetElement));
+    return allTriggers.hasMatchingElement(trigger => useScrollLock.contains(trigger, targetElement)) && (!currentDomReference || !useScrollLock.contains(currentDomReference, targetElement));
   });
-  const cleanupMouseMoveHandler = useButton.useStableCallback(() => {
+  const cleanupMouseMoveHandler = useScrollLock.useStableCallback(() => {
     if (!instance.handler) {
       return;
     }
-    const doc = useButton.ownerDocument(store.select('domReferenceElement'));
+    const doc = useScrollLock.ownerDocument(store.select('domReferenceElement'));
     doc.removeEventListener('mousemove', instance.handler);
     instance.handler = undefined;
   });
-  const clearPointerEvents = useButton.useStableCallback(() => {
+  const clearPointerEvents = useScrollLock.useStableCallback(() => {
     clearSafePolygonPointerEventsMutation(instance);
   });
   if (isActiveTrigger) {
@@ -523,7 +522,7 @@ function useHoverReferenceInteraction(context, props = {}) {
     }
     function onOpenChangeLocal(details) {
       if (!details.open) {
-        isHoverCloseActiveRef.current = details.reason === useButton.triggerHover;
+        isHoverCloseActiveRef.current = details.reason === useScrollLock.triggerHover;
         cleanupMouseMoveHandler();
         instance.openChangeTimeout.clear();
         instance.restTimeout.clear();
@@ -546,23 +545,23 @@ function useHoverReferenceInteraction(context, props = {}) {
       const closeDelay = getDelay(delayRef.current, 'close', instance.pointerType);
       if (closeDelay) {
         instance.openChangeTimeout.start(closeDelay, () => {
-          store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerHover, event));
+          store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event));
           tree?.events.emit('floating.closed', event);
         });
       } else if (runElseBranch) {
         instance.openChangeTimeout.clear();
-        store.setOpen(false, useButton.createChangeEventDetails(useButton.triggerHover, event));
+        store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event));
         tree?.events.emit('floating.closed', event);
       }
     }
     const trigger = triggerElementRef.current ?? (isActiveTrigger ? store.select('domReferenceElement') : null);
-    if (!floatingUi_utils_dom.isElement(trigger)) {
+    if (!floatingUi_utils.isElement(trigger)) {
       return undefined;
     }
     function onMouseEnter(event) {
       instance.openChangeTimeout.clear();
       instance.blockMouseMove = false;
-      if (mouseOnly && !useButton.isMouseLikePointerType(instance.pointerType)) {
+      if (mouseOnly && !useScrollLock.isMouseLikePointerType(instance.pointerType)) {
         return;
       }
 
@@ -570,15 +569,15 @@ function useHoverReferenceInteraction(context, props = {}) {
       // This will be handled by `onMouseMove`.
       const restMsValue = getRestMs(restMsRef.current);
       const openDelay = getDelay(delayRef.current, 'open', instance.pointerType);
-      const eventTarget = useButton.getTarget(event);
+      const eventTarget = useScrollLock.getTarget(event);
       const currentTarget = event.currentTarget ?? null;
       const currentDomReference = store.select('domReferenceElement');
       let triggerNode = currentTarget;
 
       // Wrapper/delegated mode: resolve the actual trigger from the event target.
-      if (floatingUi_utils_dom.isElement(eventTarget) && !store.context.triggerElements.hasElement(eventTarget)) {
+      if (floatingUi_utils.isElement(eventTarget) && !store.context.triggerElements.hasElement(eventTarget)) {
         for (const triggerElement of store.context.triggerElements.elements()) {
-          if (useButton.contains(triggerElement, eventTarget)) {
+          if (useScrollLock.contains(triggerElement, eventTarget)) {
             triggerNode = triggerElement;
             break;
           }
@@ -587,14 +586,14 @@ function useHoverReferenceInteraction(context, props = {}) {
 
       // Wrapper/delegated mode fallback: if the wrapper contains the active trigger,
       // treat this as re-entering that active trigger.
-      if (floatingUi_utils_dom.isElement(currentTarget) && floatingUi_utils_dom.isElement(currentDomReference) && !store.context.triggerElements.hasElement(currentTarget) && useButton.contains(currentTarget, currentDomReference)) {
+      if (floatingUi_utils.isElement(currentTarget) && floatingUi_utils.isElement(currentDomReference) && !store.context.triggerElements.hasElement(currentTarget) && useScrollLock.contains(currentTarget, currentDomReference)) {
         triggerNode = currentDomReference;
       }
       const isOverInactive = triggerNode == null ? false : isOverInactiveTrigger(currentDomReference, triggerNode, eventTarget);
       const isOpen = store.select('open');
       const isInClosingTransition = isClosingRef.current?.() ?? store.select('transitionStatus') === 'ending';
       const isHoverCloseTransition = !isOpen && isInClosingTransition && isHoverCloseActiveRef.current;
-      const isReenteringSameTriggerDuringCloseTransition = !isOverInactive && floatingUi_utils_dom.isElement(triggerNode) && floatingUi_utils_dom.isElement(currentDomReference) && useButton.contains(currentDomReference, triggerNode) && isHoverCloseTransition;
+      const isReenteringSameTriggerDuringCloseTransition = !isOverInactive && floatingUi_utils.isElement(triggerNode) && floatingUi_utils.isElement(currentDomReference) && useScrollLock.contains(currentDomReference, triggerNode) && isHoverCloseTransition;
       const isRestOnlyDelay = restMsValue > 0 && !openDelay;
       const shouldOpenImmediately = isOverInactive && (isOpen || isHoverCloseTransition) || isReenteringSameTriggerDuringCloseTransition;
       const shouldOpen = !isOpen || isOverInactive;
@@ -603,7 +602,7 @@ function useHoverReferenceInteraction(context, props = {}) {
       // a hover-driven close transition (including same-trigger re-entry).
       if (shouldOpenImmediately) {
         if (checkShouldOpen()) {
-          store.setOpen(true, useButton.createChangeEventDetails(useButton.triggerHover, event, triggerNode));
+          store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event, triggerNode));
         }
         return;
       }
@@ -613,12 +612,12 @@ function useHoverReferenceInteraction(context, props = {}) {
       if (openDelay) {
         instance.openChangeTimeout.start(openDelay, () => {
           if (shouldOpen && checkShouldOpen()) {
-            store.setOpen(true, useButton.createChangeEventDetails(useButton.triggerHover, event, triggerNode));
+            store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event, triggerNode));
           }
         });
       } else if (shouldOpen) {
         if (checkShouldOpen()) {
-          store.setOpen(true, useButton.createChangeEventDetails(useButton.triggerHover, event, triggerNode));
+          store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, event, triggerNode));
         }
       }
     }
@@ -629,7 +628,7 @@ function useHoverReferenceInteraction(context, props = {}) {
       }
       cleanupMouseMoveHandler();
       const domReferenceElement = store.select('domReferenceElement');
-      const doc = useButton.ownerDocument(domReferenceElement);
+      const doc = useScrollLock.ownerDocument(domReferenceElement);
       instance.restTimeout.clear();
       instance.restTimeoutPending = false;
       const handleCloseContextBase = dataRef.current.floatingContext ?? getHandleCloseContext?.();
@@ -658,17 +657,17 @@ function useHoverReferenceInteraction(context, props = {}) {
         instance.handler(event);
         return;
       }
-      const shouldClose = instance.pointerType === 'touch' ? !useButton.contains(store.select('floatingElement'), event.relatedTarget) : true;
+      const shouldClose = instance.pointerType === 'touch' ? !useScrollLock.contains(store.select('floatingElement'), event.relatedTarget) : true;
       if (shouldClose) {
         closeWithDelay(event);
       }
     }
     if (move) {
-      return useScrollLock.mergeCleanups(useButton.addEventListener(trigger, 'mousemove', onMouseEnter, {
+      return useScrollLock.mergeCleanups(useScrollLock.addEventListener(trigger, 'mousemove', onMouseEnter, {
         once: true
-      }), useButton.addEventListener(trigger, 'mouseenter', onMouseEnter), useButton.addEventListener(trigger, 'mouseleave', onMouseLeave));
+      }), useScrollLock.addEventListener(trigger, 'mouseenter', onMouseEnter), useScrollLock.addEventListener(trigger, 'mouseleave', onMouseLeave));
     }
-    return useScrollLock.mergeCleanups(useButton.addEventListener(trigger, 'mouseenter', onMouseEnter), useButton.addEventListener(trigger, 'mouseleave', onMouseLeave));
+    return useScrollLock.mergeCleanups(useScrollLock.addEventListener(trigger, 'mouseenter', onMouseEnter), useScrollLock.addEventListener(trigger, 'mouseleave', onMouseLeave));
   }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, store, enabled, handleCloseRef, instance, isActiveTrigger, isOverInactiveTrigger, isClickLikeOpenEvent$1, mouseOnly, move, restMsRef, triggerElementRef, tree, enabledRef, getHandleCloseContext, isClosingRef, checkShouldOpen]);
   return React__namespace.useMemo(() => {
     if (!enabled) {
@@ -688,7 +687,7 @@ function useHoverReferenceInteraction(context, props = {}) {
         const currentDomReference = store.select('domReferenceElement');
         const currentOpen = store.select('open');
         const isOverInactive = isOverInactiveTrigger(currentDomReference, trigger, event.target);
-        if (mouseOnly && !useButton.isMouseLikePointerType(instance.pointerType)) {
+        if (mouseOnly && !useScrollLock.isMouseLikePointerType(instance.pointerType)) {
           return;
         }
         if (currentOpen && isOverInactive && instance.handleCloseOptions?.blockPointerEvents) {
@@ -720,7 +719,7 @@ function useHoverReferenceInteraction(context, props = {}) {
           }
           const latestOpen = store.select('open');
           if (!instance.blockMouseMove && (!latestOpen || isOverInactive) && checkShouldOpen()) {
-            store.setOpen(true, useButton.createChangeEventDetails(useButton.triggerHover, nativeEvent, trigger));
+            store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.triggerHover, nativeEvent, trigger));
           }
         }
         if (instance.pointerType === 'touch') {
@@ -781,7 +780,7 @@ function safePolygon(options = {}) {
   const {
     blockPointerEvents = false
   } = options;
-  const timeout = new useButton.Timeout();
+  const timeout = new useScrollLock.Timeout();
   const fn = ({
     x,
     y,
@@ -829,10 +828,10 @@ function safePolygon(options = {}) {
         clientX,
         clientY
       } = event;
-      const target = useButton.getTarget(event);
+      const target = useScrollLock.getTarget(event);
       const isLeave = event.type === 'mouseleave';
-      const isOverFloatingEl = useButton.contains(floating, target);
-      const isOverReferenceEl = useButton.contains(domReference, target);
+      const isOverFloatingEl = useScrollLock.contains(floating, target);
+      const isOverReferenceEl = useScrollLock.contains(domReference, target);
       if (isOverFloatingEl) {
         hasLanded = true;
         if (!isLeave) {
@@ -849,7 +848,7 @@ function safePolygon(options = {}) {
 
       // Prevent overlapping floating element from being stuck in an open-close
       // loop: https://github.com/floating-ui/floating-ui/issues/1910
-      if (isLeave && floatingUi_utils_dom.isElement(event.relatedTarget) && useButton.contains(floating, event.relatedTarget)) {
+      if (isLeave && floatingUi_utils.isElement(event.relatedTarget) && useScrollLock.contains(floating, event.relatedTarget)) {
         return undefined;
       }
       function hasOpenChildNode() {
@@ -1012,7 +1011,7 @@ function useContextMenuRootContext(optional = true) {
 
 const stateAttributesMapping$1 = {
   ...useScrollLock.popupStateMapping,
-  ...useButton.transitionStatusMapping
+  ...useScrollLock.transitionStatusMapping
 };
 
 /**
@@ -1048,7 +1047,7 @@ const MenuBackdrop = /*#__PURE__*/React__namespace.forwardRef(function MenuBackd
       role: 'presentation',
       hidden: !mounted,
       style: {
-        pointerEvents: lastOpenChangeReason === useButton.triggerHover ? 'none' : undefined,
+        pointerEvents: lastOpenChangeReason === useScrollLock.triggerHover ? 'none' : undefined,
         userSelect: 'none',
         WebkitUserSelect: 'none'
       }
@@ -1104,7 +1103,7 @@ function useMenuItemCommonProps(params) {
       if (closeOnClick) {
         menuEvents.emit('close', {
           domEvent: event,
-          reason: useButton.itemPress
+          reason: useScrollLock.itemPress
         });
       }
     },
@@ -1118,7 +1117,7 @@ function useMenuItemCommonProps(params) {
 
         // On non-macOS platforms, this mouseup belongs to the right-click gesture
         // that opened the context menu, so it must not activate an item.
-        if (isContextMenu && !useButton.mac && event.button === 2) {
+        if (isContextMenu && !useScrollLock.mac && event.button === 2) {
           return;
         }
       }
@@ -1154,7 +1153,7 @@ function useMenuItem(params) {
   const {
     getButtonProps,
     buttonRef
-  } = useButton.useButton({
+  } = useScrollLock.useButton({
     disabled,
     focusableWhenDisabled: true,
     native: nativeButton,
@@ -1218,7 +1217,7 @@ const itemMapping = {
       [MenuCheckboxItemDataAttributes.unchecked]: ''
     };
   },
-  ...useButton.transitionStatusMapping
+  ...useScrollLock.transitionStatusMapping
 };
 
 const MenuGroupContext = /*#__PURE__*/React__namespace.createContext(undefined);
@@ -1268,9 +1267,9 @@ const MenuGroupLabel = /*#__PURE__*/React__namespace.forwardRef(function MenuGro
     id: idProp,
     ...elementProps
   } = componentProps;
-  const id = useButton.useBaseUiId(idProp);
+  const id = useScrollLock.useBaseUiId(idProp);
   const setLabelId = useMenuGroupRootContext();
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     setLabelId(id);
     return () => {
       setLabelId(undefined);
@@ -1309,7 +1308,7 @@ const MenuItem = /*#__PURE__*/React__namespace.forwardRef(function MenuItem(comp
     label
   });
   const menuPositionerContext = useMenuPositionerContext(true);
-  const id = useButton.useBaseUiId(idProp);
+  const id = useScrollLock.useBaseUiId(idProp);
   const {
     store
   } = useMenuRootContext();
@@ -1362,7 +1361,7 @@ const MenuLinkItem = /*#__PURE__*/React__namespace.forwardRef(function MenuLinkI
   });
   const menuPositionerContext = useMenuPositionerContext(true);
   const nodeId = menuPositionerContext?.context.nodeId;
-  const id = useButton.useBaseUiId(idProp);
+  const id = useScrollLock.useBaseUiId(idProp);
   const {
     store
   } = useMenuRootContext();
@@ -1372,7 +1371,7 @@ const MenuLinkItem = /*#__PURE__*/React__namespace.forwardRef(function MenuLinkI
   const {
     getButtonProps,
     buttonRef
-  } = useButton.useButton({
+  } = useScrollLock.useButton({
     native: false,
     composite: true
   });
@@ -1401,7 +1400,7 @@ if (process.env.NODE_ENV !== "production") MenuLinkItem.displayName = "MenuLinkI
 
 const stateAttributesMapping = {
   ...useScrollLock.popupStateMapping,
-  ...useButton.transitionStatusMapping
+  ...useScrollLock.transitionStatusMapping
 };
 
 /**
@@ -1425,7 +1424,7 @@ const MenuPopup = /*#__PURE__*/React__namespace.forwardRef(function MenuPopup(co
     side,
     align
   } = useMenuPositionerContext();
-  const insideToolbar = isElementDisabled.useToolbarRootContext(true) != null;
+  const insideToolbar = SelectGroupLabel.useToolbarRootContext(true) != null;
   const open = store.useState('open');
   const transitionStatus = store.useState('transitionStatus');
   const popupProps = store.useState('popupProps');
@@ -1443,7 +1442,7 @@ const MenuPopup = /*#__PURE__*/React__namespace.forwardRef(function MenuPopup(co
   const disabled = store.useState('disabled');
   const openMethod = store.useState('openMethod');
   const isContextMenu = parent.type === 'context-menu';
-  useButton.useOpenChangeComplete({
+  useScrollLock.useOpenChangeComplete({
     open,
     ref: store.context.popupRef,
     onComplete() {
@@ -1454,7 +1453,7 @@ const MenuPopup = /*#__PURE__*/React__namespace.forwardRef(function MenuPopup(co
   });
   React__namespace.useEffect(() => {
     function handleClose(event) {
-      store.setOpen(false, useButton.createChangeEventDetails(event.reason, event.domEvent));
+      store.setOpen(false, useScrollLock.createChangeEventDetails(event.reason, event.domEvent));
     }
     floatingTreeRoot.events.on('close', handleClose);
     return () => {
@@ -1491,7 +1490,7 @@ const MenuPopup = /*#__PURE__*/React__namespace.forwardRef(function MenuPopup(co
     }]
   });
   let returnFocus = parent.type === undefined || isContextMenu;
-  if (triggerElement || parent.type === 'menubar' && lastOpenChangeReason !== useButton.outsidePress) {
+  if (triggerElement || parent.type === 'menubar' && lastOpenChangeReason !== useScrollLock.outsidePress) {
     returnFocus = true;
   }
   return /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingFocusManager, {
@@ -1585,7 +1584,7 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
   const floatingParentNodeId = store.useState('floatingParentNodeId');
   const domReference = floatingRootContext.useState('domReferenceElement');
   const previousTriggerRef = React__namespace.useRef(null);
-  const runOnceAnimationsFinish = useButton.useAnimationsFinished(positionerElement, false, false);
+  const runOnceAnimationsFinish = useScrollLock.useAnimationsFinished(positionerElement, false, false);
   let anchor = anchorProp;
   let sideOffset = sideOffsetProp;
   let alignOffset = alignOffsetProp;
@@ -1638,7 +1637,7 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
           store.set('hoverEnabled', false);
         }
         if (details.nodeId !== floatingNodeId && details.parentNodeId === store.select('floatingParentNodeId')) {
-          store.setOpen(false, useButton.createChangeEventDetails(useButton.siblingOpen));
+          store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.siblingOpen));
         }
       }
     }
@@ -1655,15 +1654,15 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
       if (details.open || details.nodeId !== store.select('floatingParentNodeId')) {
         return;
       }
-      const reason = details.reason ?? useButton.siblingOpen;
-      store.setOpen(false, useButton.createChangeEventDetails(reason));
+      const reason = details.reason ?? useScrollLock.siblingOpen;
+      store.setOpen(false, useScrollLock.createChangeEventDetails(reason));
     }
     floatingTreeRoot.events.on('menuopenchange', onParentClose);
     return () => {
       floatingTreeRoot.events.off('menuopenchange', onParentClose);
     };
   }, [floatingTreeRoot.events, store]);
-  const closeTimeout = useButton.useTimeout();
+  const closeTimeout = useScrollLock.useTimeout();
 
   // Clear pending close timeout when the menu closes.
   React__namespace.useEffect(() => {
@@ -1685,11 +1684,11 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
         if (delay > 0) {
           if (!closeTimeout.isStarted()) {
             closeTimeout.start(delay, () => {
-              store.setOpen(false, useButton.createChangeEventDetails(useButton.siblingOpen));
+              store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.siblingOpen));
             });
           }
         } else {
-          store.setOpen(false, useButton.createChangeEventDetails(useButton.siblingOpen));
+          store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.siblingOpen));
         }
       } else {
         // User re-hovered the submenu trigger, cancel pending close.
@@ -1712,7 +1711,7 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
   }, [floatingTreeRoot.events, open, store, floatingNodeId, floatingParentNodeId]);
 
   // Keep positioner transition behavior aligned with Popover when switching detached triggers.
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     const currentTrigger = domReference;
     const previousTrigger = previousTriggerRef.current;
     if (currentTrigger) {
@@ -1739,7 +1738,7 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
     instant: instantType
   };
   const menubarModal = parent.type === 'menubar' && parent.context.modal;
-  const popupModal = modal && lastOpenChangeReason !== useButton.triggerHover;
+  const popupModal = modal && lastOpenChangeReason !== useScrollLock.triggerHover;
   useCompositeListItem.useAnchoredPopupScrollLock(open && (menubarModal || popupModal), openMethod === 'touch', positionerElement, triggerElement);
   const element = useCompositeListItem.usePositioner(componentProps, state, {
     styles: positioner.positionerStyles,
@@ -1749,7 +1748,7 @@ const MenuPositioner = /*#__PURE__*/React__namespace.forwardRef(function MenuPos
     hidden: !mounted,
     inert: !open
   });
-  const shouldRenderBackdrop = mounted && parent.type !== 'menu' && (parent.type !== 'menubar' && modal && lastOpenChangeReason !== useButton.triggerHover || parent.type === 'menubar' && parent.context.modal);
+  const shouldRenderBackdrop = mounted && parent.type !== 'menu' && (parent.type !== 'menubar' && modal && lastOpenChangeReason !== useScrollLock.triggerHover || parent.type === 'menubar' && parent.context.modal);
 
   // cuts a hole in the backdrop to allow pointer interaction with the menubar or dropdown menu trigger element
   let backdropCutout = null;
@@ -1805,12 +1804,12 @@ const MenuRadioGroup = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__na
     ...elementProps
   } = componentProps;
   const [labelId, setLabelId] = React__namespace.useState(undefined);
-  const [value, setValueUnwrapped] = useButton.useControlled({
+  const [value, setValueUnwrapped] = useScrollLock.useControlled({
     controlled: valueProp,
     default: defaultValue,
     name: 'MenuRadioGroup'
   });
-  const setValue = useButton.useStableCallback((newValue, eventDetails) => {
+  const setValue = useScrollLock.useStableCallback((newValue, eventDetails) => {
     onValueChangeProp?.(newValue, eventDetails);
     if (eventDetails.isCanceled) {
       return;
@@ -1872,7 +1871,7 @@ const MenuRadioItem = /*#__PURE__*/React__namespace.forwardRef(function MenuRadi
     label
   });
   const menuPositionerContext = useMenuPositionerContext(true);
-  const id = useButton.useBaseUiId(idProp);
+  const id = useScrollLock.useBaseUiId(idProp);
   const {
     store
   } = useMenuRootContext();
@@ -1904,7 +1903,7 @@ const MenuRadioItem = /*#__PURE__*/React__namespace.forwardRef(function MenuRadi
     checked
   }), [disabled, highlighted, checked]);
   function handleClick(event) {
-    const details = useButton.createChangeEventDetails(useButton.itemPress, event.nativeEvent, undefined, {
+    const details = useScrollLock.createChangeEventDetails(useScrollLock.itemPress, event.nativeEvent, undefined, {
       preventUnmountOnClose() {}
     });
     setSelectedValue(value, details);
@@ -1945,8 +1944,8 @@ const MenuRadioItemIndicator = /*#__PURE__*/React__namespace.forwardRef(function
   const {
     transitionStatus,
     setMounted
-  } = useButton.useTransitionStatus(item.checked);
-  useButton.useOpenChangeComplete({
+  } = useScrollLock.useTransitionStatus(item.checked);
+  useScrollLock.useOpenChangeComplete({
     open: item.checked,
     ref: indicatorRef,
     onComplete() {
@@ -2188,8 +2187,8 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
   store.useControlledProp('openProp', openProp);
   store.useControlledProp('triggerIdProp', triggerIdProp);
   store.useContextCallback('onOpenChangeComplete', onOpenChangeComplete);
-  const rootId = useButton.useId();
-  const floatingId = useButton.useId();
+  const rootId = useScrollLock.useId();
+  const floatingId = useScrollLock.useId();
   const floatingTreeRoot = store.useState('floatingTreeRoot');
   const floatingNodeIdFromContext = useScrollLock.useFloatingNodeId(floatingTreeRoot);
   const floatingParentNodeIdFromContext = useScrollLock.useFloatingParentNodeId();
@@ -2205,9 +2204,9 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
   const floatingParentNodeId = store.useState('floatingParentNodeId');
   const openEventRef = React__namespace.useRef(null);
   const allowOutsidePressDismissalRef = React__namespace.useRef(parent.type !== 'context-menu');
-  const allowOutsidePressDismissalTimeout = useButton.useTimeout();
+  const allowOutsidePressDismissalTimeout = useScrollLock.useTimeout();
   const allowTouchToCloseRef = React__namespace.useRef(true);
-  const allowTouchToCloseTimeout = useButton.useTimeout();
+  const allowTouchToCloseTimeout = useScrollLock.useTimeout();
   const nested = floatingParentNodeId != null;
   if (process.env.NODE_ENV !== 'production') {
     if (parent.type !== undefined && modalProp !== undefined) {
@@ -2234,7 +2233,7 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
       stickIfOpen: true
     });
   });
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (contextMenuContext && !parentMenuRootContext) {
       // This is a context menu root.
       // It doesn't support detached triggers yet, so we have to sync the parent context manually.
@@ -2273,12 +2272,12 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
       allowOutsidePressDismissalRef.current = true;
     });
   }, [allowOutsidePressDismissalTimeout, open, parent.type]);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (!open && !hoverEnabled) {
       store.set('hoverEnabled', true);
     }
   }, [open, hoverEnabled, store]);
-  const setOpen = useButton.useStableCallback((nextOpen, eventDetails) => {
+  const setOpen = useScrollLock.useStableCallback((nextOpen, eventDetails) => {
     const reason = eventDetails.reason;
     if (open === nextOpen && eventDetails.trigger === activeTriggerElement && lastOpenChangeReason === reason) {
       return;
@@ -2303,7 +2302,7 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
     // Prevent the menu from closing on mobile devices that have a delayed click event.
     // In some cases the menu, when tapped, will fire the focus event first and then the click event.
     // Without this guard, the menu will close immediately after opening.
-    if (nextOpen && reason === useButton.triggerFocus) {
+    if (nextOpen && reason === useScrollLock.triggerFocus) {
       allowTouchToCloseRef.current = false;
       allowTouchToCloseTimeout.start(300, () => {
         allowTouchToCloseRef.current = true;
@@ -2312,8 +2311,8 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
       allowTouchToCloseRef.current = true;
       allowTouchToCloseTimeout.clear();
     }
-    const isKeyboardClick = (reason === useButton.triggerPress || reason === useButton.itemPress) && nativeEvent.detail === 0 && nativeEvent?.isTrusted;
-    const isDismissClose = !nextOpen && (reason === useButton.escapeKey || reason == null);
+    const isKeyboardClick = (reason === useScrollLock.triggerPress || reason === useScrollLock.itemPress) && nativeEvent.detail === 0 && nativeEvent?.isTrusted;
+    const isDismissClose = !nextOpen && (reason === useScrollLock.escapeKey || reason == null);
     const updatedState = {
       open: nextOpen,
       openChangeReason: reason
@@ -2321,7 +2320,7 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
     openEventRef.current = eventDetails.event ?? null;
     useScrollLock.setPopupOpenState(updatedState, nextOpen, eventDetails.trigger, shouldPreventUnmountOnClose());
     store.update(updatedState);
-    if (parent.type === 'menubar' && (reason === useButton.triggerFocus || reason === useButton.focusOut || reason === useButton.triggerHover || reason === useButton.listNavigation || reason === useButton.siblingOpen)) {
+    if (parent.type === 'menubar' && (reason === useScrollLock.triggerFocus || reason === useScrollLock.focusOut || reason === useScrollLock.triggerHover || reason === useScrollLock.listNavigation || reason === useScrollLock.siblingOpen)) {
       store.set('instantType', 'group');
     } else if (isKeyboardClick || isDismissClose) {
       store.set('instantType', isKeyboardClick ? 'click' : 'dismiss');
@@ -2347,7 +2346,7 @@ const MenuRoot = useScrollLock.fastComponent(function MenuRoot(props) {
     };
   }, [floatingEvents, setOpen]);
   const handleImperativeClose = React__namespace.useCallback(() => {
-    store.setOpen(false, useButton.createChangeEventDetails(useButton.imperativeAction));
+    store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.imperativeAction));
   }, [store]);
   React__namespace.useImperativeHandle(actionsRef, () => ({
     unmount: forceUnmount,
@@ -2506,7 +2505,7 @@ function useCompositeItem(params = {}) {
     highlightItemOnHover,
     highlightedIndex,
     onHighlightedIndexChange
-  } = useButton.useCompositeRootContext();
+  } = useScrollLock.useCompositeRootContext();
   const {
     ref,
     index
@@ -2568,13 +2567,13 @@ function CompositeItem(componentProps) {
 }
 
 function findRootOwnerId(node) {
-  if (floatingUi_utils_dom.isHTMLElement(node) && node.hasAttribute('data-rootownerid')) {
+  if (floatingUi_utils.isHTMLElement(node) && node.hasAttribute('data-rootownerid')) {
     return node.getAttribute('data-rootownerid') ?? undefined;
   }
-  if (floatingUi_utils_dom.isLastTraversableNode(node)) {
+  if (floatingUi_utils.isLastTraversableNode(node)) {
     return undefined;
   }
-  return findRootOwnerId(floatingUi_utils_dom.getParentNode(node));
+  return findRootOwnerId(floatingUi_utils.getParentNode(node));
 }
 
 /**
@@ -2593,7 +2592,7 @@ function useTriggerFocusGuards(store, triggerElementRef) {
   const preFocusGuardRef = React__namespace.useRef(null);
   function handlePreFocusGuardFocus(event) {
     ReactDOM__namespace.flushSync(() => {
-      store.setOpen(false, useButton.createChangeEventDetails(useButton.focusOut, event.nativeEvent, event.currentTarget));
+      store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.focusOut, event.nativeEvent, event.currentTarget));
     });
     const previousTabbable = useScrollLock.getTabbableBeforeElement(preFocusGuardRef.current);
     previousTabbable?.focus();
@@ -2604,10 +2603,10 @@ function useTriggerFocusGuards(store, triggerElementRef) {
       store.context.beforeContentFocusGuardRef.current?.focus();
     } else {
       ReactDOM__namespace.flushSync(() => {
-        store.setOpen(false, useButton.createChangeEventDetails(useButton.focusOut, event.nativeEvent, event.currentTarget));
+        store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.focusOut, event.nativeEvent, event.currentTarget));
       });
       let nextTabbable = useScrollLock.getTabbableAfterElement(store.context.triggerFocusTargetRef.current || triggerElementRef.current);
-      while (nextTabbable !== null && useButton.contains(positionerElement, nextTabbable)) {
+      while (nextTabbable !== null && useScrollLock.contains(positionerElement, nextTabbable)) {
         const prevTabbable = nextTabbable;
         nextTabbable = useScrollLock.getNextTabbable(nextTabbable);
         if (nextTabbable === prevTabbable) {
@@ -2644,7 +2643,7 @@ function useMixedToggleClickHandler(params) {
       onMouseDown: event => {
         if (mouseDownAction === 'open' && !open || mouseDownAction === 'close' && open) {
           ignoreClickRef.current = true;
-          useButton.ownerDocument(event.currentTarget).addEventListener('click', () => {
+          useScrollLock.ownerDocument(event.currentTarget).addEventListener('click', () => {
             ignoreClickRef.current = false;
           }, {
             once: true
@@ -2689,14 +2688,14 @@ const MenuTrigger = useScrollLock.fastComponentRef(function MenuTrigger(componen
   if (!store) {
     throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: <Menu.Trigger> must be either used within a <Menu.Root> component or provided with a handle.' : useRenderElement.formatErrorMessage(85));
   }
-  const thisTriggerId = useButton.useBaseUiId(idProp);
+  const thisTriggerId = useScrollLock.useBaseUiId(idProp);
   const isTriggerActive = store.useState('isTriggerActive', thisTriggerId);
   const floatingRootContext = store.useState('floatingRootContext');
   const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);
   const popupId = store.useState('triggerPopupId', thisTriggerId);
   const triggerElementRef = React__namespace.useRef(null);
   const parent = useMenuParent();
-  const compositeRootContext = useButton.useCompositeRootContext(true);
+  const compositeRootContext = useScrollLock.useCompositeRootContext(true);
   const floatingTreeRootFromContext = useScrollLock.useFloatingTree();
   const floatingTreeRoot = React__namespace.useMemo(() => {
     return floatingTreeRootFromContext ?? new useScrollLock.FloatingTreeStore();
@@ -2721,7 +2720,7 @@ const MenuTrigger = useScrollLock.fastComponentRef(function MenuTrigger(componen
   const {
     getButtonProps,
     buttonRef
-  } = useButton.useButton({
+  } = useScrollLock.useButton({
     disabled,
     native: nativeButton
   });
@@ -2731,15 +2730,15 @@ const MenuTrigger = useScrollLock.fastComponentRef(function MenuTrigger(componen
     }
   }, [store, isOpenedByThisTrigger, parent.type]);
   const triggerRef = React__namespace.useRef(null);
-  const allowMouseUpTriggerTimeout = useButton.useTimeout();
-  const handleDocumentMouseUp = useButton.useStableCallback(mouseEvent => {
+  const allowMouseUpTriggerTimeout = useScrollLock.useTimeout();
+  const handleDocumentMouseUp = useScrollLock.useStableCallback(mouseEvent => {
     if (!triggerRef.current) {
       return;
     }
     allowMouseUpTriggerTimeout.clear();
     store.context.allowMouseUpTriggerRef.current = false;
     const mouseUpTarget = mouseEvent.target;
-    if (useButton.contains(triggerRef.current, mouseUpTarget) || useButton.contains(store.select('positionerElement'), mouseUpTarget) || mouseUpTarget === triggerRef.current) {
+    if (useScrollLock.contains(triggerRef.current, mouseUpTarget) || useScrollLock.contains(store.select('positionerElement'), mouseUpTarget) || mouseUpTarget === triggerRef.current) {
       return;
     }
     if (mouseUpTarget != null && findRootOwnerId(mouseUpTarget) === store.select('rootId')) {
@@ -2751,12 +2750,12 @@ const MenuTrigger = useScrollLock.fastComponentRef(function MenuTrigger(componen
     }
     floatingTreeRoot.events.emit('close', {
       domEvent: mouseEvent,
-      reason: useButton.cancelOpen
+      reason: useScrollLock.cancelOpen
     });
   });
   React__namespace.useEffect(() => {
-    if (isOpenedByThisTrigger && store.select('lastOpenChangeReason') === useButton.triggerHover) {
-      const doc = useButton.ownerDocument(triggerRef.current);
+    if (isOpenedByThisTrigger && store.select('lastOpenChangeReason') === useScrollLock.triggerHover) {
+      const doc = useScrollLock.ownerDocument(triggerRef.current);
       doc.addEventListener('mouseup', handleDocumentMouseUp, {
         once: true
       });
@@ -2825,7 +2824,7 @@ const MenuTrigger = useScrollLock.fastComponentRef(function MenuTrigger(componen
       allowMouseUpTriggerTimeout.start(200, () => {
         store.context.allowMouseUpTriggerRef.current = true;
       });
-      const doc = useButton.ownerDocument(event.currentTarget);
+      const doc = useScrollLock.ownerDocument(event.currentTarget);
       doc.addEventListener('mouseup', handleDocumentMouseUp, {
         once: true
       });
@@ -2878,9 +2877,9 @@ if (process.env.NODE_ENV !== "production") MenuTrigger.displayName = "MenuTrigge
  * Determines whether to ignore clicks after a hover-open.
  */
 function useStickIfOpen(open, openReason) {
-  const stickIfOpenTimeout = useButton.useTimeout();
+  const stickIfOpenTimeout = useScrollLock.useTimeout();
   const [stickIfOpen, setStickIfOpen] = React__namespace.useState(false);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (open && openReason === 'trigger-hover') {
       // Only allow "patient" clicks to close the menu if it's open.
       // If they clicked within 500ms of the menu opening, keep it open.
@@ -2950,7 +2949,7 @@ const MenuSubmenuTrigger = /*#__PURE__*/React__namespace.forwardRef(function Men
   const {
     store
   } = useMenuRootContext();
-  const thisTriggerId = useButton.useBaseUiId(idProp);
+  const thisTriggerId = useScrollLock.useBaseUiId(idProp);
   const open = store.useState('open');
   const floatingRootContext = store.useState('floatingRootContext');
   const floatingTreeRoot = store.useState('floatingTreeRoot');
@@ -2983,10 +2982,10 @@ const MenuSubmenuTrigger = /*#__PURE__*/React__namespace.forwardRef(function Men
   const disabled = disabledProp || rootDisabled || parentDisabled;
   if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    useButton.useIsoLayoutEffect(() => {
+    useScrollLock.useIsoLayoutEffect(() => {
       const element = triggerElementRef.current;
-      if (element && isElementDisabled.isElementDisabled(element) && !disabled) {
-        const ownerStackMessage = useButton.SafeReact.captureOwnerStack?.() || '';
+      if (element && SelectGroupLabel.isElementDisabled(element) && !disabled) {
+        const ownerStackMessage = useScrollLock.SafeReact.captureOwnerStack?.() || '';
         useRenderElement.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}`);
       }
     });