@jobber/components 8.24.1 → 8.24.2-visual-reg-d5e3ec5.19

package/dist/ScrollAreaViewport-cjs.js

@@ -5,9 +5,10 @@ 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 clamp = require('./clamp-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
 var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
+var ReactDOM = require('react-dom');
+var clamp = require('./clamp-cjs.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -27,6 +28,7 @@ function _interopNamespaceDefault(e) {
 }
 
 var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+var ReactDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactDOM);
 
 function getEmptyRootContext() {
   return new useScrollLock.FloatingRootStore({
@@ -460,6 +462,98 @@ function DialogRoot(props) {
   return useRenderDialogRoot(props, mode);
 }
 
+let DialogViewportDataAttributes = function (DialogViewportDataAttributes) {
+  /**
+   * Present when the dialog is open.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["open"] = useScrollLock.CommonPopupDataAttributes.open] = "open";
+  /**
+   * Present when the dialog is closed.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["closed"] = useScrollLock.CommonPopupDataAttributes.closed] = "closed";
+  /**
+   * Present when the dialog is animating in.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["startingStyle"] = useScrollLock.CommonPopupDataAttributes.startingStyle] = "startingStyle";
+  /**
+   * Present when the dialog is animating out.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["endingStyle"] = useScrollLock.CommonPopupDataAttributes.endingStyle] = "endingStyle";
+  /**
+   * Present when the dialog is nested within another dialog.
+   */
+  DialogViewportDataAttributes["nested"] = "data-nested";
+  /**
+   * Present when the dialog has other open dialogs nested within it.
+   */
+  DialogViewportDataAttributes["nestedDialogOpen"] = "data-nested-dialog-open";
+  return DialogViewportDataAttributes;
+}({});
+
+const stateAttributesMapping$2 = {
+  ...useScrollLock.popupStateMapping,
+  ...useButton.transitionStatusMapping,
+  nested(value) {
+    return value ? {
+      [DialogViewportDataAttributes.nested]: ''
+    } : null;
+  },
+  nestedDialogOpen(value) {
+    return value ? {
+      [DialogViewportDataAttributes.nestedDialogOpen]: ''
+    } : null;
+  }
+};
+
+/**
+ * A positioning container for the dialog popup that can be made scrollable.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+const DialogViewport = /*#__PURE__*/React__namespace.forwardRef(function DialogViewport(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    children,
+    ...elementProps
+  } = componentProps;
+  const keepMounted = useDialogPortalContext();
+  const {
+    store
+  } = useDialogRootContext();
+  const open = store.useState('open');
+  const nested = store.useState('nested');
+  const transitionStatus = store.useState('transitionStatus');
+  const nestedOpenDialogCount = store.useState('nestedOpenDialogCount');
+  const mounted = store.useState('mounted');
+  const setViewportElement = store.useStateSetter('viewportElement');
+  const nestedDialogOpen = nestedOpenDialogCount > 0;
+  const state = {
+    open,
+    nested,
+    transitionStatus,
+    nestedDialogOpen
+  };
+  const shouldRender = keepMounted || mounted;
+  return useRenderElement.useRenderElement('div', componentProps, {
+    enabled: shouldRender,
+    state,
+    ref: [forwardedRef, setViewportElement],
+    stateAttributesMapping: stateAttributesMapping$2,
+    props: [{
+      role: 'presentation',
+      hidden: !mounted,
+      style: {
+        pointerEvents: !open ? 'none' : undefined
+      },
+      children
+    }, elementProps]
+  });
+});
+if (process.env.NODE_ENV !== "production") DialogViewport.displayName = "DialogViewport";
+
 /**
  * A button that opens the dialog.
  * Renders a `<button>` element.
@@ -1433,13 +1527,2025 @@ function DrawerProviderReporter() {
   return null;
 }
 
-/**
- * A button that opens the drawer.
- * Renders a `<button>` element.
- *
- * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
- */
-const DrawerTrigger = DialogTrigger;
+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);
+  if (axis === 'vertical') {
+    const overflowY = style.overflowY;
+    if (overflowY !== 'auto' && overflowY !== 'scroll') {
+      return false;
+    }
+    return allowOverflowIntent ? element.clientHeight > 0 : element.scrollHeight > element.clientHeight;
+  }
+  const overflowX = style.overflowX;
+  if (overflowX !== 'auto' && overflowX !== 'scroll') {
+    return false;
+  }
+  return allowOverflowIntent ? element.clientWidth > 0 : element.scrollWidth > element.clientWidth;
+}
+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)) {
+    for (const axis of axes) {
+      if (isScrollable(node, axis)) {
+        return true;
+      }
+    }
+    node = floatingUi_utils_dom.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)) {
+    if (isScrollable(node, axis, allowOverflowIntent)) {
+      return node;
+    }
+    node = floatingUi_utils_dom.getParentNode(node);
+  }
+  return isScrollable(root, axis, allowOverflowIntent) ? root : null;
+}
+
+function getElementAtPoint(doc, x, y) {
+  return typeof doc?.elementFromPoint === 'function' ? doc.elementFromPoint(x, y) : null;
+}
+
+const DEFAULT_SWIPE_THRESHOLD = 40;
+const REVERSE_CANCEL_THRESHOLD = 10;
+const MIN_DRAG_THRESHOLD = 1;
+const MIN_VELOCITY_DURATION_MS = 50;
+const MIN_RELEASE_VELOCITY_DURATION_MS = 16;
+const MAX_RELEASE_VELOCITY_AGE_MS = 80;
+const DEFAULT_IGNORE_SELECTOR = 'button,a,input,select,textarea,label,[role="button"]';
+function getDisplacement(direction, deltaX, deltaY) {
+  switch (direction) {
+    case 'up':
+      return -deltaY;
+    case 'down':
+      return deltaY;
+    case 'left':
+      return -deltaX;
+    case 'right':
+      return deltaX;
+    default:
+      return 0;
+  }
+}
+function getElementTransform(element) {
+  const computedStyle = floatingUi_utils_dom.getWindow(element).getComputedStyle(element);
+  const transform = computedStyle.transform;
+  let translateX = 0;
+  let translateY = 0;
+  let scale = 1;
+  if (transform && transform !== 'none') {
+    const matrix = transform.match(/matrix(?:3d)?\(([^)]+)\)/);
+    if (matrix) {
+      const values = matrix[1].split(', ').map(parseFloat);
+      if (values.length === 6) {
+        translateX = values[4];
+        translateY = values[5];
+        scale = Math.sqrt(values[0] * values[0] + values[1] * values[1]);
+      } else if (values.length === 16) {
+        translateX = values[12];
+        translateY = values[13];
+        scale = values[0];
+      }
+    }
+  }
+  return {
+    x: translateX,
+    y: translateY,
+    scale
+  };
+}
+function getValidTimeStamp(timeStamp) {
+  return Number.isFinite(timeStamp) && timeStamp > 0 ? timeStamp : null;
+}
+function getDragTransform(dragOffset, scale) {
+  return `translate3d(${dragOffset.x}px,${dragOffset.y}px,0) scale(${scale})`;
+}
+function hasPrimaryMouseButton(buttons) {
+  return buttons % 2 === 1;
+}
+function safelyChangePointerCapture(element, pointerId, method) {
+  const pointerCaptureMethod = element[method];
+  if (typeof pointerCaptureMethod !== 'function') {
+    return;
+  }
+  try {
+    pointerCaptureMethod.call(element, pointerId);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'name' in error && error.name === 'NotFoundError') {
+      return;
+    }
+    throw error;
+  }
+}
+function useSwipeDismiss(options) {
+  const {
+    enabled,
+    directions,
+    elementRef,
+    movementCssVars,
+    canStart,
+    ignoreSelectorWhenTouch = true,
+    ignoreScrollableAncestors = false,
+    swipeThreshold: swipeThresholdProp,
+    onDismiss,
+    onProgress,
+    onCancel,
+    onSwipeStart,
+    onRelease,
+    onSwipingChange,
+    trackDrag = true
+  } = options;
+  const ignoreSelector = DEFAULT_IGNORE_SELECTOR;
+  const primaryDirection = directions.length === 1 ? directions[0] : undefined;
+  const swipeThresholdDefault = Math.max(0, typeof swipeThresholdProp === 'number' ? swipeThresholdProp : DEFAULT_SWIPE_THRESHOLD);
+  const allowLeft = directions.includes('left');
+  const allowRight = directions.includes('right');
+  const allowUp = directions.includes('up');
+  const allowDown = directions.includes('down');
+  const hasHorizontal = allowLeft || allowRight;
+  const hasVertical = allowUp || allowDown;
+  const scrollAxes = React__namespace.useMemo(() => {
+    const axes = [];
+    if (hasVertical) {
+      axes.push('vertical');
+    }
+    if (hasHorizontal) {
+      axes.push('horizontal');
+    }
+    return axes;
+  }, [hasHorizontal, hasVertical]);
+  const [currentSwipeDirection, setCurrentSwipeDirection] = React__namespace.useState(undefined);
+  const [isSwiping, setIsSwiping] = React__namespace.useState(false);
+  const [dragDismissed, setDragDismissed] = React__namespace.useState(false);
+  const dragStartPosRef = React__namespace.useRef({
+    x: 0,
+    y: 0
+  });
+  const dragOffsetRef = React__namespace.useRef({
+    x: 0,
+    y: 0
+  });
+  const lastMovePosRef = React__namespace.useRef(null);
+  const initialTransformRef = React__namespace.useRef({
+    x: 0,
+    y: 0,
+    scale: 1
+  });
+  const intendedSwipeDirectionRef = React__namespace.useRef(undefined);
+  const maxSwipeDisplacementRef = React__namespace.useRef(0);
+  const cancelledSwipeRef = React__namespace.useRef(false);
+  const swipeCancelBaselineRef = React__namespace.useRef({
+    x: 0,
+    y: 0
+  });
+  const lockedDirectionRef = React__namespace.useRef(null);
+  const isFirstPointerMoveRef = React__namespace.useRef(false);
+  const pendingSwipeRef = React__namespace.useRef(false);
+  const pendingSwipeStartPosRef = React__namespace.useRef(null);
+  const swipeFromScrollableRef = React__namespace.useRef(false);
+  const sawPrimaryButtonsOnMoveRef = React__namespace.useRef(false);
+  const elementSizeRef = React__namespace.useRef({
+    width: 0,
+    height: 0
+  });
+  const swipeProgressRef = React__namespace.useRef(0);
+  const swipeThresholdRef = React__namespace.useRef(swipeThresholdDefault);
+  const swipeStartTimeRef = React__namespace.useRef(null);
+  const lastDragSampleRef = React__namespace.useRef(null);
+  const lastDragVelocityRef = React__namespace.useRef({
+    x: 0,
+    y: 0
+  });
+  const lastProgressDetailsRef = React__namespace.useRef(null);
+  const isSwipingRef = React__namespace.useRef(false);
+  const dragStyleSnapshotRef = React__namespace.useRef(null);
+  const setSwiping = useButton.useStableCallback(nextSwiping => {
+    if (isSwipingRef.current === nextSwiping) {
+      return;
+    }
+    isSwipingRef.current = nextSwiping;
+    setIsSwiping(nextSwiping);
+    onSwipingChange?.(nextSwiping);
+  });
+  function resolveSwipeThreshold(direction) {
+    if (!direction) {
+      return;
+    }
+    if (typeof swipeThresholdProp !== 'function') {
+      swipeThresholdRef.current = swipeThresholdDefault;
+      return;
+    }
+    const element = elementRef.current;
+    if (!element) {
+      return;
+    }
+    const value = swipeThresholdProp({
+      element,
+      direction
+    });
+    swipeThresholdRef.current = Math.max(0, value);
+  }
+  const updateSwipeProgress = useButton.useStableCallback((progress, details) => {
+    const nextProgress = Number.isFinite(progress) ? clamp.clamp(progress, 0, 1) : 0;
+    const progressChanged = nextProgress !== swipeProgressRef.current;
+    let detailsChanged = false;
+    if (details) {
+      const lastDetails = lastProgressDetailsRef.current;
+      detailsChanged = !lastDetails || lastDetails.deltaX !== details.deltaX || lastDetails.deltaY !== details.deltaY || lastDetails.direction !== details.direction;
+    }
+    if (!progressChanged && !detailsChanged) {
+      return;
+    }
+    swipeProgressRef.current = nextProgress;
+    if (details) {
+      lastProgressDetailsRef.current = details;
+    } else if (progressChanged) {
+      lastProgressDetailsRef.current = null;
+    }
+    onProgress?.(nextProgress, details);
+  });
+  const syncDragStyles = useButton.useStableCallback(swiping => {
+    const element = elementRef.current;
+    if (!trackDrag || !element) {
+      if (!swiping) {
+        dragStyleSnapshotRef.current = null;
+      }
+      return;
+    }
+    const style = element.style;
+    const dragStyleSnapshot = dragStyleSnapshotRef.current;
+    if (swiping) {
+      if (!dragStyleSnapshot) {
+        dragStyleSnapshotRef.current = [style.transition, style.transform];
+      }
+      style.transition = 'none';
+    } else if (dragStyleSnapshot) {
+      [style.transition, style.transform] = dragStyleSnapshot;
+      dragStyleSnapshotRef.current = null;
+    }
+    const dragOffset = dragOffsetRef.current;
+    const initialTransform = initialTransformRef.current;
+    const deltaX = dragOffset.x - initialTransform.x;
+    const deltaY = dragOffset.y - initialTransform.y;
+    if (swiping) {
+      style.transform = getDragTransform(dragOffset, initialTransform.scale);
+    }
+    style.setProperty(movementCssVars.x, `${deltaX}px`);
+    style.setProperty(movementCssVars.y, `${deltaY}px`);
+  });
+  function recordDragSample(offset, timeStamp) {
+    if (timeStamp === null) {
+      return;
+    }
+    const lastSample = lastDragSampleRef.current;
+    if (lastSample && timeStamp > lastSample.time) {
+      const durationMs = Math.max(timeStamp - lastSample.time, MIN_RELEASE_VELOCITY_DURATION_MS);
+      lastDragVelocityRef.current = {
+        x: (offset.x - lastSample.x) / durationMs,
+        y: (offset.y - lastSample.y) / durationMs
+      };
+    }
+    lastDragSampleRef.current = {
+      x: offset.x,
+      y: offset.y,
+      time: timeStamp
+    };
+  }
+  const reset = React__namespace.useCallback(() => {
+    setCurrentSwipeDirection(undefined);
+    setSwiping(false);
+    setDragDismissed(false);
+    updateSwipeProgress(0);
+    swipeThresholdRef.current = swipeThresholdDefault;
+    dragStartPosRef.current = {
+      x: 0,
+      y: 0
+    };
+    dragOffsetRef.current = {
+      x: 0,
+      y: 0
+    };
+    initialTransformRef.current = {
+      x: 0,
+      y: 0,
+      scale: 1
+    };
+    intendedSwipeDirectionRef.current = undefined;
+    maxSwipeDisplacementRef.current = 0;
+    cancelledSwipeRef.current = false;
+    swipeCancelBaselineRef.current = {
+      x: 0,
+      y: 0
+    };
+    lockedDirectionRef.current = null;
+    isFirstPointerMoveRef.current = false;
+    lastMovePosRef.current = null;
+    pendingSwipeRef.current = false;
+    pendingSwipeStartPosRef.current = null;
+    swipeFromScrollableRef.current = false;
+    sawPrimaryButtonsOnMoveRef.current = false;
+    elementSizeRef.current = {
+      width: 0,
+      height: 0
+    };
+    swipeStartTimeRef.current = null;
+    lastDragSampleRef.current = null;
+    lastDragVelocityRef.current = {
+      x: 0,
+      y: 0
+    };
+    lastProgressDetailsRef.current = null;
+    syncDragStyles(false);
+  }, [setSwiping, swipeThresholdDefault, syncDragStyles, updateSwipeProgress]);
+  React__namespace.useEffect(() => {
+    if (typeof swipeThresholdProp !== 'function') {
+      swipeThresholdRef.current = swipeThresholdDefault;
+    }
+  }, [swipeThresholdDefault, swipeThresholdProp]);
+  function getPrimaryPointerPosition(event) {
+    if ('touches' in event) {
+      const touch = event.touches[0];
+      return touch ? {
+        x: touch.clientX,
+        y: touch.clientY
+      } : null;
+    }
+    return {
+      x: event.clientX,
+      y: event.clientY
+    };
+  }
+  function isTouchLikeEvent(event) {
+    if ('touches' in event) {
+      return true;
+    }
+    return event.pointerType === 'touch';
+  }
+  function getTargetAtPoint(position, nativeEvent) {
+    const doc = useButton.ownerDocument(elementRef.current);
+    const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
+    const target = elementAtPoint ?? useButton.getTarget(nativeEvent);
+    return target;
+  }
+  function findGestureScrollableTouchTarget(target, root) {
+    if (hasHorizontal && !hasVertical) {
+      return findScrollableTouchTarget(target, root, 'horizontal');
+    }
+    if (hasVertical && !hasHorizontal) {
+      return findScrollableTouchTarget(target, root, 'vertical');
+    }
+    return findScrollableTouchTarget(target, root, 'vertical') ?? findScrollableTouchTarget(target, root, 'horizontal');
+  }
+  function startSwipeAtPosition(event, position, startOptions) {
+    swipeFromScrollableRef.current = false;
+    const touchLike = isTouchLikeEvent(event);
+    const target = getTargetAtPoint(position, event.nativeEvent);
+    const doc = useButton.ownerDocument(elementRef.current);
+    const body = doc.body;
+    const scrollableTarget = touchLike && body ? findGestureScrollableTouchTarget(target, body) : null;
+    const ignoreScrollableTarget = startOptions?.ignoreScrollableTarget ?? false;
+    if (scrollableTarget && !ignoreScrollableTarget) {
+      return false;
+    }
+    swipeFromScrollableRef.current = Boolean(scrollableTarget && ignoreScrollableTarget);
+    const isInteractiveElement = target ? target.closest(ignoreSelector) : false;
+    if (isInteractiveElement && (!touchLike || ignoreSelectorWhenTouch)) {
+      return false;
+    }
+    const element = elementRef.current;
+    if (ignoreScrollableAncestors && element && target && scrollAxes.length > 0) {
+      const ignoreAncestors = startOptions?.ignoreScrollableAncestors ?? false;
+      if (!ignoreAncestors && hasScrollableAncestor(target, element, scrollAxes)) {
+        return false;
+      }
+    }
+    cancelledSwipeRef.current = false;
+    intendedSwipeDirectionRef.current = undefined;
+    maxSwipeDisplacementRef.current = 0;
+    dragStartPosRef.current = position;
+    swipeStartTimeRef.current = getValidTimeStamp(event.timeStamp);
+    swipeCancelBaselineRef.current = position;
+    lastMovePosRef.current = position;
+    if (element) {
+      elementSizeRef.current = {
+        width: element.offsetWidth,
+        height: element.offsetHeight
+      };
+      resolveSwipeThreshold(primaryDirection);
+      const transform = getElementTransform(element);
+      initialTransformRef.current = transform;
+      dragOffsetRef.current = {
+        x: transform.x,
+        y: transform.y
+      };
+      recordDragSample({
+        x: transform.x,
+        y: transform.y
+      }, swipeStartTimeRef.current);
+      if (!('touches' in event)) {
+        safelyChangePointerCapture(element, event.pointerId, 'setPointerCapture');
+      }
+    }
+    onSwipeStart?.(event.nativeEvent);
+    setSwiping(true);
+    lockedDirectionRef.current = null;
+    isFirstPointerMoveRef.current = true;
+    updateSwipeProgress(0);
+    syncDragStyles(true);
+    return true;
+  }
+  function resetPendingSwipeState() {
+    clearPendingSwipeStartState();
+    swipeFromScrollableRef.current = false;
+    lastMovePosRef.current = null;
+  }
+  function clearPendingSwipeStartState() {
+    pendingSwipeRef.current = false;
+    pendingSwipeStartPosRef.current = null;
+  }
+  function cancelSwipeInteraction(event) {
+    resetPendingSwipeState();
+    if (!isSwipingRef.current) {
+      return;
+    }
+    setSwiping(false);
+    lockedDirectionRef.current = null;
+    const resolvedInitialTransform = initialTransformRef.current;
+    dragOffsetRef.current = {
+      x: resolvedInitialTransform.x,
+      y: resolvedInitialTransform.y
+    };
+    setCurrentSwipeDirection(undefined);
+    sawPrimaryButtonsOnMoveRef.current = false;
+    syncDragStyles(false);
+    const element = elementRef.current;
+    if (element) {
+      safelyChangePointerCapture(element, event.pointerId, 'releasePointerCapture');
+    }
+    updateSwipeProgress(0, {
+      deltaX: 0,
+      deltaY: 0,
+      direction: undefined
+    });
+    onCancel?.(event.nativeEvent);
+  }
+  function applyDirectionalDamping(deltaX, deltaY) {
+    const exponent = value => value >= 0 ? value ** 0.5 : -(Math.abs(value) ** 0.5);
+    const dampAxis = (delta, allowNegative, allowPositive) => {
+      if (!allowNegative && delta < 0) {
+        return exponent(delta);
+      }
+      if (!allowPositive && delta > 0) {
+        return exponent(delta);
+      }
+      return delta;
+    };
+    const newDeltaX = hasHorizontal ? dampAxis(deltaX, allowLeft, allowRight) : exponent(deltaX);
+    const newDeltaY = hasVertical ? dampAxis(deltaY, allowUp, allowDown) : exponent(deltaY);
+    return {
+      x: newDeltaX,
+      y: newDeltaY
+    };
+  }
+  function canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY) {
+    const absDeltaX = Math.abs(deltaX);
+    const absDeltaY = Math.abs(deltaY);
+    const useVerticalAxis = hasVertical && deltaY !== 0 && (!hasHorizontal || absDeltaY >= absDeltaX);
+    if (useVerticalAxis) {
+      const maxScrollTop = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+      const atTop = scrollTarget.scrollTop <= 0;
+      const atBottom = scrollTarget.scrollTop >= maxScrollTop;
+      const movingDown = deltaY > 0;
+      const movingUp = deltaY < 0;
+      const canSwipeDown = movingDown && atTop && allowDown;
+      const canSwipeUp = movingUp && atBottom && allowUp;
+      return canSwipeDown || canSwipeUp;
+    }
+    const useHorizontalAxis = hasHorizontal && deltaX !== 0 && (!hasVertical || absDeltaX > absDeltaY);
+    if (useHorizontalAxis) {
+      const maxScrollLeft = Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth);
+      const atLeft = scrollTarget.scrollLeft <= 0;
+      const atRight = scrollTarget.scrollLeft >= maxScrollLeft;
+      const movingRight = deltaX > 0;
+      const movingLeft = deltaX < 0;
+      const canSwipeRight = movingRight && atLeft && allowRight;
+      const canSwipeLeft = movingLeft && atRight && allowLeft;
+      return canSwipeRight || canSwipeLeft;
+    }
+    return null;
+  }
+  const handleStart = useButton.useStableCallback(event => {
+    if (!enabled) {
+      return;
+    }
+    if (event.defaultPrevented || event.nativeEvent.defaultPrevented) {
+      return;
+    }
+    if (!('touches' in event) && event.button !== 0) {
+      return;
+    }
+    const startPos = getPrimaryPointerPosition(event);
+    if (!startPos) {
+      return;
+    }
+    pendingSwipeRef.current = true;
+    pendingSwipeStartPosRef.current = startPos;
+    swipeFromScrollableRef.current = false;
+    sawPrimaryButtonsOnMoveRef.current = false;
+    const allowedToStart = canStart ? canStart(startPos, {
+      nativeEvent: event.nativeEvent,
+      direction: primaryDirection
+    }) : true;
+    if (!allowedToStart) {
+      return;
+    }
+    if (startSwipeAtPosition(event, startPos)) {
+      clearPendingSwipeStartState();
+    }
+  });
+  function handleMoveCore(event, position, movement) {
+    if (!enabled || !isSwipingRef.current) {
+      return;
+    }
+    const target = useButton.getTarget(event.nativeEvent);
+    if (isTouchLikeEvent(event) && !swipeFromScrollableRef.current) {
+      const boundaryElement = event.currentTarget;
+      if (findGestureScrollableTouchTarget(target, boundaryElement)) {
+        return;
+      }
+    }
+    if (!('touches' in event)) {
+      // Prevent text selection on Safari
+      event.preventDefault();
+    }
+    if (isFirstPointerMoveRef.current) {
+      // Adjust the starting position to the current position on the first move
+      // to account for the delay between pointerdown and the first pointermove on iOS.
+      dragStartPosRef.current = position;
+      const moveTime = getValidTimeStamp(event.timeStamp);
+      if (moveTime !== null) {
+        swipeStartTimeRef.current = moveTime;
+      }
+      isFirstPointerMoveRef.current = false;
+    }
+    const clientX = position.x;
+    const clientY = position.y;
+    const movementX = movement.x;
+    const movementY = movement.y;
+    if (movementY < 0 && clientY > swipeCancelBaselineRef.current.y || movementY > 0 && clientY < swipeCancelBaselineRef.current.y) {
+      swipeCancelBaselineRef.current = {
+        x: swipeCancelBaselineRef.current.x,
+        y: clientY
+      };
+    }
+    if (movementX < 0 && clientX > swipeCancelBaselineRef.current.x || movementX > 0 && clientX < swipeCancelBaselineRef.current.x) {
+      swipeCancelBaselineRef.current = {
+        x: clientX,
+        y: swipeCancelBaselineRef.current.y
+      };
+    }
+    const deltaX = clientX - dragStartPosRef.current.x;
+    const deltaY = clientY - dragStartPosRef.current.y;
+    const cancelDeltaY = clientY - swipeCancelBaselineRef.current.y;
+    const cancelDeltaX = clientX - swipeCancelBaselineRef.current.x;
+    let lockedDirection = lockedDirectionRef.current;
+    if (lockedDirection === null && hasHorizontal && hasVertical) {
+      const movementDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+      if (movementDistance >= MIN_DRAG_THRESHOLD) {
+        lockedDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'horizontal' : 'vertical';
+        lockedDirectionRef.current = lockedDirection;
+      }
+    }
+    let candidate;
+    if (!intendedSwipeDirectionRef.current) {
+      if (lockedDirection === 'vertical') {
+        if (deltaY > 0) {
+          candidate = 'down';
+        } else if (deltaY < 0) {
+          candidate = 'up';
+        }
+      } else if (lockedDirection === 'horizontal') {
+        if (deltaX > 0) {
+          candidate = 'right';
+        } else if (deltaX < 0) {
+          candidate = 'left';
+        }
+      } else if (Math.abs(deltaX) >= Math.abs(deltaY)) {
+        candidate = deltaX > 0 ? 'right' : 'left';
+      } else {
+        candidate = deltaY > 0 ? 'down' : 'up';
+      }
+      if (candidate) {
+        const isAllowed = candidate === 'left' && allowLeft || candidate === 'right' && allowRight || candidate === 'up' && allowUp || candidate === 'down' && allowDown;
+        if (isAllowed) {
+          intendedSwipeDirectionRef.current = candidate;
+          maxSwipeDisplacementRef.current = getDisplacement(candidate, deltaX, deltaY);
+          setCurrentSwipeDirection(candidate);
+          resolveSwipeThreshold(candidate);
+        }
+      }
+    } else {
+      const direction = intendedSwipeDirectionRef.current;
+      const currentDisplacement = getDisplacement(direction, cancelDeltaX, cancelDeltaY);
+      if (currentDisplacement > swipeThresholdRef.current) {
+        cancelledSwipeRef.current = false;
+        setCurrentSwipeDirection(direction);
+      } else if (!(allowLeft && allowRight) && !(allowUp && allowDown) && maxSwipeDisplacementRef.current - currentDisplacement >= REVERSE_CANCEL_THRESHOLD) {
+        // Mark that a change-of-mind has occurred
+        cancelledSwipeRef.current = true;
+      }
+    }
+    const dampedDelta = applyDirectionalDamping(deltaX, deltaY);
+    let newOffsetX = initialTransformRef.current.x;
+    let newOffsetY = initialTransformRef.current.y;
+    if (lockedDirection === 'horizontal') {
+      if (hasHorizontal) {
+        newOffsetX += dampedDelta.x;
+      }
+    } else if (lockedDirection === 'vertical') {
+      if (hasVertical) {
+        newOffsetY += dampedDelta.y;
+      }
+    } else {
+      if (hasHorizontal) {
+        newOffsetX += dampedDelta.x;
+      }
+      if (hasVertical) {
+        newOffsetY += dampedDelta.y;
+      }
+    }
+    dragOffsetRef.current = {
+      x: newOffsetX,
+      y: newOffsetY
+    };
+    syncDragStyles(true);
+    recordDragSample({
+      x: newOffsetX,
+      y: newOffsetY
+    }, getValidTimeStamp(event.timeStamp));
+    const dragDeltaX = newOffsetX - initialTransformRef.current.x;
+    const dragDeltaY = newOffsetY - initialTransformRef.current.y;
+    const swipeDirectionDetails = intendedSwipeDirectionRef.current;
+    const progressDirection = primaryDirection ?? intendedSwipeDirectionRef.current;
+    if (!progressDirection) {
+      updateSwipeProgress(0, {
+        deltaX: dragDeltaX,
+        deltaY: dragDeltaY,
+        direction: swipeDirectionDetails
+      });
+      return;
+    }
+    const size = progressDirection === 'left' || progressDirection === 'right' ? elementSizeRef.current.width : elementSizeRef.current.height;
+    const scale = initialTransformRef.current.scale || 1;
+    if (size <= 0 || scale <= 0) {
+      updateSwipeProgress(0, {
+        deltaX: dragDeltaX,
+        deltaY: dragDeltaY,
+        direction: swipeDirectionDetails
+      });
+      return;
+    }
+    const progressDisplacement = getDisplacement(progressDirection, newOffsetX - initialTransformRef.current.x, newOffsetY - initialTransformRef.current.y);
+    if (progressDisplacement <= 0) {
+      updateSwipeProgress(0, {
+        deltaX: dragDeltaX,
+        deltaY: dragDeltaY,
+        direction: swipeDirectionDetails
+      });
+      return;
+    }
+    updateSwipeProgress(progressDisplacement / (size * scale), {
+      deltaX: dragDeltaX,
+      deltaY: dragDeltaY,
+      direction: swipeDirectionDetails
+    });
+  }
+  const handleEnd = useButton.useStableCallback(event => {
+    if (!enabled) {
+      return;
+    }
+    const resolvedDragOffset = dragOffsetRef.current;
+    const resolvedInitialTransform = initialTransformRef.current;
+    const releaseDeltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
+    const releaseDeltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
+    const progressDetails = {
+      deltaX: releaseDeltaX,
+      deltaY: releaseDeltaY,
+      direction: intendedSwipeDirectionRef.current
+    };
+    if (!isSwipingRef.current) {
+      resetPendingSwipeState();
+      updateSwipeProgress(0, progressDetails);
+      return;
+    }
+    setSwiping(false);
+    lockedDirectionRef.current = null;
+    resetPendingSwipeState();
+    sawPrimaryButtonsOnMoveRef.current = false;
+    const element = elementRef.current;
+    if (element) {
+      if (!('touches' in event)) {
+        safelyChangePointerCapture(element, event.pointerId, 'releasePointerCapture');
+      }
+    }
+    const deltaX = releaseDeltaX;
+    const deltaY = releaseDeltaY;
+    const startTime = swipeStartTimeRef.current;
+    const endTime = getValidTimeStamp(event.timeStamp);
+    const durationMs = startTime !== null && endTime !== null && endTime > startTime ? endTime - startTime : 0;
+    const velocityDurationMs = durationMs > 0 ? Math.max(durationMs, MIN_VELOCITY_DURATION_MS) : 0;
+    const velocityX = velocityDurationMs > 0 ? deltaX / velocityDurationMs : 0;
+    const velocityY = velocityDurationMs > 0 ? deltaY / velocityDurationMs : 0;
+    let releaseVelocityX = lastDragVelocityRef.current.x;
+    let releaseVelocityY = lastDragVelocityRef.current.y;
+    const lastSample = lastDragSampleRef.current;
+    if (lastSample && endTime !== null && endTime >= lastSample.time) {
+      const ageMs = endTime - lastSample.time;
+      if (ageMs <= MAX_RELEASE_VELOCITY_AGE_MS) {
+        const sampleDurationMs = Math.max(ageMs, MIN_RELEASE_VELOCITY_DURATION_MS);
+        const deltaFromLastSampleX = resolvedDragOffset.x - lastSample.x;
+        const deltaFromLastSampleY = resolvedDragOffset.y - lastSample.y;
+        const sampleVelocityX = deltaFromLastSampleX / sampleDurationMs;
+        const sampleVelocityY = deltaFromLastSampleY / sampleDurationMs;
+        if (sampleVelocityX !== 0) {
+          releaseVelocityX = sampleVelocityX;
+        }
+        if (sampleVelocityY !== 0) {
+          releaseVelocityY = sampleVelocityY;
+        }
+      } else {
+        releaseVelocityX = 0;
+        releaseVelocityY = 0;
+      }
+    }
+    const releaseDecision = onRelease?.({
+      event: event.nativeEvent,
+      direction: intendedSwipeDirectionRef.current,
+      deltaX,
+      deltaY,
+      velocityX,
+      velocityY,
+      releaseVelocityX,
+      releaseVelocityY
+    });
+    const hasReleaseDecision = typeof releaseDecision === 'boolean';
+    if (cancelledSwipeRef.current && !hasReleaseDecision) {
+      dragOffsetRef.current = {
+        x: resolvedInitialTransform.x,
+        y: resolvedInitialTransform.y
+      };
+      setCurrentSwipeDirection(undefined);
+      syncDragStyles(false);
+      updateSwipeProgress(0, progressDetails);
+      return;
+    }
+    let shouldClose = false;
+    let dismissDirection;
+    if (hasReleaseDecision) {
+      shouldClose = releaseDecision;
+      dismissDirection = intendedSwipeDirectionRef.current ?? primaryDirection;
+    } else {
+      for (const direction of directions) {
+        switch (direction) {
+          case 'right':
+            if (deltaX > swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'right';
+            }
+            break;
+          case 'left':
+            if (deltaX < -swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'left';
+            }
+            break;
+          case 'down':
+            if (deltaY > swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'down';
+            }
+            break;
+          case 'up':
+            if (deltaY < -swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'up';
+            }
+            break;
+        }
+        if (shouldClose) {
+          break;
+        }
+      }
+    }
+    if (shouldClose && dismissDirection) {
+      setCurrentSwipeDirection(dismissDirection);
+      setDragDismissed(true);
+      syncDragStyles(false);
+      onDismiss?.(event.nativeEvent, {
+        direction: dismissDirection
+      });
+    } else {
+      dragOffsetRef.current = {
+        x: resolvedInitialTransform.x,
+        y: resolvedInitialTransform.y
+      };
+      setCurrentSwipeDirection(undefined);
+      syncDragStyles(false);
+      updateSwipeProgress(0, progressDetails);
+    }
+  });
+  const handleMove = useButton.useStableCallback(event => {
+    const currentPos = getPrimaryPointerPosition(event);
+    if (!currentPos) {
+      return;
+    }
+    let endAfterMove = false;
+    if (!('touches' in event)) {
+      const hasPrimaryButton = hasPrimaryMouseButton(event.buttons);
+      if (hasPrimaryButton) {
+        sawPrimaryButtonsOnMoveRef.current = true;
+      }
+
+      // Cancel the swipe if a non-primary button takes over the interaction.
+      // This handles cases where a right-click interrupts dragging.
+      if (event.buttons !== 0 && !hasPrimaryButton) {
+        cancelSwipeInteraction(event);
+        return;
+      }
+
+      // A `buttons: 0` pointermove means the primary button was already released, so the gesture is
+      // over even if no pointerup reached us. On fast trackpad flicks this trailing move is
+      // dispatched just before pointerup; treat it as the release (mirroring touchend) instead of
+      // cancelling and snapping the element back.
+      if (event.buttons === 0 && sawPrimaryButtonsOnMoveRef.current) {
+        if (!isSwipingRef.current) {
+          // The gesture never activated — discard it.
+          handleEnd(event);
+          return;
+        }
+        // This release move can itself carry the threshold-crossing displacement (and the peak
+        // release velocity), so let it flow through `handleMoveCore` below to update the drag
+        // offset / velocity sample, then commit the release afterwards.
+        endAfterMove = true;
+      }
+    }
+    if (!isSwiping && pendingSwipeRef.current) {
+      if (!isTouchLikeEvent(event) && (event.defaultPrevented || event.nativeEvent.defaultPrevented)) {
+        resetPendingSwipeState();
+        return;
+      }
+      const allowedToStart = canStart ? canStart(currentPos, {
+        nativeEvent: event.nativeEvent,
+        direction: primaryDirection
+      }) : true;
+      if (allowedToStart) {
+        const pendingStartPos = pendingSwipeStartPosRef.current;
+        let ignoreScrollableOnStart = false;
+        if (isTouchLikeEvent(event)) {
+          const element = elementRef.current;
+          if (pendingStartPos && element) {
+            const target = getTargetAtPoint(currentPos, event.nativeEvent);
+            const doc = useButton.ownerDocument(element);
+            const body = doc.body;
+            const scrollTarget = body ? findGestureScrollableTouchTarget(target, body) : null;
+            if (scrollTarget && (useButton.contains(element, scrollTarget) || useButton.contains(scrollTarget, element))) {
+              const deltaX = currentPos.x - pendingStartPos.x;
+              const deltaY = currentPos.y - pendingStartPos.y;
+              const canSwipeFromEdge = canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY);
+              if (canSwipeFromEdge === false) {
+                return;
+              }
+              if (canSwipeFromEdge === true) {
+                ignoreScrollableOnStart = true;
+              }
+            }
+          }
+        }
+        const started = startSwipeAtPosition(event, currentPos, {
+          ignoreScrollableTarget: ignoreScrollableOnStart,
+          ignoreScrollableAncestors: ignoreScrollableOnStart
+        });
+        if (started) {
+          if (pendingStartPos && ignoreScrollableOnStart) {
+            // Preserve displacement between touchstart and the move that activates swipe from
+            // a scroll-edge so quick flicks can dismiss.
+            clearPendingSwipeStartState();
+            dragStartPosRef.current = pendingStartPos;
+            swipeCancelBaselineRef.current = pendingStartPos;
+            lastMovePosRef.current = pendingStartPos;
+            isFirstPointerMoveRef.current = false;
+          } else {
+            // Start from the current in-bounds position without dropping follow-up move
+            // displacement; this avoids jumps when entering from outside the element while
+            // keeping swipe tracking responsive on the next move.
+            clearPendingSwipeStartState();
+            swipeFromScrollableRef.current = false;
+          }
+        }
+      }
+    }
+    const previousPos = lastMovePosRef.current;
+    const movement = previousPos === null ? {
+      x: 0,
+      y: 0
+    } : {
+      x: currentPos.x - previousPos.x,
+      y: currentPos.y - previousPos.y
+    };
+    lastMovePosRef.current = currentPos;
+    handleMoveCore(event, currentPos, movement);
+
+    // `endAfterMove` is only set in the non-touch branch above; the `'touches'` guard re-narrows the
+    // event type for `handleEnd` after the shared move handling has run.
+    if (endAfterMove && !('touches' in event)) {
+      handleEnd(event);
+    }
+  });
+
+  // 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) => {
+    handleMove({
+      touches: nativeEvent.touches,
+      currentTarget,
+      nativeEvent,
+      defaultPrevented: nativeEvent.defaultPrevented,
+      timeStamp: nativeEvent.timeStamp
+    });
+  });
+  const getDragStyles = React__namespace.useCallback(() => {
+    const dragOffset = dragOffsetRef.current;
+    const initialTransform = initialTransformRef.current;
+    const deltaX = dragOffset.x - initialTransform.x;
+    const deltaY = dragOffset.y - initialTransform.y;
+    if (!isSwiping && deltaX === 0 && deltaY === 0 && !dragDismissed) {
+      return {
+        [movementCssVars.x]: '0px',
+        [movementCssVars.y]: '0px'
+      };
+    }
+    return {
+      transition: isSwiping ? 'none' : undefined,
+      // While swiping, freeze the element at its current visual transform so it doesn't snap to the
+      // end position.
+      transform: isSwiping ? getDragTransform(dragOffset, initialTransform.scale) : undefined,
+      [movementCssVars.x]: `${deltaX}px`,
+      [movementCssVars.y]: `${deltaY}px`
+    };
+  }, [dragDismissed, isSwiping, movementCssVars]);
+  const getPointerProps = React__namespace.useCallback(() => {
+    if (!enabled) {
+      return {};
+    }
+    return {
+      onPointerDown: handleStart,
+      onPointerMove: handleMove,
+      onPointerUp: handleEnd,
+      onPointerCancel: handleEnd
+    };
+  }, [enabled, handleEnd, handleMove, handleStart]);
+  const getTouchProps = React__namespace.useCallback(() => {
+    if (!enabled) {
+      return {};
+    }
+    return {
+      onTouchStart: handleStart,
+      onTouchMove: handleMove,
+      onTouchEnd: handleEnd,
+      onTouchCancel: handleEnd
+    };
+  }, [enabled, handleEnd, handleMove, handleStart]);
+  return {
+    swiping: isSwiping,
+    swipeDirection: currentSwipeDirection,
+    dragDismissed,
+    getPointerProps,
+    getTouchProps,
+    moveNative,
+    getDragStyles,
+    reset
+  };
+}
+
+/**
+ * A button that opens the drawer.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+const DrawerTrigger = DialogTrigger;
+
+const DrawerVirtualKeyboardContext = /*#__PURE__*/React__namespace.createContext(undefined);
+if (process.env.NODE_ENV !== "production") DrawerVirtualKeyboardContext.displayName = "DrawerVirtualKeyboardContext";
+function useDrawerVirtualKeyboardContext() {
+  return React__namespace.useContext(DrawerVirtualKeyboardContext);
+}
+
+const MIN_SWIPE_THRESHOLD = 10;
+const FAST_SWIPE_VELOCITY = 0.5;
+const SNAP_VELOCITY_THRESHOLD = 0.5;
+const SNAP_VELOCITY_MULTIPLIER = 300;
+const MAX_SNAP_VELOCITY = 4;
+const MIN_SWIPE_RELEASE_VELOCITY = 0.2;
+const MAX_SWIPE_RELEASE_VELOCITY = 4;
+const MIN_SWIPE_RELEASE_DURATION_MS = 80;
+const MAX_SWIPE_RELEASE_DURATION_MS = 360;
+const MIN_SWIPE_RELEASE_SCALAR = 0.1;
+const MAX_SWIPE_RELEASE_SCALAR = 1;
+const DRAWER_CONTENT_SELECTOR = `[${DRAWER_CONTENT_ATTRIBUTE}]`;
+/**
+ * A positioning container for the drawer popup that can be made scrollable.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerViewport(props, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    children,
+    ...elementProps
+  } = props;
+  const {
+    store
+  } = useDialogRootContext();
+  const popupRef = store.context.popupRef;
+  const backdropRef = store.context.backdropRef;
+  const {
+    swipeDirection,
+    notifyParentSwipingChange,
+    notifyParentSwipeProgressChange,
+    frontmostHeight,
+    snapToSequentialPoints
+  } = useDrawerRootContext();
+  const providerContext = useDrawerProviderContext();
+  const {
+    snapPoints,
+    resolvedSnapPoints,
+    activeSnapPoint,
+    activeSnapPointOffset,
+    setActiveSnapPoint,
+    popupHeight
+  } = useDrawerSnapPoints();
+  const open = store.useState('open');
+  const mounted = store.useState('mounted');
+  const nested = store.useState('nested');
+  const nestedOpenDrawerCount = store.useState('nestedOpenDrawerCount');
+  const viewportElement = store.useState('viewportElement');
+  const popupElementState = store.useState('popupElement');
+  const visualStateStore = providerContext?.visualStateStore;
+  const nestedDrawerOpen = nestedOpenDrawerCount > 0;
+  const scrollAxis = swipeDirection === 'left' || swipeDirection === 'right' ? 'horizontal' : 'vertical';
+  const isVerticalScrollAxis = scrollAxis === 'vertical';
+  const crossScrollAxis = isVerticalScrollAxis ? 'horizontal' : 'vertical';
+  const [swipeRelease, setSwipeRelease] = React__namespace.useState(null);
+  const pendingSwipeCloseSnapPointRef = React__namespace.useRef(undefined);
+  const resetSwipeRef = React__namespace.useRef(null);
+  const controlledDismissFrame = useButton.useAnimationFrame();
+  const swipingRef = React__namespace.useRef(false);
+  const nestedSwipeActiveRef = React__namespace.useRef(false);
+  const lastPointerTypeRef = React__namespace.useRef('');
+  const ignoreNextTouchStartFromPenRef = React__namespace.useRef(false);
+  const ignoreTouchSwipeRef = React__namespace.useRef(false);
+  const touchScrollStateRef = React__namespace.useRef(null);
+  const virtualKeyboard = useDrawerVirtualKeyboardContext();
+  const snapPointRange = React__namespace.useMemo(() => {
+    if (!snapPoints || snapPoints.length < 2) {
+      return null;
+    }
+    if (swipeDirection !== 'down' && swipeDirection !== 'up') {
+      return null;
+    }
+    if (resolvedSnapPoints.length < 2) {
+      return null;
+    }
+    const offsets = resolvedSnapPoints.map(point => point.offset).filter(offset => Number.isFinite(offset)).sort((a, b) => a - b);
+    if (offsets.length < 2) {
+      return null;
+    }
+    const minOffset = offsets[0];
+    const nextOffset = offsets[1];
+    const maxOffset = offsets[offsets.length - 1];
+    let range = nextOffset - minOffset;
+    if (!Number.isFinite(range) || range <= 0) {
+      const fallbackRange = maxOffset - minOffset;
+      if (!Number.isFinite(fallbackRange) || fallbackRange <= 0) {
+        return null;
+      }
+      range = fallbackRange;
+    }
+    return {
+      minOffset,
+      range
+    };
+  }, [resolvedSnapPoints, snapPoints, swipeDirection]);
+  const snapPointProgress = React__namespace.useMemo(() => {
+    if (!snapPointRange || activeSnapPointOffset === null) {
+      return null;
+    }
+    return clamp.clamp((activeSnapPointOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+  }, [activeSnapPointOffset, snapPointRange]);
+  const swipeDirections = React__namespace.useMemo(() => {
+    if (snapPoints && snapPoints.length > 0 && (swipeDirection === 'down' || swipeDirection === 'up')) {
+      return swipeDirection === 'down' ? ['down', 'up'] : ['up', 'down'];
+    }
+    return [swipeDirection];
+  }, [snapPoints, swipeDirection]);
+  const setSwipeDismissed = useButton.useStableCallback(dismissed => {
+    setSwipeDismissedElements(popupRef.current, backdropRef.current, dismissed);
+  });
+  const clearSwipeRelease = useButton.useStableCallback(() => {
+    setSwipeDismissed(false);
+    popupRef.current?.removeAttribute(useButton.TransitionStatusDataAttributes.endingStyle);
+    setSwipeRelease(null);
+  });
+  const finishNestedSwipe = useButton.useStableCallback(() => {
+    if (!nestedSwipeActiveRef.current) {
+      return;
+    }
+    nestedSwipeActiveRef.current = false;
+    notifyParentSwipingChange?.(false);
+  });
+  const applySwipeProgress = useButton.useStableCallback(({
+    resolvedProgress,
+    shouldTrackProgress,
+    notifyParent
+  }) => {
+    const isActive = open && !nested && shouldTrackProgress;
+    const swipeProgress = isActive ? resolvedProgress : 0;
+    const nestedSwipeProgress = open && shouldTrackProgress ? resolvedProgress : 0;
+    if (notifyParent && notifyParentSwipeProgressChange) {
+      notifyParentSwipeProgressChange(nestedSwipeProgress);
+      if (nestedSwipeProgress <= 0) {
+        finishNestedSwipe();
+      }
+    }
+    visualStateStore?.set({
+      swipeProgress,
+      frontmostHeight: swipeProgress > 0 ? frontmostHeight : 0
+    });
+    const backdropElement = backdropRef.current;
+    if (!backdropElement) {
+      return;
+    }
+    if (!isActive || swipeProgress <= 0) {
+      backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, '0');
+      backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+      return;
+    }
+    backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, `${swipeProgress}`);
+    if (frontmostHeight > 0) {
+      backdropElement.style.setProperty(DrawerPopupCssVars.height, `${frontmostHeight}px`);
+    } else {
+      backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+    }
+  });
+  function resolveSwipeRelease({
+    direction,
+    deltaX,
+    deltaY,
+    velocityX,
+    velocityY,
+    releaseVelocityX,
+    releaseVelocityY
+  }) {
+    if (!direction) {
+      return null;
+    }
+    const popupElement = store.context.popupRef.current;
+    if (!popupElement) {
+      return null;
+    }
+    const size = direction === 'left' || direction === 'right' ? popupElement.offsetWidth : popupElement.offsetHeight;
+    if (!Number.isFinite(size) || size <= 0) {
+      return null;
+    }
+    const axisDelta = direction === 'left' || direction === 'right' ? deltaX : deltaY;
+    const snapPointBaseOffset = snapPoints && snapPoints.length > 0 ? activeSnapPointOffset ?? 0 : 0;
+    let baseOffset = 0;
+    if (direction === 'down') {
+      baseOffset = snapPointBaseOffset;
+    } else if (direction === 'up') {
+      baseOffset = -snapPointBaseOffset;
+    }
+    const translation = baseOffset + axisDelta;
+    const translationAlongDirection = direction === 'left' || direction === 'up' ? -translation : translation;
+    const remainingDistance = Math.max(0, size - translationAlongDirection);
+    if (!Number.isFinite(remainingDistance) || remainingDistance <= 0) {
+      return null;
+    }
+    const axisVelocity = direction === 'left' || direction === 'right' ? releaseVelocityX : releaseVelocityY;
+    const fallbackVelocity = direction === 'left' || direction === 'right' ? velocityX : velocityY;
+    const resolvedVelocity = Math.abs(axisVelocity) > 0 && Number.isFinite(axisVelocity) ? axisVelocity : fallbackVelocity;
+    const directionalVelocity = direction === 'left' || direction === 'up' ? -resolvedVelocity : resolvedVelocity;
+    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);
+    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);
+    if (!Number.isFinite(durationScalar) || durationScalar <= 0) {
+      return null;
+    }
+    return durationScalar;
+  }
+  function updateNestedSwipeActive(details) {
+    if (nestedSwipeActiveRef.current || !details) {
+      return;
+    }
+    const direction = details.direction ?? swipeDirection;
+    const delta = direction === 'left' || direction === 'right' ? details.deltaX : details.deltaY;
+    if (!Number.isFinite(delta) || Math.abs(delta) < MIN_SWIPE_THRESHOLD) {
+      return;
+    }
+    nestedSwipeActiveRef.current = true;
+    notifyParentSwipingChange?.(true);
+  }
+  const swipe = useSwipeDismiss({
+    enabled: mounted && !nestedDrawerOpen,
+    directions: swipeDirections,
+    elementRef: store.context.popupRef,
+    ignoreSelectorWhenTouch: false,
+    ignoreScrollableAncestors: true,
+    movementCssVars: {
+      x: DrawerPopupCssVars.swipeMovementX,
+      y: DrawerPopupCssVars.swipeMovementY
+    },
+    onSwipeStart(event) {
+      if ('touches' in event || 'pointerType' in event && event.pointerType === 'touch') {
+        return;
+      }
+      const popupElement = popupRef.current;
+      if (!popupElement) {
+        return;
+      }
+      const doc = useButton.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)) {
+        return;
+      }
+      selection.removeAllRanges();
+    },
+    onSwipingChange(swiping) {
+      swipingRef.current = swiping;
+      setBackdropSwipingAttribute(store.context.backdropRef.current, swiping);
+      if (!swiping && !notifyParentSwipeProgressChange) {
+        finishNestedSwipe();
+      }
+    },
+    swipeThreshold({
+      element,
+      direction
+    }) {
+      return getBaseSwipeThreshold(element, direction);
+    },
+    canStart(position, details) {
+      const popupElement = store.context.popupRef.current;
+      if (!popupElement) {
+        return false;
+      }
+      const doc = popupElement.ownerDocument;
+      const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
+      if (!elementAtPoint || !useButton.contains(popupElement, elementAtPoint)) {
+        return false;
+      }
+      const nativeEvent = details.nativeEvent;
+      const touchLike = 'touches' in nativeEvent || 'pointerType' in nativeEvent && nativeEvent.pointerType === 'touch';
+      if (touchLike && shouldIgnoreSwipeForTextSelection(doc, popupElement)) {
+        return false;
+      }
+      if (nativeEvent.type === 'touchstart' && isSwipeIgnoredTarget(elementAtPoint)) {
+        return false;
+      }
+      return true;
+    },
+    onProgress(progress, details) {
+      updateNestedSwipeActive(details);
+      const hasSnapPoints = Boolean(snapPoints && snapPoints.length > 0);
+      if (swipingRef.current && swipeDirection === 'down' && hasSnapPoints && details && Number.isFinite(details.deltaY)) {
+        const popupElement = store.context.popupRef.current;
+        if (popupElement) {
+          popupElement.style.removeProperty('transform');
+          popupElement.style.setProperty(DrawerPopupCssVars.swipeMovementY, `${getSnapPointSwipeMovement(activeSnapPointOffset ?? 0, details.deltaY)}px`);
+        }
+      }
+      const currentDirection = details?.direction ?? swipe.swipeDirection;
+      const isDismissSwipe = currentDirection === undefined || currentDirection === swipeDirection;
+      const isVerticalSwipe = swipeDirection === 'down' || swipeDirection === 'up';
+      const shouldTrackProgress = hasSnapPoints && isVerticalSwipe || !hasSnapPoints || swipeDirection === 'left' || swipeDirection === 'right' || isDismissSwipe;
+      let resolvedProgress = progress;
+      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);
+        } 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);
+        }
+      }
+      applySwipeProgress({
+        resolvedProgress,
+        shouldTrackProgress,
+        notifyParent: true
+      });
+    },
+    onRelease({
+      event,
+      deltaX,
+      deltaY,
+      direction,
+      velocityX,
+      velocityY,
+      releaseVelocityX,
+      releaseVelocityY
+    }) {
+      const swipeReleasePayload = {
+        deltaX,
+        deltaY,
+        velocityX,
+        velocityY,
+        releaseVelocityX,
+        releaseVelocityY
+      };
+      function startSwipeRelease(resolvedDirection) {
+        // Start ending transition styles earlier and synchronously to prevent a period where
+        // the popup appears stuck on release before the actual closing animation starts.
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) {
+          return;
+        }
+        finishNestedSwipe();
+        setSwipeDismissed(true);
+        popupElement.style.removeProperty('transition');
+        popupElement.setAttribute(useButton.TransitionStatusDataAttributes.endingStyle, '');
+        ReactDOM__namespace.flushSync(() => {
+          setSwipeRelease(resolveSwipeRelease({
+            direction: resolvedDirection,
+            ...swipeReleasePayload
+          }));
+        });
+      }
+      if (!snapPoints || snapPoints.length === 0) {
+        if (!direction) {
+          clearSwipeRelease();
+          return undefined;
+        }
+        const element = store.context.popupRef.current;
+        if (!element) {
+          clearSwipeRelease();
+          return undefined;
+        }
+        const baseThreshold = getBaseSwipeThreshold(element, direction);
+        const delta = direction === 'left' || direction === 'right' ? deltaX : deltaY;
+        if (!Number.isFinite(delta)) {
+          clearSwipeRelease();
+          return undefined;
+        }
+        const directionalDelta = direction === 'left' || direction === 'up' ? -delta : delta;
+        if (directionalDelta <= 0) {
+          clearSwipeRelease();
+          return false;
+        }
+        const velocity = direction === 'left' || direction === 'right' ? velocityX : velocityY;
+        const directionalVelocity = direction === 'left' || direction === 'up' ? -velocity : velocity;
+        if (directionalVelocity >= FAST_SWIPE_VELOCITY && directionalDelta > 0) {
+          startSwipeRelease(direction);
+          return true;
+        }
+        const shouldClose = directionalDelta > baseThreshold;
+        if (shouldClose) {
+          startSwipeRelease(direction);
+        } else {
+          clearSwipeRelease();
+        }
+        return shouldClose;
+      }
+      if (swipeDirection !== 'down' && swipeDirection !== 'up') {
+        clearSwipeRelease();
+        return undefined;
+      }
+      if (!popupHeight || resolvedSnapPoints.length === 0) {
+        clearSwipeRelease();
+        return undefined;
+      }
+      const dragDelta = swipeDirection === 'down' ? deltaY : -deltaY;
+      if (!Number.isFinite(dragDelta)) {
+        clearSwipeRelease();
+        return undefined;
+      }
+      const dragDirection = Math.sign(dragDelta);
+      const releaseDirectionalVelocity = swipeDirection === 'down' ? releaseVelocityY : -releaseVelocityY;
+      const fallbackDirectionalVelocity = swipeDirection === 'down' ? velocityY : -velocityY;
+      let resolvedDirectionalVelocity = Number.isFinite(releaseDirectionalVelocity) ? releaseDirectionalVelocity : fallbackDirectionalVelocity;
+      if (dragDirection !== 0 && Math.abs(dragDelta) >= MIN_SWIPE_THRESHOLD && Number.isFinite(resolvedDirectionalVelocity)) {
+        const velocityDirection = Math.sign(resolvedDirectionalVelocity);
+        if (velocityDirection !== 0 && velocityDirection !== dragDirection) {
+          // Ignore touch reversals that would otherwise flip the snap decision.
+          resolvedDirectionalVelocity = fallbackDirectionalVelocity;
+        }
+      }
+      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 closeFromSnapPoints = () => {
+        pendingSwipeCloseSnapPointRef.current = activeSnapPoint;
+        setActiveSnapPoint?.(null, snapPointEventDetails);
+        startSwipeRelease(swipeDirection);
+        return true;
+      };
+      if (snapToSequentialPoints) {
+        const orderedSnapPoints = [...resolvedSnapPoints].sort((first, second) => first.offset - second.offset);
+        if (orderedSnapPoints.length === 0) {
+          clearSwipeRelease();
+          return false;
+        }
+        let currentIndex = 0;
+        let closestDistance = Math.abs(currentOffset - orderedSnapPoints[0].offset);
+        for (let index = 1; index < orderedSnapPoints.length; index += 1) {
+          const distance = Math.abs(currentOffset - orderedSnapPoints[index].offset);
+          if (distance < closestDistance) {
+            closestDistance = distance;
+            currentIndex = index;
+          }
+        }
+        let targetSnapPoint = orderedSnapPoints[0];
+        closestDistance = Math.abs(targetOffset - targetSnapPoint.offset);
+        for (const snapPoint of orderedSnapPoints) {
+          const distance = Math.abs(targetOffset - snapPoint.offset);
+          if (distance < closestDistance) {
+            closestDistance = distance;
+            targetSnapPoint = snapPoint;
+          }
+        }
+        const velocityDirection = Math.sign(resolvedDirectionalVelocity);
+        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);
+          if (adjacentIndex !== currentIndex) {
+            const adjacentPoint = orderedSnapPoints[adjacentIndex];
+            const shouldForceAdjacent = dragDirection > 0 ? targetOffset < adjacentPoint.offset : targetOffset > adjacentPoint.offset;
+            if (shouldForceAdjacent) {
+              targetSnapPoint = adjacentPoint;
+              effectiveTargetOffset = adjacentPoint.offset;
+            }
+          } else if (dragDirection > 0) {
+            return closeFromSnapPoints();
+          }
+        }
+        const closeOffset = popupHeight;
+        const closeDistance = Math.abs(effectiveTargetOffset - closeOffset);
+        const snapDistance = Math.abs(effectiveTargetOffset - targetSnapPoint.offset);
+        if (closeDistance < snapDistance) {
+          return closeFromSnapPoints();
+        }
+        setActiveSnapPoint?.(targetSnapPoint.value, snapPointEventDetails);
+        clearSwipeRelease();
+        return false;
+      }
+      if (resolvedDirectionalVelocity >= FAST_SWIPE_VELOCITY && dragDelta > 0) {
+        return closeFromSnapPoints();
+      }
+      let closestSnapPoint = resolvedSnapPoints[0];
+      let closestDistance = Math.abs(targetOffset - closestSnapPoint.offset);
+      for (const snapPoint of resolvedSnapPoints) {
+        const distance = Math.abs(targetOffset - snapPoint.offset);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestSnapPoint = snapPoint;
+        }
+      }
+      const closeOffset = popupHeight;
+      const closeDistance = Math.abs(targetOffset - closeOffset);
+      if (closeDistance < closestDistance) {
+        return closeFromSnapPoints();
+      }
+      setActiveSnapPoint?.(closestSnapPoint.value, snapPointEventDetails);
+      clearSwipeRelease();
+      return false;
+    },
+    onDismiss(event) {
+      visualStateStore?.set({
+        swipeProgress: 0,
+        frontmostHeight: 0
+      });
+      const backdropElement = store.context.backdropRef.current;
+      if (backdropElement) {
+        backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, '0');
+        backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+      }
+      const dismissEventDetails = useButton.createChangeEventDetails(useButton.swipe, event);
+      store.setOpen(false, dismissEventDetails);
+      if (dismissEventDetails.isCanceled) {
+        const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
+        if (pendingSnapPoint !== undefined) {
+          setActiveSnapPoint?.(pendingSnapPoint, useButton.createChangeEventDetails(useButton.swipe, event));
+        }
+        pendingSwipeCloseSnapPointRef.current = undefined;
+        resetSwipeRef.current?.();
+        clearSwipeRelease();
+        return;
+      }
+
+      // In controlled mode, the effective open state may not have changed yet
+      // (openProp takes precedence over state.open). Proceed optimistically with the
+      // dismiss animation — React's Scheduler flushes before the next rAF, so we can
+      // reliably check whether the parent accepted or rejected the close.
+      // Note: if onOpenChange is asynchronous (e.g., closes the drawer after a network
+      // call), the rAF check will see open === true, revert the animation, and the
+      // drawer will close without animation when the parent eventually sets open={false}.
+      if (store.select('open')) {
+        const savedEvent = event;
+        controlledDismissFrame.request(() => {
+          if (store.select('open')) {
+            // Parent rejected: revert animation and restore snap point.
+            const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
+            if (pendingSnapPoint !== undefined) {
+              setActiveSnapPoint?.(pendingSnapPoint, useButton.createChangeEventDetails(useButton.swipe, savedEvent));
+            }
+            pendingSwipeCloseSnapPointRef.current = undefined;
+            clearSwipeRelease();
+            resetSwipeRef.current?.();
+          } else {
+            // Parent accepted: clean up the ref.
+            pendingSwipeCloseSnapPointRef.current = undefined;
+          }
+        });
+        return;
+      }
+      pendingSwipeCloseSnapPointRef.current = undefined;
+      setSwipeDismissed(true);
+    }
+  });
+  const swipePointerProps = swipe.getPointerProps();
+  const swipeTouchProps = swipe.getTouchProps();
+  const {
+    moveNative: moveSwipeNative,
+    reset: resetSwipe
+  } = swipe;
+  resetSwipeRef.current = resetSwipe;
+  React__namespace.useEffect(() => {
+    const rootElement = viewportElement ?? popupElementState;
+    if (!rootElement) {
+      return undefined;
+    }
+    const resolvedRootElement = rootElement;
+    const doc = useButton.ownerDocument(resolvedRootElement);
+    const win = floatingUi_utils_dom.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
+      // `stopPropagation()`, which would otherwise prevent React's delegated handlers
+      // (and the provider) from ever seeing the move.
+      virtualKeyboard?.onTouchMove(event);
+      if (ignoreTouchSwipeRef.current) {
+        return;
+      }
+      const touchState = touchScrollStateRef.current;
+      const touch = event.touches[0];
+      if (!touch || !touchState) {
+        return;
+      }
+      const drawerAxisDelta = isVerticalScrollAxis ? touch.clientY - touchState.lastY : touch.clientX - touchState.lastX;
+
+      // Preserve native range interaction by never locking touchmove for range inputs.
+      if (isEventOnRangeInput(event, win)) {
+        touchState.allowSwipe = false;
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+
+      // Avoid blocking pinch zoom or text selection adjustments on iOS Safari.
+      if (event.touches.length === 2) {
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+      const allowTouchMove = shouldIgnoreSwipeForTextSelection(doc, resolvedRootElement);
+      if (allowTouchMove || !open || !mounted || nestedDrawerOpen) {
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+      if (preserveNativeCrossAxisScrollOnMove(touchState, touch, isVerticalScrollAxis)) {
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+      const scrollTarget = touchState.scrollTarget;
+      if (!scrollTarget || scrollTarget === doc.documentElement || scrollTarget === doc.body) {
+        if (event.cancelable) {
+          event.preventDefault();
+        }
+        // Claim the gesture before React's delegated touch handlers see it; dispatching the
+        // move through React re-rasterizes the popup content on every frame.
+        event.stopPropagation();
+        moveSwipeNative(event, resolvedRootElement);
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+      const hasScrollableContent = hasScrollableContentOnAxis(scrollTarget, scrollAxis);
+      if (!hasScrollableContent) {
+        // If the scroll container doesn't overflow on the drawer axis, prevent the window from
+        // scrolling instead.
+        if (event.cancelable) {
+          event.preventDefault();
+        }
+        event.stopPropagation();
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+      const delta = drawerAxisDelta;
+      if (delta !== 0) {
+        const canSwipeFromScrollEdge = canSwipeFromScrollEdgeOnMove(scrollTarget, scrollAxis, swipeDirection, delta);
+        if (!touchState.allowSwipe) {
+          if (!event.cancelable) {
+            touchState.allowSwipe = false;
+          } else if (canSwipeFromScrollEdge) {
+            touchState.allowSwipe = true;
+            event.preventDefault();
+          } else {
+            touchState.allowSwipe = false;
+          }
+        } else if (event.cancelable) {
+          event.preventDefault();
+        }
+      }
+      if (touchState.allowSwipe === true) {
+        event.stopPropagation();
+        moveSwipeNative(event, resolvedRootElement);
+      }
+      updateTouchScrollPosition(touchState, touch);
+    }
+    return useButton.addEventListener(doc, 'touchmove', handleNativeTouchMove, {
+      passive: false,
+      capture: true
+    });
+  }, [mounted, nestedDrawerOpen, open, popupElementState, isVerticalScrollAxis, scrollAxis, swipeDirection, moveSwipeNative, viewportElement, virtualKeyboard]);
+  React__namespace.useEffect(() => {
+    if (!snapPointRange || swipe.swiping) {
+      return;
+    }
+    const resolvedProgress = !open || nested ? 0 : snapPointProgress ?? 0;
+    applySwipeProgress({
+      resolvedProgress,
+      shouldTrackProgress: true,
+      notifyParent: false
+    });
+  }, [applySwipeProgress, frontmostHeight, nested, notifyParentSwipeProgressChange, open, snapPointProgress, snapPointRange, swipe.swiping, store, visualStateStore]);
+  React__namespace.useEffect(() => {
+    if (!notifyParentSwipeProgressChange) {
+      return undefined;
+    }
+    if (!open) {
+      notifyParentSwipeProgressChange(0);
+    }
+    return () => {
+      notifyParentSwipeProgressChange(0);
+    };
+  }, [notifyParentSwipeProgressChange, open]);
+  React__namespace.useEffect(() => {
+    if (open) {
+      resetSwipe();
+      clearSwipeRelease();
+    }
+  }, [clearSwipeRelease, open, resetSwipe]);
+  React__namespace.useEffect(() => {
+    const backdropElement = backdropRef.current;
+    return () => {
+      visualStateStore?.set({
+        swipeProgress: 0,
+        frontmostHeight: 0
+      });
+      setBackdropSwipingAttribute(backdropElement, false);
+      // `data-swiping` is set on whichever backdrop is current when a swipe starts, which can
+      // differ from the captured element if the backdrop mounted late or changed identity.
+      // Reading the live ref here is intentional so the current backdrop is cleared too.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      const currentBackdrop = backdropRef.current;
+      if (currentBackdrop !== backdropElement) {
+        setBackdropSwipingAttribute(currentBackdrop, false);
+      }
+      finishNestedSwipe();
+    };
+  }, [backdropRef, finishNestedSwipe, visualStateStore]);
+  const swipeProviderValue = React__namespace.useMemo(() => ({
+    swiping: swipe.swiping,
+    getDragStyles: swipe.getDragStyles,
+    swipeStrength: swipeRelease ?? null,
+    setSwipeDismissed
+  }), [setSwipeDismissed, swipe.getDragStyles, swipe.swiping, swipeRelease]);
+  function resetTouchTrackingState() {
+    ignoreTouchSwipeRef.current = false;
+    touchScrollStateRef.current = null;
+    lastPointerTypeRef.current = '';
+    ignoreNextTouchStartFromPenRef.current = false;
+  }
+  return /*#__PURE__*/jsxRuntime.jsx(DialogViewport, {
+    ref: forwardedRef,
+    className: className,
+    style: style,
+    render: render,
+    ...useRenderElement.mergeProps(elementProps, {
+      onPointerDown(event) {
+        lastPointerTypeRef.current = event.pointerType;
+        ignoreNextTouchStartFromPenRef.current = event.pointerType === 'pen';
+        if (!open || !mounted || nestedDrawerOpen) {
+          return;
+        }
+        const doc = useButton.ownerDocument(event.currentTarget);
+        const elementAtPoint = getElementAtPoint(doc, event.clientX, event.clientY);
+        if (isSwipeIgnoredTarget(elementAtPoint) || isDrawerContentTarget(elementAtPoint)) {
+          return;
+        }
+        if (event.pointerType === 'touch') {
+          return;
+        }
+        swipePointerProps.onPointerDown?.(event);
+      },
+      onPointerMove(event) {
+        if (event.pointerType === 'touch') {
+          return;
+        }
+        swipePointerProps.onPointerMove?.(event);
+      },
+      onPointerUp(event) {
+        if (lastPointerTypeRef.current === event.pointerType) {
+          lastPointerTypeRef.current = '';
+        }
+        if (event.pointerType === 'touch') {
+          return;
+        }
+        swipePointerProps.onPointerUp?.(event);
+      },
+      onPointerCancel(event) {
+        if (lastPointerTypeRef.current === event.pointerType) {
+          lastPointerTypeRef.current = '';
+        }
+        if (event.pointerType === 'touch') {
+          return;
+        }
+        swipePointerProps.onPointerCancel?.(event);
+      },
+      onTouchStart(event) {
+        const startedFromPenPointerDown = lastPointerTypeRef.current === 'pen' && ignoreNextTouchStartFromPenRef.current;
+        if (startedFromPenPointerDown) {
+          ignoreNextTouchStartFromPenRef.current = false;
+          ignoreTouchSwipeRef.current = false;
+          touchScrollStateRef.current = null;
+          return;
+        }
+        if (!open || !mounted || nestedDrawerOpen) {
+          ignoreTouchSwipeRef.current = false;
+          touchScrollStateRef.current = null;
+          return;
+        }
+        const touch = event.touches[0];
+        if (!touch) {
+          return;
+        }
+        if (isReactTouchEventOnRangeInput(event)) {
+          ignoreTouchSwipeRef.current = false;
+          touchScrollStateRef.current = null;
+          return;
+        }
+        const doc = useButton.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)) {
+          ignoreTouchSwipeRef.current = true;
+          touchScrollStateRef.current = null;
+          return;
+        }
+        virtualKeyboard?.onTouchStart(event);
+        ignoreTouchSwipeRef.current = isSwipeIgnoredTarget(elementAtPoint);
+        if (ignoreTouchSwipeRef.current) {
+          touchScrollStateRef.current = null;
+          return;
+        }
+        let scrollTarget = null;
+        let hasCrossAxisScrollableContent = false;
+        if (rootElement && target) {
+          scrollTarget = findScrollableTouchTarget(target, rootElement, scrollAxis);
+          hasCrossAxisScrollableContent = findScrollableTouchTarget(target, rootElement, crossScrollAxis) != null;
+        }
+        let allowSwipe = null;
+        if (scrollTarget) {
+          const canSwipeFromEdge = isAtSwipeStartEdge(scrollTarget, scrollAxis, swipeDirection);
+          allowSwipe = canSwipeFromEdge ? null : false;
+        }
+        touchScrollStateRef.current = {
+          startX: touch.clientX,
+          startY: touch.clientY,
+          lastX: touch.clientX,
+          lastY: touch.clientY,
+          scrollTarget,
+          hasCrossAxisScrollableContent,
+          allowSwipe,
+          preserveNativeCrossAxisScroll: false
+        };
+        swipeTouchProps.onTouchStart?.(event);
+      },
+      onTouchEnd(event) {
+        virtualKeyboard?.onTouchEnd(event);
+        resetTouchTrackingState();
+        swipeTouchProps.onTouchEnd?.(event);
+      },
+      onTouchCancel(event) {
+        virtualKeyboard?.onTouchCancel();
+        resetTouchTrackingState();
+        swipeTouchProps.onTouchCancel?.(event);
+      },
+      // Drawer popups use drawer-specific nested state attributes.
+      // Suppress DialogViewport's generic nested dialog attribute.
+      ['data-nested-dialog-open']: undefined
+    }),
+    children: /*#__PURE__*/jsxRuntime.jsx(DrawerViewportContext.Provider, {
+      value: swipeProviderValue,
+      children: children
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") DrawerViewport.displayName = "DrawerViewport";
+function setSwipeDismissedElements(popupElement, backdropElement, dismissed) {
+  if (dismissed) {
+    popupElement?.setAttribute(DrawerPopupDataAttributes.swipeDismiss, '');
+    backdropElement?.setAttribute(DrawerPopupDataAttributes.swipeDismiss, '');
+    return;
+  }
+  popupElement?.removeAttribute(DrawerPopupDataAttributes.swipeDismiss);
+  backdropElement?.removeAttribute(DrawerPopupDataAttributes.swipeDismiss);
+}
+function setBackdropSwipingAttribute(backdropElement, swiping) {
+  if (!backdropElement) {
+    return;
+  }
+  if (swiping) {
+    backdropElement.setAttribute(DrawerPopupDataAttributes.swiping, '');
+    return;
+  }
+  backdropElement.removeAttribute(DrawerPopupDataAttributes.swiping);
+}
+function isSwipeIgnoredTarget(target) {
+  return Boolean(target?.closest(useScrollLock.BASE_UI_SWIPE_IGNORE_SELECTOR));
+}
+function isDrawerContentTarget(target) {
+  return Boolean(target?.closest(DRAWER_CONTENT_SELECTOR));
+}
+function getBaseSwipeThreshold(element, direction) {
+  const size = direction === 'left' || direction === 'right' ? element.offsetWidth : element.offsetHeight;
+  return Math.max(size * 0.5, MIN_SWIPE_THRESHOLD);
+}
+function isRangeInput(target, win) {
+  return target instanceof win.HTMLInputElement && target.type === 'range';
+}
+function isTextSelectionControl(target) {
+  if (!floatingUi_utils_dom.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);
+}
+function shouldIgnoreSwipeForTextSelection(doc, rootElement) {
+  const activeEl = useButton.activeElement(doc);
+  const activeElementWithinRoot = Boolean(activeEl && useButton.contains(rootElement, activeEl));
+  if (activeElementWithinRoot && isTextSelectionControl(activeEl)) {
+    const {
+      selectionStart,
+      selectionEnd
+    } = activeEl;
+    if (selectionStart != null && selectionEnd != null && selectionStart < selectionEnd) {
+      return true;
+    }
+  }
+  const selection = doc.getSelection?.();
+  if (!selection || selection.isCollapsed) {
+    return false;
+  }
+  return hasExpandedSelectionWithinTarget(selection, rootElement);
+}
+function isEventOnRangeInput(event, win) {
+  const composedPath = event.composedPath();
+  if (composedPath) {
+    return composedPath.some(pathTarget => isRangeInput(pathTarget, win));
+  }
+  return isRangeInput(useButton.getTarget(event), win);
+}
+function isReactTouchEventOnRangeInput(event) {
+  return isEventOnRangeInput(event.nativeEvent, floatingUi_utils_dom.getWindow(event.currentTarget));
+}
+function updateTouchScrollPosition(touchState, touch) {
+  touchState.lastX = touch.clientX;
+  touchState.lastY = touch.clientY;
+}
+function preserveNativeCrossAxisScrollOnMove(touchState, touch, isVerticalScrollAxis) {
+  if (touchState.preserveNativeCrossAxisScroll) {
+    return true;
+  }
+  if (touchState.allowSwipe === true || !touchState.hasCrossAxisScrollableContent) {
+    return false;
+  }
+  const drawerAxisGestureDelta = isVerticalScrollAxis ? touch.clientY - touchState.startY : touch.clientX - touchState.startX;
+  const crossAxisGestureDelta = isVerticalScrollAxis ? touch.clientX - touchState.startX : touch.clientY - touchState.startY;
+  const absDrawerAxisGestureDelta = Math.abs(drawerAxisGestureDelta);
+  const absCrossAxisGestureDelta = Math.abs(crossAxisGestureDelta);
+  if (absCrossAxisGestureDelta < 6 || absCrossAxisGestureDelta <= absDrawerAxisGestureDelta + 2) {
+    return false;
+  }
+  touchState.preserveNativeCrossAxisScroll = true;
+  return true;
+}
+function hasScrollableContentOnAxis(scrollTarget, axis) {
+  return axis === 'vertical' ? scrollTarget.scrollHeight > scrollTarget.clientHeight : scrollTarget.scrollWidth > scrollTarget.clientWidth;
+}
+function getScrollMetrics(scrollTarget, axis) {
+  if (axis === 'vertical') {
+    const max = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+    return {
+      offset: scrollTarget.scrollTop,
+      max
+    };
+  }
+  const max = Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth);
+  return {
+    offset: scrollTarget.scrollLeft,
+    max
+  };
+}
+function isAtSwipeStartEdge(scrollTarget, axis, direction) {
+  const {
+    offset,
+    max
+  } = getScrollMetrics(scrollTarget, axis);
+  const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+  if (dismissFromStartEdge === null) {
+    return false;
+  }
+  return dismissFromStartEdge ? offset <= 0 : offset >= max;
+}
+function canSwipeFromScrollEdgeOnMove(scrollTarget, axis, direction, delta) {
+  const {
+    offset,
+    max
+  } = getScrollMetrics(scrollTarget, axis);
+  const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+  if (dismissFromStartEdge === null) {
+    return false;
+  }
+  const movingTowardDismiss = dismissFromStartEdge ? delta > 0 : delta < 0;
+  if (!movingTowardDismiss) {
+    return false;
+  }
+  return dismissFromStartEdge ? offset <= 0 : offset >= max;
+}
+function shouldDismissFromStartEdge(direction, axis) {
+  if (axis === 'vertical') {
+    if (direction === 'down') {
+      return true;
+    }
+    if (direction === 'up') {
+      return false;
+    }
+    return null;
+  }
+  if (direction === 'right') {
+    return true;
+  }
+  if (direction === 'left') {
+    return false;
+  }
+  return null;
+}
 
 const ScrollAreaRootContext = /*#__PURE__*/React__namespace.createContext(undefined);
 if (process.env.NODE_ENV !== "production") ScrollAreaRootContext.displayName = "ScrollAreaRootContext";
@@ -2221,11 +4327,11 @@ function mergeHiddenState(prevState, nextState) {
   return nextState;
 }
 
-exports.DRAWER_CONTENT_ATTRIBUTE = DRAWER_CONTENT_ATTRIBUTE;
 exports.DialogPortal = DialogPortal;
 exports.DialogRoot = DialogRoot;
 exports.DialogStore = DialogStore;
 exports.DialogTrigger = DialogTrigger;
+exports.DialogViewport = DialogViewport;
 exports.DrawerBackdrop = DrawerBackdrop;
 exports.DrawerBackdropCssVars = DrawerBackdropCssVars;
 exports.DrawerContent = DrawerContent;
@@ -2236,19 +4342,23 @@ exports.DrawerPortal = DrawerPortal;
 exports.DrawerProviderContext = DrawerProviderContext;
 exports.DrawerRoot = DrawerRoot;
 exports.DrawerTrigger = DrawerTrigger;
-exports.DrawerViewportContext = DrawerViewportContext;
+exports.DrawerViewport = DrawerViewport;
+exports.DrawerVirtualKeyboardContext = DrawerVirtualKeyboardContext;
 exports.ScrollAreaRoot = ScrollAreaRoot;
 exports.ScrollAreaRootCssVars = ScrollAreaRootCssVars;
 exports.ScrollAreaViewport = ScrollAreaViewport;
 exports.createInitialPopupStoreState = createInitialPopupStoreState;
+exports.findScrollableTouchTarget = findScrollableTouchTarget;
+exports.getDisplacement = getDisplacement;
+exports.getElementAtPoint = getElementAtPoint;
+exports.getElementTransform = getElementTransform;
 exports.getOffset = getOffset;
-exports.getSnapPointSwipeMovement = getSnapPointSwipeMovement;
 exports.popupStoreSelectors = popupStoreSelectors;
 exports.scrollAreaStateAttributesMapping = scrollAreaStateAttributesMapping;
 exports.useDialogPortalContext = useDialogPortalContext;
 exports.useDialogRootContext = useDialogRootContext;
 exports.useDrawerProviderContext = useDrawerProviderContext;
 exports.useDrawerRootContext = useDrawerRootContext;
-exports.useDrawerSnapPoints = useDrawerSnapPoints;
 exports.useScrollAreaRootContext = useScrollAreaRootContext;
 exports.useScrollAreaViewportContext = useScrollAreaViewportContext;
+exports.useSwipeDismiss = useSwipeDismiss;