@jobber/components 9.3.0 → 9.5.0

package/dist/ScrollAreaViewport-cjs.js

@@ -3,12 +3,10 @@
 var React = require('react');
 var useRenderElement = require('./useRenderElement-cjs.js');
 var useScrollLock = require('./useScrollLock-cjs.js');
-var useButton = require('./useButton-cjs.js');
 var scrollEdges = require('./scrollEdges-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
-var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
+var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var ReactDOM = require('react-dom');
-var clamp = require('./clamp-cjs.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -193,7 +191,7 @@ function useDialogRoot(params) {
     forceUnmount
   } = useScrollLock.useOpenStateTransitions(open, store);
   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,
@@ -238,13 +236,13 @@ function DialogInteractions({
       if ('touches' in event && event.touches.length !== 1) {
         return false;
       }
-      const target = useButton.getTarget(event);
+      const target = useScrollLock.getTarget(event);
       if (isTopmost && !disablePointerDismissal) {
         // Only close if the click occurred on the dialog's owning backdrop.
         // This supports multiple modal dialogs that aren't nested in the React tree:
         // https://github.com/mui/base-ui/issues/1320
         if (modal) {
-          return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === target || store.context.backdropRef.current === target || useButton.contains(target, popupElement) && !target?.hasAttribute('data-base-ui-portal') : true;
+          return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === target || store.context.backdropRef.current === target || useScrollLock.contains(target, popupElement) && !target?.hasAttribute('data-base-ui-portal') : true;
         }
         return true;
       }
@@ -492,7 +490,7 @@ let DialogViewportDataAttributes = function (DialogViewportDataAttributes) {
 
 const stateAttributesMapping$2 = {
   ...useScrollLock.popupStateMapping,
-  ...useButton.transitionStatusMapping,
+  ...useScrollLock.transitionStatusMapping,
   nested(value) {
     return value ? {
       [DialogViewportDataAttributes.nested]: ''
@@ -577,7 +575,7 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
   if (!store) {
     throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: <Dialog.Trigger> must be used within <Dialog.Root> or provided with a handle.' : useRenderElement.formatErrorMessage(79));
   }
-  const thisTriggerId = useButton.useBaseUiId(idProp);
+  const thisTriggerId = useScrollLock.useBaseUiId(idProp);
   const floatingContext = store.useState('floatingRootContext');
   const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);
   const popupId = store.useState('triggerPopupId', thisTriggerId);
@@ -591,7 +589,7 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
   const {
     getButtonProps,
     buttonRef
-  } = useButton.useButton({
+  } = useScrollLock.useButton({
     disabled,
     native: nativeButton
   });
@@ -671,7 +669,7 @@ let DrawerBackdropCssVars = /*#__PURE__*/function (DrawerBackdropCssVars) {
 
 const stateAttributesMapping$1 = {
   ...useScrollLock.popupStateMapping,
-  ...useButton.transitionStatusMapping
+  ...useScrollLock.transitionStatusMapping
 };
 
 /**
@@ -826,7 +824,7 @@ function resolveSnapPointValue(snapPoint, viewportHeight, rootFontSize) {
       return null;
     }
     if (snapPoint <= 1) {
-      return clamp.clamp(snapPoint, 0, 1) * viewportHeight;
+      return scrollEdges.clamp(snapPoint, 0, 1) * viewportHeight;
     }
     return snapPoint;
   }
@@ -866,8 +864,8 @@ function useDrawerSnapPoints() {
   const viewportElement = store.useState('viewportElement');
   const [viewportHeight, setViewportHeight] = React__namespace.useState(0);
   const [rootFontSize, setRootFontSize] = React__namespace.useState(16);
-  const measureViewportHeight = useButton.useStableCallback(() => {
-    const doc = useButton.ownerDocument(viewportElement);
+  const measureViewportHeight = useScrollLock.useStableCallback(() => {
+    const doc = useScrollLock.ownerDocument(viewportElement);
     const html = doc.documentElement;
     if (viewportElement) {
       setViewportHeight(viewportElement.offsetHeight);
@@ -880,7 +878,7 @@ function useDrawerSnapPoints() {
       setRootFontSize(fontSize);
     }
   });
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     measureViewportHeight();
     if (!viewportElement || typeof ResizeObserver !== 'function') {
       return undefined;
@@ -904,7 +902,7 @@ function useDrawerSnapPoints() {
       if (resolvedHeight === null || !Number.isFinite(resolvedHeight)) {
         return null;
       }
-      const clampedHeight = clamp.clamp(resolvedHeight, 0, maxHeight);
+      const clampedHeight = scrollEdges.clamp(resolvedHeight, 0, maxHeight);
       return {
         value,
         height: clampedHeight,
@@ -944,7 +942,7 @@ function useDrawerSnapPoints() {
     if (resolvedHeight === null || !Number.isFinite(resolvedHeight)) {
       return undefined;
     }
-    const clampedHeight = clamp.clamp(resolvedHeight, 0, maxHeight);
+    const clampedHeight = scrollEdges.clamp(resolvedHeight, 0, maxHeight);
     return findClosestSnapPoint(clampedHeight, resolvedSnapPoints) ?? undefined;
   }, [activeSnapPoint, popupHeight, resolvedSnapPoints, rootFontSize, viewportHeight]);
   return {
@@ -1021,7 +1019,7 @@ function removeCSSVariableInheritance$1() {
 }
 const stateAttributesMapping = {
   ...useScrollLock.popupStateMapping,
-  ...useButton.transitionStatusMapping,
+  ...useScrollLock.transitionStatusMapping,
   expanded(value) {
     return value ? {
       [DrawerPopupDataAttributes.expanded]: ''
@@ -1111,12 +1109,12 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       if (swipe) {
         return;
       }
-      const ownerStackMessage = useButton.SafeReact.captureOwnerStack?.() || '';
+      const ownerStackMessage = useScrollLock.SafeReact.captureOwnerStack?.() || '';
       const message = '<Drawer.Popup> expected to be rendered within <Drawer.Viewport>. Omitting the ' + 'viewport disables drawer swipe handling and touch scroll locking. Wrap ' + '<Drawer.Popup> in <Drawer.Viewport>.';
-      useButton.error(`${message}${ownerStackMessage}`);
+      useScrollLock.error(`${message}${ownerStackMessage}`);
     }, [swipe]);
   }
-  const measureHeight = useButton.useStableCallback(() => {
+  const measureHeight = useScrollLock.useStableCallback(() => {
     const popupElement = popupRef.current;
     if (!popupElement) {
       return;
@@ -1142,7 +1140,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
     setPopupHeight(nextHeight);
     onPopupHeightChange(nextHeight);
   });
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (!mounted) {
       popupHeightRef.current = 0;
       setPopupHeight(0);
@@ -1164,7 +1162,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       resizeObserver.disconnect();
     };
   }, [measureHeight, mounted, nestedDrawerOpen, onPopupHeightChange, popupRef]);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     const syncNestedSwipeProgress = () => {
       const popupElement = popupRef.current;
       if (!popupElement) {
@@ -1206,7 +1204,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       notifyParentHasNestedDrawer(false);
     };
   }, [notifyParentHasNestedDrawer, open, transitionStatus]);
-  useButton.useOpenChangeComplete({
+  useScrollLock.useOpenChangeComplete({
     open,
     ref: popupRef,
     onComplete() {
@@ -1343,15 +1341,15 @@ function DrawerRoot(props) {
   const [nestedSwipeProgressStore] = React__namespace.useState(createNestedSwipeProgressStore);
   const resolvedDefaultSnapPoint = defaultSnapPoint !== undefined ? defaultSnapPoint : snapPoints?.[0] ?? null;
   const isSnapPointControlled = snapPointProp !== undefined;
-  const [activeSnapPoint, setActiveSnapPointUnwrapped] = useButton.useControlled({
+  const [activeSnapPoint, setActiveSnapPointUnwrapped] = useScrollLock.useControlled({
     controlled: snapPointProp,
     default: resolvedDefaultSnapPoint,
     name: 'Drawer',
     state: 'snapPoint'
   });
   const isNestedDrawerOpenRef = React__namespace.useRef(false);
-  const setActiveSnapPoint = useButton.useStableCallback((nextSnapPoint, eventDetails) => {
-    const resolvedEventDetails = eventDetails ?? useButton.createChangeEventDetails(useButton.none);
+  const setActiveSnapPoint = useScrollLock.useStableCallback((nextSnapPoint, eventDetails) => {
+    const resolvedEventDetails = eventDetails ?? useScrollLock.createChangeEventDetails(useScrollLock.none);
     onSnapPointChange?.(nextSnapPoint, resolvedEventDetails);
     if (resolvedEventDetails.isCanceled) {
       return;
@@ -1370,13 +1368,13 @@ function DrawerRoot(props) {
     }
     return activeSnapPoint;
   }, [activeSnapPoint, isSnapPointControlled, resolvedDefaultSnapPoint, snapPoints]);
-  const onPopupHeightChange = useButton.useStableCallback(height => {
+  const onPopupHeightChange = useScrollLock.useStableCallback(height => {
     setPopupHeight(height);
     if (!isNestedDrawerOpenRef.current && height > 0) {
       setFrontmostHeight(height);
     }
   });
-  const onNestedFrontmostHeightChange = useButton.useStableCallback(height => {
+  const onNestedFrontmostHeightChange = useScrollLock.useStableCallback(height => {
     if (height > 0) {
       isNestedDrawerOpenRef.current = true;
       setFrontmostHeight(height);
@@ -1387,24 +1385,24 @@ function DrawerRoot(props) {
       setFrontmostHeight(popupHeight);
     }
   });
-  const onNestedDrawerPresenceChange = useButton.useStableCallback(present => {
+  const onNestedDrawerPresenceChange = useScrollLock.useStableCallback(present => {
     setHasNestedDrawer(present);
   });
-  const onNestedSwipeProgressChange = useButton.useStableCallback(progress => {
+  const onNestedSwipeProgressChange = useScrollLock.useStableCallback(progress => {
     nestedSwipeProgressStore.set(progress);
     notifyParentSwipeProgressChange?.(progress);
   });
-  const onNestedSwipingChange = useButton.useStableCallback(swiping => {
+  const onNestedSwipingChange = useScrollLock.useStableCallback(swiping => {
     setNestedSwiping(swiping);
     notifyParentSwipingChange?.(swiping);
   });
-  const handleOpenChange = useButton.useStableCallback((nextOpen, eventDetails) => {
+  const handleOpenChange = useScrollLock.useStableCallback((nextOpen, eventDetails) => {
     onOpenChange?.(nextOpen, eventDetails);
     if (eventDetails.isCanceled) {
       return;
     }
     if (!nextOpen && snapPoints && snapPoints.length > 0) {
-      setActiveSnapPoint(resolvedDefaultSnapPoint, useButton.createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
+      setActiveSnapPoint(resolvedDefaultSnapPoint, useScrollLock.createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
     }
   });
   const contextValue = React__namespace.useMemo(() => ({
@@ -1477,7 +1475,7 @@ function createNestedSwipeProgressStore() {
   };
 }
 function DrawerProviderReporter() {
-  const drawerId = useButton.useId();
+  const drawerId = useScrollLock.useId();
   const providerContext = useDrawerProviderContext();
   const {
     store
@@ -1503,10 +1501,10 @@ function DrawerProviderReporter() {
   React__namespace.useEffect(() => {
     // CloseWatcher enables the Android back gesture (Chromium-only).
     // Keep this Android-only for now to avoid interfering with Escape/nesting semantics on desktop due to `useDismiss`.
-    if (!open || !isTopmost || !useButton.android) {
+    if (!open || !isTopmost || !useScrollLock.android) {
       return undefined;
     }
-    const win = floatingUi_utils_dom.getWindow(popupElement);
+    const win = floatingUi_utils.getWindow(popupElement);
     const CloseWatcherCtor = win.CloseWatcher;
     if (!CloseWatcherCtor) {
       return undefined;
@@ -1515,10 +1513,10 @@ function DrawerProviderReporter() {
       if (!store.select('open')) {
         return;
       }
-      store.setOpen(false, useButton.createChangeEventDetails(useButton.closeWatcher, event));
+      store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.closeWatcher, event));
     }
     const closeWatcher = new CloseWatcherCtor();
-    const unsubscribe = useButton.addEventListener(closeWatcher, 'close', handleCloseWatcher);
+    const unsubscribe = useScrollLock.addEventListener(closeWatcher, 'close', handleCloseWatcher);
     return () => {
       unsubscribe();
       closeWatcher.destroy();
@@ -1531,7 +1529,7 @@ function isScrollable(element, axis,
 // When true, a container that overflows only once extra space is added (e.g. drawer
 // keyboard scroll slack) still counts, as long as it has layout size on the axis.
 allowOverflowIntent = false) {
-  const style = floatingUi_utils_dom.getComputedStyle(element);
+  const style = floatingUi_utils.getComputedStyle(element);
   if (axis === 'vertical') {
     const overflowY = style.overflowY;
     if (overflowY !== 'auto' && overflowY !== 'scroll') {
@@ -1549,25 +1547,25 @@ function hasScrollableAncestor(target, root, axes) {
   // `getParentNode` crosses shadow boundaries (and slots), so a target inside a shadow root
   // still walks up to scrollable ancestors in the light DOM.
   let node = target;
-  while (floatingUi_utils_dom.isHTMLElement(node) && node !== root && !floatingUi_utils_dom.isLastTraversableNode(node)) {
+  while (floatingUi_utils.isHTMLElement(node) && node !== root && !floatingUi_utils.isLastTraversableNode(node)) {
     for (const axis of axes) {
       if (isScrollable(node, axis)) {
         return true;
       }
     }
-    node = floatingUi_utils_dom.getParentNode(node);
+    node = floatingUi_utils.getParentNode(node);
   }
   return false;
 }
 function findScrollableTouchTarget(target, root, axis = 'vertical', allowOverflowIntent = false) {
   // `getParentNode` crosses shadow boundaries (and slots), so a target inside a shadow root
   // still reaches a scrollable ancestor in the light DOM.
-  let node = floatingUi_utils_dom.isHTMLElement(target) ? target : null;
-  while (floatingUi_utils_dom.isHTMLElement(node) && node !== root && !floatingUi_utils_dom.isLastTraversableNode(node)) {
+  let node = floatingUi_utils.isHTMLElement(target) ? target : null;
+  while (floatingUi_utils.isHTMLElement(node) && node !== root && !floatingUi_utils.isLastTraversableNode(node)) {
     if (isScrollable(node, axis, allowOverflowIntent)) {
       return node;
     }
-    node = floatingUi_utils_dom.getParentNode(node);
+    node = floatingUi_utils.getParentNode(node);
   }
   return isScrollable(root, axis, allowOverflowIntent) ? root : null;
 }
@@ -1598,7 +1596,7 @@ function getDisplacement(direction, deltaX, deltaY) {
   }
 }
 function getElementTransform(element) {
-  const computedStyle = floatingUi_utils_dom.getWindow(element).getComputedStyle(element);
+  const computedStyle = floatingUi_utils.getWindow(element).getComputedStyle(element);
   const transform = computedStyle.transform;
   let translateX = 0;
   let translateY = 0;
@@ -1729,7 +1727,7 @@ function useSwipeDismiss(options) {
   const lastProgressDetailsRef = React__namespace.useRef(null);
   const isSwipingRef = React__namespace.useRef(false);
   const dragStyleSnapshotRef = React__namespace.useRef(null);
-  const setSwiping = useButton.useStableCallback(nextSwiping => {
+  const setSwiping = useScrollLock.useStableCallback(nextSwiping => {
     if (isSwipingRef.current === nextSwiping) {
       return;
     }
@@ -1755,8 +1753,8 @@ function useSwipeDismiss(options) {
     });
     swipeThresholdRef.current = Math.max(0, value);
   }
-  const updateSwipeProgress = useButton.useStableCallback((progress, details) => {
-    const nextProgress = Number.isFinite(progress) ? clamp.clamp(progress, 0, 1) : 0;
+  const updateSwipeProgress = useScrollLock.useStableCallback((progress, details) => {
+    const nextProgress = Number.isFinite(progress) ? scrollEdges.clamp(progress, 0, 1) : 0;
     const progressChanged = nextProgress !== swipeProgressRef.current;
     let detailsChanged = false;
     if (details) {
@@ -1774,7 +1772,7 @@ function useSwipeDismiss(options) {
     }
     onProgress?.(nextProgress, details);
   });
-  const syncDragStyles = useButton.useStableCallback(swiping => {
+  const syncDragStyles = useScrollLock.useStableCallback(swiping => {
     const element = elementRef.current;
     if (!trackDrag || !element) {
       if (!swiping) {
@@ -1892,9 +1890,9 @@ function useSwipeDismiss(options) {
     return event.pointerType === 'touch';
   }
   function getTargetAtPoint(position, nativeEvent) {
-    const doc = useButton.ownerDocument(elementRef.current);
+    const doc = useScrollLock.ownerDocument(elementRef.current);
     const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
-    const target = elementAtPoint ?? useButton.getTarget(nativeEvent);
+    const target = elementAtPoint ?? useScrollLock.getTarget(nativeEvent);
     return target;
   }
   function findGestureScrollableTouchTarget(target, root) {
@@ -1910,7 +1908,7 @@ function useSwipeDismiss(options) {
     swipeFromScrollableRef.current = false;
     const touchLike = isTouchLikeEvent(event);
     const target = getTargetAtPoint(position, event.nativeEvent);
-    const doc = useButton.ownerDocument(elementRef.current);
+    const doc = useScrollLock.ownerDocument(elementRef.current);
     const body = doc.body;
     const scrollableTarget = touchLike && body ? findGestureScrollableTouchTarget(target, body) : null;
     const ignoreScrollableTarget = startOptions?.ignoreScrollableTarget ?? false;
@@ -2044,7 +2042,7 @@ function useSwipeDismiss(options) {
     }
     return null;
   }
-  const handleStart = useButton.useStableCallback(event => {
+  const handleStart = useScrollLock.useStableCallback(event => {
     if (!enabled) {
       return;
     }
@@ -2077,7 +2075,7 @@ function useSwipeDismiss(options) {
     if (!enabled || !isSwipingRef.current) {
       return;
     }
-    const target = useButton.getTarget(event.nativeEvent);
+    const target = useScrollLock.getTarget(event.nativeEvent);
     if (isTouchLikeEvent(event) && !swipeFromScrollableRef.current) {
       const boundaryElement = event.currentTarget;
       if (findGestureScrollableTouchTarget(target, boundaryElement)) {
@@ -2230,7 +2228,7 @@ function useSwipeDismiss(options) {
       direction: swipeDirectionDetails
     });
   }
-  const handleEnd = useButton.useStableCallback(event => {
+  const handleEnd = useScrollLock.useStableCallback(event => {
     if (!enabled) {
       return;
     }
@@ -2364,7 +2362,7 @@ function useSwipeDismiss(options) {
       updateSwipeProgress(0, progressDetails);
     }
   });
-  const handleMove = useButton.useStableCallback(event => {
+  const handleMove = useScrollLock.useStableCallback(event => {
     const currentPos = getPrimaryPointerPosition(event);
     if (!currentPos) {
       return;
@@ -2415,10 +2413,10 @@ function useSwipeDismiss(options) {
           const element = elementRef.current;
           if (pendingStartPos && element) {
             const target = getTargetAtPoint(currentPos, event.nativeEvent);
-            const doc = useButton.ownerDocument(element);
+            const doc = useScrollLock.ownerDocument(element);
             const body = doc.body;
             const scrollTarget = body ? findGestureScrollableTouchTarget(target, body) : null;
-            if (scrollTarget && (useButton.contains(element, scrollTarget) || useButton.contains(scrollTarget, element))) {
+            if (scrollTarget && (useScrollLock.contains(element, scrollTarget) || useScrollLock.contains(scrollTarget, element))) {
               const deltaX = currentPos.x - pendingStartPos.x;
               const deltaY = currentPos.y - pendingStartPos.y;
               const canSwipeFromEdge = canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY);
@@ -2474,7 +2472,7 @@ function useSwipeDismiss(options) {
 
   // Feeds a native touchmove into the swipe pipeline. Used by consumers that claim the gesture
   // in a capture-phase listener and stop it from reaching React's delegated touch handlers.
-  const moveNative = useButton.useStableCallback((nativeEvent, currentTarget) => {
+  const moveNative = useScrollLock.useStableCallback((nativeEvent, currentTarget) => {
     handleMove({
       touches: nativeEvent.touches,
       currentTarget,
@@ -2612,7 +2610,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
   const [swipeRelease, setSwipeRelease] = React__namespace.useState(null);
   const pendingSwipeCloseSnapPointRef = React__namespace.useRef(undefined);
   const resetSwipeRef = React__namespace.useRef(null);
-  const controlledDismissFrame = useButton.useAnimationFrame();
+  const controlledDismissFrame = useScrollLock.useAnimationFrame();
   const swipingRef = React__namespace.useRef(false);
   const nestedSwipeActiveRef = React__namespace.useRef(false);
   const lastPointerTypeRef = React__namespace.useRef('');
@@ -2654,7 +2652,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     if (!snapPointRange || activeSnapPointOffset === null) {
       return null;
     }
-    return clamp.clamp((activeSnapPointOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+    return scrollEdges.clamp((activeSnapPointOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
   }, [activeSnapPointOffset, snapPointRange]);
   const swipeDirections = React__namespace.useMemo(() => {
     if (snapPoints && snapPoints.length > 0 && (swipeDirection === 'down' || swipeDirection === 'up')) {
@@ -2662,22 +2660,22 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     }
     return [swipeDirection];
   }, [snapPoints, swipeDirection]);
-  const setSwipeDismissed = useButton.useStableCallback(dismissed => {
+  const setSwipeDismissed = useScrollLock.useStableCallback(dismissed => {
     setSwipeDismissedElements(popupRef.current, backdropRef.current, dismissed);
   });
-  const clearSwipeRelease = useButton.useStableCallback(() => {
+  const clearSwipeRelease = useScrollLock.useStableCallback(() => {
     setSwipeDismissed(false);
-    popupRef.current?.removeAttribute(useButton.TransitionStatusDataAttributes.endingStyle);
+    popupRef.current?.removeAttribute(useScrollLock.TransitionStatusDataAttributes.endingStyle);
     setSwipeRelease(null);
   });
-  const finishNestedSwipe = useButton.useStableCallback(() => {
+  const finishNestedSwipe = useScrollLock.useStableCallback(() => {
     if (!nestedSwipeActiveRef.current) {
       return;
     }
     nestedSwipeActiveRef.current = false;
     notifyParentSwipingChange?.(false);
   });
-  const applySwipeProgress = useButton.useStableCallback(({
+  const applySwipeProgress = useScrollLock.useStableCallback(({
     resolvedProgress,
     shouldTrackProgress,
     notifyParent
@@ -2752,13 +2750,13 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     if (!Number.isFinite(directionalVelocity) || directionalVelocity <= MIN_SWIPE_RELEASE_VELOCITY) {
       return null;
     }
-    const clampedVelocity = clamp.clamp(directionalVelocity, MIN_SWIPE_RELEASE_VELOCITY, MAX_SWIPE_RELEASE_VELOCITY);
-    const durationMs = clamp.clamp(remainingDistance / clampedVelocity, MIN_SWIPE_RELEASE_DURATION_MS, MAX_SWIPE_RELEASE_DURATION_MS);
+    const clampedVelocity = scrollEdges.clamp(directionalVelocity, MIN_SWIPE_RELEASE_VELOCITY, MAX_SWIPE_RELEASE_VELOCITY);
+    const durationMs = scrollEdges.clamp(remainingDistance / clampedVelocity, MIN_SWIPE_RELEASE_DURATION_MS, MAX_SWIPE_RELEASE_DURATION_MS);
     if (!Number.isFinite(durationMs)) {
       return null;
     }
     const normalizedDuration = (durationMs - MIN_SWIPE_RELEASE_DURATION_MS) / (MAX_SWIPE_RELEASE_DURATION_MS - MIN_SWIPE_RELEASE_DURATION_MS);
-    const durationScalar = clamp.clamp(MIN_SWIPE_RELEASE_SCALAR + normalizedDuration * (MAX_SWIPE_RELEASE_SCALAR - MIN_SWIPE_RELEASE_SCALAR), MIN_SWIPE_RELEASE_SCALAR, MAX_SWIPE_RELEASE_SCALAR);
+    const durationScalar = scrollEdges.clamp(MIN_SWIPE_RELEASE_SCALAR + normalizedDuration * (MAX_SWIPE_RELEASE_SCALAR - MIN_SWIPE_RELEASE_SCALAR), MIN_SWIPE_RELEASE_SCALAR, MAX_SWIPE_RELEASE_SCALAR);
     if (!Number.isFinite(durationScalar) || durationScalar <= 0) {
       return null;
     }
@@ -2794,14 +2792,14 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       if (!popupElement) {
         return;
       }
-      const doc = useButton.ownerDocument(popupElement);
+      const doc = useScrollLock.ownerDocument(popupElement);
       const selection = doc.getSelection?.();
       if (!selection || selection.isCollapsed) {
         return;
       }
-      const anchorElement = floatingUi_utils_dom.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
-      const focusElement = floatingUi_utils_dom.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
-      if (!useButton.contains(popupElement, anchorElement) && !useButton.contains(popupElement, focusElement)) {
+      const anchorElement = floatingUi_utils.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+      const focusElement = floatingUi_utils.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+      if (!useScrollLock.contains(popupElement, anchorElement) && !useScrollLock.contains(popupElement, focusElement)) {
         return;
       }
       selection.removeAllRanges();
@@ -2826,7 +2824,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       }
       const doc = popupElement.ownerDocument;
       const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
-      if (!elementAtPoint || !useButton.contains(popupElement, elementAtPoint)) {
+      if (!elementAtPoint || !useScrollLock.contains(popupElement, elementAtPoint)) {
         return false;
       }
       const nativeEvent = details.nativeEvent;
@@ -2857,15 +2855,15 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       if (snapPointRange && popupHeight > 0) {
         if (details && Number.isFinite(details.deltaY)) {
           const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
-          const nextOffset = clamp.clamp(baseOffset + details.deltaY, 0, popupHeight);
-          resolvedProgress = clamp.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+          const nextOffset = scrollEdges.clamp(baseOffset + details.deltaY, 0, popupHeight);
+          resolvedProgress = scrollEdges.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
         } else if (snapPointProgress !== null) {
           resolvedProgress = snapPointProgress;
         } else if (currentDirection === 'down' || currentDirection === 'up') {
           const displacement = progress * popupHeight;
           const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
           const nextOffset = currentDirection === 'down' ? baseOffset + displacement : baseOffset - displacement;
-          resolvedProgress = clamp.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+          resolvedProgress = scrollEdges.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
         }
       }
       applySwipeProgress({
@@ -2902,7 +2900,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         finishNestedSwipe();
         setSwipeDismissed(true);
         popupElement.style.removeProperty('transition');
-        popupElement.setAttribute(useButton.TransitionStatusDataAttributes.endingStyle, '');
+        popupElement.setAttribute(useScrollLock.TransitionStatusDataAttributes.endingStyle, '');
         ReactDOM__namespace.flushSync(() => {
           setSwipeRelease(resolveSwipeRelease({
             direction: resolvedDirection,
@@ -2970,10 +2968,10 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         }
       }
       const currentOffset = activeSnapPointOffset ?? 0;
-      const dragTargetOffset = clamp.clamp(currentOffset + dragDelta, 0, popupHeight);
-      const velocityOffset = Number.isFinite(resolvedDirectionalVelocity) && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? clamp.clamp(resolvedDirectionalVelocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
-      const targetOffset = snapToSequentialPoints ? dragTargetOffset : clamp.clamp(dragTargetOffset + velocityOffset, 0, popupHeight);
-      const snapPointEventDetails = useButton.createChangeEventDetails(useButton.swipe, event);
+      const dragTargetOffset = scrollEdges.clamp(currentOffset + dragDelta, 0, popupHeight);
+      const velocityOffset = Number.isFinite(resolvedDirectionalVelocity) && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? scrollEdges.clamp(resolvedDirectionalVelocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
+      const targetOffset = snapToSequentialPoints ? dragTargetOffset : scrollEdges.clamp(dragTargetOffset + velocityOffset, 0, popupHeight);
+      const snapPointEventDetails = useScrollLock.createChangeEventDetails(useScrollLock.swipe, event);
       const closeFromSnapPoints = () => {
         pendingSwipeCloseSnapPointRef.current = activeSnapPoint;
         setActiveSnapPoint?.(null, snapPointEventDetails);
@@ -3008,7 +3006,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         const shouldAdvance = dragDirection !== 0 && velocityDirection !== 0 && velocityDirection === dragDirection && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD;
         let effectiveTargetOffset = targetOffset;
         if (shouldAdvance) {
-          const adjacentIndex = clamp.clamp(currentIndex + dragDirection, 0, orderedSnapPoints.length - 1);
+          const adjacentIndex = scrollEdges.clamp(currentIndex + dragDirection, 0, orderedSnapPoints.length - 1);
           if (adjacentIndex !== currentIndex) {
             const adjacentPoint = orderedSnapPoints[adjacentIndex];
             const shouldForceAdjacent = dragDirection > 0 ? targetOffset < adjacentPoint.offset : targetOffset > adjacentPoint.offset;
@@ -3061,12 +3059,12 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, '0');
         backdropElement.style.removeProperty(DrawerPopupCssVars.height);
       }
-      const dismissEventDetails = useButton.createChangeEventDetails(useButton.swipe, event);
+      const dismissEventDetails = useScrollLock.createChangeEventDetails(useScrollLock.swipe, event);
       store.setOpen(false, dismissEventDetails);
       if (dismissEventDetails.isCanceled) {
         const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
         if (pendingSnapPoint !== undefined) {
-          setActiveSnapPoint?.(pendingSnapPoint, useButton.createChangeEventDetails(useButton.swipe, event));
+          setActiveSnapPoint?.(pendingSnapPoint, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event));
         }
         pendingSwipeCloseSnapPointRef.current = undefined;
         resetSwipeRef.current?.();
@@ -3088,7 +3086,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
             // Parent rejected: revert animation and restore snap point.
             const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
             if (pendingSnapPoint !== undefined) {
-              setActiveSnapPoint?.(pendingSnapPoint, useButton.createChangeEventDetails(useButton.swipe, savedEvent));
+              setActiveSnapPoint?.(pendingSnapPoint, useScrollLock.createChangeEventDetails(useScrollLock.swipe, savedEvent));
             }
             pendingSwipeCloseSnapPointRef.current = undefined;
             clearSwipeRelease();
@@ -3117,8 +3115,8 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       return undefined;
     }
     const resolvedRootElement = rootElement;
-    const doc = useButton.ownerDocument(resolvedRootElement);
-    const win = floatingUi_utils_dom.getWindow(doc);
+    const doc = useScrollLock.ownerDocument(resolvedRootElement);
+    const win = floatingUi_utils.getWindow(doc);
     function handleNativeTouchMove(event) {
       // The virtual keyboard provider observes the move to tell a tap apart from a drag.
       // It must run even when the swipe gesture below claims the event with
@@ -3201,7 +3199,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       }
       updateTouchScrollPosition(touchState, touch);
     }
-    return useButton.addEventListener(doc, 'touchmove', handleNativeTouchMove, {
+    return useScrollLock.addEventListener(doc, 'touchmove', handleNativeTouchMove, {
       passive: false,
       capture: true
     });
@@ -3277,7 +3275,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         if (!open || !mounted || nestedDrawerOpen) {
           return;
         }
-        const doc = useButton.ownerDocument(event.currentTarget);
+        const doc = useScrollLock.ownerDocument(event.currentTarget);
         const elementAtPoint = getElementAtPoint(doc, event.clientX, event.clientY);
         if (isSwipeIgnoredTarget(elementAtPoint) || isDrawerContentTarget(elementAtPoint)) {
           return;
@@ -3333,12 +3331,12 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
           touchScrollStateRef.current = null;
           return;
         }
-        const doc = useButton.ownerDocument(event.currentTarget);
+        const doc = useScrollLock.ownerDocument(event.currentTarget);
         const elementAtPoint = getElementAtPoint(doc, touch.clientX, touch.clientY);
         const rootElement = viewportElement ?? popupElementState;
-        const eventTarget = useButton.getTarget(event.nativeEvent);
-        const target = floatingUi_utils_dom.isElement(eventTarget) ? eventTarget : null;
-        if (rootElement && target && !useButton.contains(rootElement, target)) {
+        const eventTarget = useScrollLock.getTarget(event.nativeEvent);
+        const target = floatingUi_utils.isElement(eventTarget) ? eventTarget : null;
+        if (rootElement && target && !useScrollLock.contains(rootElement, target)) {
           ignoreTouchSwipeRef.current = true;
           touchScrollStateRef.current = null;
           return;
@@ -3426,19 +3424,19 @@ function isRangeInput(target, win) {
   return target instanceof win.HTMLInputElement && target.type === 'range';
 }
 function isTextSelectionControl(target) {
-  if (!floatingUi_utils_dom.isElement(target)) {
+  if (!floatingUi_utils.isElement(target)) {
     return false;
   }
   return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA';
 }
 function hasExpandedSelectionWithinTarget(selection, target) {
-  const anchorElement = floatingUi_utils_dom.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
-  const focusElement = floatingUi_utils_dom.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
-  return selection.containsNode(target, true) || useButton.contains(target, anchorElement) || useButton.contains(target, focusElement);
+  const anchorElement = floatingUi_utils.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+  const focusElement = floatingUi_utils.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+  return selection.containsNode(target, true) || useScrollLock.contains(target, anchorElement) || useScrollLock.contains(target, focusElement);
 }
 function shouldIgnoreSwipeForTextSelection(doc, rootElement) {
-  const activeEl = useButton.activeElement(doc);
-  const activeElementWithinRoot = Boolean(activeEl && useButton.contains(rootElement, activeEl));
+  const activeEl = useScrollLock.activeElement(doc);
+  const activeElementWithinRoot = Boolean(activeEl && useScrollLock.contains(rootElement, activeEl));
   if (activeElementWithinRoot && isTextSelectionControl(activeEl)) {
     const {
       selectionStart,
@@ -3459,10 +3457,10 @@ function isEventOnRangeInput(event, win) {
   if (composedPath) {
     return composedPath.some(pathTarget => isRangeInput(pathTarget, win));
   }
-  return isRangeInput(useButton.getTarget(event), win);
+  return isRangeInput(useScrollLock.getTarget(event), win);
 }
 function isReactTouchEventOnRangeInput(event) {
-  return isEventOnRangeInput(event.nativeEvent, floatingUi_utils_dom.getWindow(event.currentTarget));
+  return isEventOnRangeInput(event.nativeEvent, floatingUi_utils.getWindow(event.currentTarget));
 }
 function updateTouchScrollPosition(touchState, touch) {
   touchState.lastX = touch.clientX;
@@ -3723,9 +3721,9 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
     yStart,
     yEnd
   } = normalizeOverflowEdgeThreshold(overflowEdgeThresholdProp);
-  const rootId = useButton.useBaseUiId();
-  const scrollYTimeout = useButton.useTimeout();
-  const scrollXTimeout = useButton.useTimeout();
+  const rootId = useScrollLock.useBaseUiId();
+  const scrollYTimeout = useScrollLock.useTimeout();
+  const scrollXTimeout = useScrollLock.useTimeout();
   const {
     nonce,
     disableStyleElements
@@ -3753,7 +3751,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
   const startScrollLeftRef = React__namespace.useRef(0);
   const currentOrientationRef = React__namespace.useRef('vertical');
   const scrollPositionRef = React__namespace.useRef(DEFAULT_COORDS);
-  const handleScroll = useButton.useStableCallback(scrollPosition => {
+  const handleScroll = useScrollLock.useStableCallback(scrollPosition => {
     const offsetX = scrollPosition.x - scrollPositionRef.current.x;
     const offsetY = scrollPosition.y - scrollPositionRef.current.y;
     scrollPositionRef.current = scrollPosition;
@@ -3770,7 +3768,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       });
     }
   });
-  const handlePointerDown = useButton.useStableCallback(event => {
+  const handlePointerDown = useScrollLock.useStableCallback(event => {
     if (event.button !== 0) {
       return;
     }
@@ -3789,7 +3787,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       thumbXRef.current.setPointerCapture(event.pointerId);
     }
   });
-  const handlePointerMove = useButton.useStableCallback(event => {
+  const handlePointerMove = useScrollLock.useStableCallback(event => {
     if (!thumbDraggingRef.current) {
       return;
     }
@@ -3828,7 +3826,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       }
     }
   });
-  const handlePointerUp = useButton.useStableCallback(event => {
+  const handlePointerUp = useScrollLock.useStableCallback(event => {
     thumbDraggingRef.current = false;
 
     // `pointercancel` releases capture implicitly, so guard against releasing a
@@ -3846,7 +3844,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
   function handlePointerEnterOrMove(event) {
     handleTouchModalityChange(event);
     if (event.pointerType !== 'touch') {
-      const isTargetRootChild = useButton.contains(rootRef.current, event.target);
+      const isTargetRootChild = useScrollLock.contains(rootRef.current, event.target);
       setHovering(isTargetRootChild);
     }
   }
@@ -4048,9 +4046,9 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
   const direction = useScrollLock.useDirection();
   const programmaticScrollRef = React__namespace.useRef(true);
   const lastMeasuredViewportMetricsRef = React__namespace.useRef([NaN, NaN, NaN, NaN]);
-  const scrollEndTimeout = useButton.useTimeout();
-  const waitForAnimationsTimeout = useButton.useTimeout();
-  const computeThumbPosition = useButton.useStableCallback(() => {
+  const scrollEndTimeout = useScrollLock.useTimeout();
+  const waitForAnimationsTimeout = useScrollLock.useTimeout();
+  const computeThumbPosition = useScrollLock.useStableCallback(() => {
     const viewportEl = viewportRef.current;
     const scrollbarYEl = scrollbarYRef.current;
     const scrollbarXEl = scrollbarXRef.current;
@@ -4090,14 +4088,14 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
     if (!scrollbarXHidden) {
       let rawScrollLeftFromStart = 0;
       if (direction === 'rtl') {
-        rawScrollLeftFromStart = clamp.clamp(-scrollLeft, 0, maxScrollLeft);
+        rawScrollLeftFromStart = scrollEdges.clamp(-scrollLeft, 0, maxScrollLeft);
       } else {
-        rawScrollLeftFromStart = clamp.clamp(scrollLeft, 0, maxScrollLeft);
+        rawScrollLeftFromStart = scrollEdges.clamp(scrollLeft, 0, maxScrollLeft);
       }
       scrollLeftFromStart = scrollEdges.normalizeScrollOffset(rawScrollLeftFromStart, maxScrollLeft);
       scrollLeftFromEnd = maxScrollLeft - scrollLeftFromStart;
     }
-    const rawScrollTopFromStart = !scrollbarYHidden ? clamp.clamp(scrollTop, 0, maxScrollTop) : 0;
+    const rawScrollTopFromStart = !scrollbarYHidden ? scrollEdges.clamp(scrollTop, 0, maxScrollTop) : 0;
     const scrollTopFromStart = !scrollbarYHidden ? scrollEdges.normalizeScrollOffset(rawScrollTopFromStart, maxScrollTop) : 0;
     const scrollTopFromEnd = !scrollbarYHidden ? maxScrollTop - scrollTopFromStart : 0;
     const nextWidth = scrollbarXHidden ? 0 : viewportWidth;
@@ -4154,7 +4152,7 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
 
       // In Safari, don't allow it to go negative or too far as `scrollLeft` considers the rubber
       // band effect.
-      const thumbOffsetX = direction === 'rtl' ? clamp.clamp(scrollRatioX * maxThumbOffsetX, -maxThumbOffsetX, 0) : clamp.clamp(scrollRatioX * maxThumbOffsetX, 0, maxThumbOffsetX);
+      const thumbOffsetX = direction === 'rtl' ? scrollEdges.clamp(scrollRatioX * maxThumbOffsetX, -maxThumbOffsetX, 0) : scrollEdges.clamp(scrollRatioX * maxThumbOffsetX, 0, maxThumbOffsetX);
       thumbXEl.style.transform = `translate3d(${thumbOffsetX}px,0,0)`;
     }
     const overflowMetricsPx = [[ScrollAreaViewportCssVars.scrollAreaOverflowXStart, scrollLeftFromStart], [ScrollAreaViewportCssVars.scrollAreaOverflowXEnd, scrollLeftFromEnd], [ScrollAreaViewportCssVars.scrollAreaOverflowYStart, scrollTopFromStart], [ScrollAreaViewportCssVars.scrollAreaOverflowYEnd, scrollTopFromEnd]];
@@ -4188,25 +4186,25 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
       return nextOverflowEdges;
     });
   });
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     if (!viewportRef.current) {
       return;
     }
     removeCSSVariableInheritance();
   }, [viewportRef]);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     // Wait for scrollbar and thumb refs after hidden-state toggles, refresh math on direction
     // flips, and re-evaluate overflow edges when the threshold changes.
     queueMicrotask(computeThumbPosition);
   }, [computeThumbPosition, hiddenState, direction, overflowEdgeThreshold.xStart, overflowEdgeThreshold.xEnd, overflowEdgeThreshold.yStart, overflowEdgeThreshold.yEnd]);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     // `onMouseEnter` doesn't fire upon load, so we need to check if the viewport is already
     // being hovered.
     if (viewportRef.current?.matches(':hover')) {
       setHovering(true);
     }
   }, [viewportRef, setHovering]);
-  useButton.useIsoLayoutEffect(() => {
+  useScrollLock.useIsoLayoutEffect(() => {
     const viewport = viewportRef.current;
     if (typeof ResizeObserver === 'undefined' || !viewport) {
       return undefined;