@jobber/components 8.27.0 → 8.27.1

package/dist/ScrollAreaViewport-es.js

@@ -1,11 +1,12 @@
 import * as React from 'react';
-import { E as EMPTY_OBJECT, f as formatErrorMessage, u as useRenderElement } from './useRenderElement-es.js';
-import { b as FloatingRootStore, P as PopupTriggerMap, t as createSelector, E as FloatingPortal, I as InternalBackdrop, G as inertValue, K as usePopupRootSync, L as useImplicitActiveTrigger, M as useOpenStateTransitions, y as useDismiss, s as useScrollLock, N as usePopupInteractionProps, R as ReactStore, O as setPopupOpenState, Q as usePopupStore, z as useOnFirstRender, T as useTriggerDataForwarding, x as useClick, U as useOpenMethodTriggerProps, V as CLICK_TRIGGER_IDENTIFIER, W as triggerOpenStateMapping, p as popupStateMapping, C as CommonPopupDataAttributes, F as FOCUSABLE_POPUP_PROPS, a as FloatingFocusManager, r as useDirection, J as webkit } from './useScrollLock-es.js';
-import { d as createChangeEventDetails, i as imperativeAction, g as getTarget, q as contains, u as useBaseUiId, c as useButton, t as transitionStatusMapping, b as useStableCallback, o as ownerDocument, a as useIsoLayoutEffect, S as SafeReact, j as error, f as useOpenChangeComplete, z as useControlled, C as none, l as useId, W as android, B as addEventListener, X as closeWatcher, h as useTimeout } from './useButton-es.js';
+import { E as EMPTY_OBJECT, f as formatErrorMessage, u as useRenderElement, m as mergeProps } from './useRenderElement-es.js';
+import { b as FloatingRootStore, P as PopupTriggerMap, t as createSelector, E as FloatingPortal, I as InternalBackdrop, G as inertValue, ag as usePopupRootSync, _ as useImplicitActiveTrigger, $ as useOpenStateTransitions, y as useDismiss, s as useScrollLock, a4 as usePopupInteractionProps, V as ReactStore, a1 as setPopupOpenState, ah as usePopupStore, z as useOnFirstRender, C as CommonPopupDataAttributes, p as popupStateMapping, ab as useTriggerDataForwarding, x as useClick, ai as useOpenMethodTriggerProps, aj as CLICK_TRIGGER_IDENTIFIER, af as triggerOpenStateMapping, F as FOCUSABLE_POPUP_PROPS, a as FloatingFocusManager, ak as BASE_UI_SWIPE_IGNORE_SELECTOR, r as useDirection, J as webkit } from './useScrollLock-es.js';
+import { d as createChangeEventDetails, i as imperativeAction, g as getTarget, q as contains, t as transitionStatusMapping, u as useBaseUiId, c as useButton, b as useStableCallback, o as ownerDocument, a as useIsoLayoutEffect, S as SafeReact, j as error, f as useOpenChangeComplete, z as useControlled, C as none, l as useId, a3 as android, B as addEventListener, a4 as closeWatcher, n as useAnimationFrame, p as activeElement, a5 as TransitionStatusDataAttributes, a6 as swipe, h as useTimeout } from './useButton-es.js';
 import { C as COMPOSITE_KEYS, u as useCSPContext, s as styleDisableScrollbar, n as normalizeScrollOffset } from './scrollEdges-es.js';
-import { c as clamp } from './clamp-es.js';
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { o as getWindow } from './floating-ui.utils.dom-es.js';
+import { o as getWindow, i as isHTMLElement, d as isLastTraversableNode, e as getParentNode, f as getComputedStyle$1, b as isElement } from './floating-ui.utils.dom-es.js';
+import * as ReactDOM from 'react-dom';
+import { c as clamp } from './clamp-es.js';
 
 function getEmptyRootContext() {
   return new FloatingRootStore({
@@ -439,6 +440,98 @@ function DialogRoot(props) {
   return useRenderDialogRoot(props, mode);
 }
 
+let DialogViewportDataAttributes = function (DialogViewportDataAttributes) {
+  /**
+   * Present when the dialog is open.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["open"] = CommonPopupDataAttributes.open] = "open";
+  /**
+   * Present when the dialog is closed.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["closed"] = CommonPopupDataAttributes.closed] = "closed";
+  /**
+   * Present when the dialog is animating in.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["startingStyle"] = CommonPopupDataAttributes.startingStyle] = "startingStyle";
+  /**
+   * Present when the dialog is animating out.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["endingStyle"] = 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 = {
+  ...popupStateMapping,
+  ...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.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('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.
@@ -1412,13 +1505,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 = getComputedStyle$1(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 (isHTMLElement(node) && node !== root && !isLastTraversableNode(node)) {
+    for (const axis of axes) {
+      if (isScrollable(node, axis)) {
+        return true;
+      }
+    }
+    node = 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 = isHTMLElement(target) ? target : null;
+  while (isHTMLElement(node) && node !== root && !isLastTraversableNode(node)) {
+    if (isScrollable(node, axis, allowOverflowIntent)) {
+      return node;
+    }
+    node = 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 = 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.useMemo(() => {
+    const axes = [];
+    if (hasVertical) {
+      axes.push('vertical');
+    }
+    if (hasHorizontal) {
+      axes.push('horizontal');
+    }
+    return axes;
+  }, [hasHorizontal, hasVertical]);
+  const [currentSwipeDirection, setCurrentSwipeDirection] = React.useState(undefined);
+  const [isSwiping, setIsSwiping] = React.useState(false);
+  const [dragDismissed, setDragDismissed] = React.useState(false);
+  const dragStartPosRef = React.useRef({
+    x: 0,
+    y: 0
+  });
+  const dragOffsetRef = React.useRef({
+    x: 0,
+    y: 0
+  });
+  const lastMovePosRef = React.useRef(null);
+  const initialTransformRef = React.useRef({
+    x: 0,
+    y: 0,
+    scale: 1
+  });
+  const intendedSwipeDirectionRef = React.useRef(undefined);
+  const maxSwipeDisplacementRef = React.useRef(0);
+  const cancelledSwipeRef = React.useRef(false);
+  const swipeCancelBaselineRef = React.useRef({
+    x: 0,
+    y: 0
+  });
+  const lockedDirectionRef = React.useRef(null);
+  const isFirstPointerMoveRef = React.useRef(false);
+  const pendingSwipeRef = React.useRef(false);
+  const pendingSwipeStartPosRef = React.useRef(null);
+  const swipeFromScrollableRef = React.useRef(false);
+  const sawPrimaryButtonsOnMoveRef = React.useRef(false);
+  const elementSizeRef = React.useRef({
+    width: 0,
+    height: 0
+  });
+  const swipeProgressRef = React.useRef(0);
+  const swipeThresholdRef = React.useRef(swipeThresholdDefault);
+  const swipeStartTimeRef = React.useRef(null);
+  const lastDragSampleRef = React.useRef(null);
+  const lastDragVelocityRef = React.useRef({
+    x: 0,
+    y: 0
+  });
+  const lastProgressDetailsRef = React.useRef(null);
+  const isSwipingRef = React.useRef(false);
+  const dragStyleSnapshotRef = React.useRef(null);
+  const setSwiping = 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 = useStableCallback((progress, details) => {
+    const nextProgress = Number.isFinite(progress) ? 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 = 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.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.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 = ownerDocument(elementRef.current);
+    const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
+    const target = elementAtPoint ?? 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 = 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 = 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 = 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 = 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 = 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 = ownerDocument(element);
+            const body = doc.body;
+            const scrollTarget = body ? findGestureScrollableTouchTarget(target, body) : null;
+            if (scrollTarget && (contains(element, scrollTarget) || 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 = useStableCallback((nativeEvent, currentTarget) => {
+    handleMove({
+      touches: nativeEvent.touches,
+      currentTarget,
+      nativeEvent,
+      defaultPrevented: nativeEvent.defaultPrevented,
+      timeStamp: nativeEvent.timeStamp
+    });
+  });
+  const getDragStyles = React.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.useCallback(() => {
+    if (!enabled) {
+      return {};
+    }
+    return {
+      onPointerDown: handleStart,
+      onPointerMove: handleMove,
+      onPointerUp: handleEnd,
+      onPointerCancel: handleEnd
+    };
+  }, [enabled, handleEnd, handleMove, handleStart]);
+  const getTouchProps = React.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.createContext(undefined);
+if (process.env.NODE_ENV !== "production") DrawerVirtualKeyboardContext.displayName = "DrawerVirtualKeyboardContext";
+function useDrawerVirtualKeyboardContext() {
+  return React.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.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.useState(null);
+  const pendingSwipeCloseSnapPointRef = React.useRef(undefined);
+  const resetSwipeRef = React.useRef(null);
+  const controlledDismissFrame = useAnimationFrame();
+  const swipingRef = React.useRef(false);
+  const nestedSwipeActiveRef = React.useRef(false);
+  const lastPointerTypeRef = React.useRef('');
+  const ignoreNextTouchStartFromPenRef = React.useRef(false);
+  const ignoreTouchSwipeRef = React.useRef(false);
+  const touchScrollStateRef = React.useRef(null);
+  const virtualKeyboard = useDrawerVirtualKeyboardContext();
+  const snapPointRange = React.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.useMemo(() => {
+    if (!snapPointRange || activeSnapPointOffset === null) {
+      return null;
+    }
+    return clamp((activeSnapPointOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+  }, [activeSnapPointOffset, snapPointRange]);
+  const swipeDirections = React.useMemo(() => {
+    if (snapPoints && snapPoints.length > 0 && (swipeDirection === 'down' || swipeDirection === 'up')) {
+      return swipeDirection === 'down' ? ['down', 'up'] : ['up', 'down'];
+    }
+    return [swipeDirection];
+  }, [snapPoints, swipeDirection]);
+  const setSwipeDismissed = useStableCallback(dismissed => {
+    setSwipeDismissedElements(popupRef.current, backdropRef.current, dismissed);
+  });
+  const clearSwipeRelease = useStableCallback(() => {
+    setSwipeDismissed(false);
+    popupRef.current?.removeAttribute(TransitionStatusDataAttributes.endingStyle);
+    setSwipeRelease(null);
+  });
+  const finishNestedSwipe = useStableCallback(() => {
+    if (!nestedSwipeActiveRef.current) {
+      return;
+    }
+    nestedSwipeActiveRef.current = false;
+    notifyParentSwipingChange?.(false);
+  });
+  const applySwipeProgress = 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(directionalVelocity, MIN_SWIPE_RELEASE_VELOCITY, MAX_SWIPE_RELEASE_VELOCITY);
+    const durationMs = 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(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$1 = 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 = ownerDocument(popupElement);
+      const selection = doc.getSelection?.();
+      if (!selection || selection.isCollapsed) {
+        return;
+      }
+      const anchorElement = isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+      const focusElement = isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+      if (!contains(popupElement, anchorElement) && !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 || !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$1.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(baseOffset + details.deltaY, 0, popupHeight);
+          resolvedProgress = 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((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(TransitionStatusDataAttributes.endingStyle, '');
+        ReactDOM.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(currentOffset + dragDelta, 0, popupHeight);
+      const velocityOffset = Number.isFinite(resolvedDirectionalVelocity) && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? clamp(resolvedDirectionalVelocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
+      const targetOffset = snapToSequentialPoints ? dragTargetOffset : clamp(dragTargetOffset + velocityOffset, 0, popupHeight);
+      const snapPointEventDetails = createChangeEventDetails(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(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 = createChangeEventDetails(swipe, event);
+      store.setOpen(false, dismissEventDetails);
+      if (dismissEventDetails.isCanceled) {
+        const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
+        if (pendingSnapPoint !== undefined) {
+          setActiveSnapPoint?.(pendingSnapPoint, createChangeEventDetails(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, createChangeEventDetails(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$1.getPointerProps();
+  const swipeTouchProps = swipe$1.getTouchProps();
+  const {
+    moveNative: moveSwipeNative,
+    reset: resetSwipe
+  } = swipe$1;
+  resetSwipeRef.current = resetSwipe;
+  React.useEffect(() => {
+    const rootElement = viewportElement ?? popupElementState;
+    if (!rootElement) {
+      return undefined;
+    }
+    const resolvedRootElement = rootElement;
+    const doc = ownerDocument(resolvedRootElement);
+    const win = 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 addEventListener(doc, 'touchmove', handleNativeTouchMove, {
+      passive: false,
+      capture: true
+    });
+  }, [mounted, nestedDrawerOpen, open, popupElementState, isVerticalScrollAxis, scrollAxis, swipeDirection, moveSwipeNative, viewportElement, virtualKeyboard]);
+  React.useEffect(() => {
+    if (!snapPointRange || swipe$1.swiping) {
+      return;
+    }
+    const resolvedProgress = !open || nested ? 0 : snapPointProgress ?? 0;
+    applySwipeProgress({
+      resolvedProgress,
+      shouldTrackProgress: true,
+      notifyParent: false
+    });
+  }, [applySwipeProgress, frontmostHeight, nested, notifyParentSwipeProgressChange, open, snapPointProgress, snapPointRange, swipe$1.swiping, store, visualStateStore]);
+  React.useEffect(() => {
+    if (!notifyParentSwipeProgressChange) {
+      return undefined;
+    }
+    if (!open) {
+      notifyParentSwipeProgressChange(0);
+    }
+    return () => {
+      notifyParentSwipeProgressChange(0);
+    };
+  }, [notifyParentSwipeProgressChange, open]);
+  React.useEffect(() => {
+    if (open) {
+      resetSwipe();
+      clearSwipeRelease();
+    }
+  }, [clearSwipeRelease, open, resetSwipe]);
+  React.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.useMemo(() => ({
+    swiping: swipe$1.swiping,
+    getDragStyles: swipe$1.getDragStyles,
+    swipeStrength: swipeRelease ?? null,
+    setSwipeDismissed
+  }), [setSwipeDismissed, swipe$1.getDragStyles, swipe$1.swiping, swipeRelease]);
+  function resetTouchTrackingState() {
+    ignoreTouchSwipeRef.current = false;
+    touchScrollStateRef.current = null;
+    lastPointerTypeRef.current = '';
+    ignoreNextTouchStartFromPenRef.current = false;
+  }
+  return /*#__PURE__*/jsx(DialogViewport, {
+    ref: forwardedRef,
+    className: className,
+    style: style,
+    render: render,
+    ...mergeProps(elementProps, {
+      onPointerDown(event) {
+        lastPointerTypeRef.current = event.pointerType;
+        ignoreNextTouchStartFromPenRef.current = event.pointerType === 'pen';
+        if (!open || !mounted || nestedDrawerOpen) {
+          return;
+        }
+        const doc = 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 = ownerDocument(event.currentTarget);
+        const elementAtPoint = getElementAtPoint(doc, touch.clientX, touch.clientY);
+        const rootElement = viewportElement ?? popupElementState;
+        const eventTarget = getTarget(event.nativeEvent);
+        const target = isElement(eventTarget) ? eventTarget : null;
+        if (rootElement && target && !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__*/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(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 (!isElement(target)) {
+    return false;
+  }
+  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA';
+}
+function hasExpandedSelectionWithinTarget(selection, target) {
+  const anchorElement = isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+  const focusElement = isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+  return selection.containsNode(target, true) || contains(target, anchorElement) || contains(target, focusElement);
+}
+function shouldIgnoreSwipeForTextSelection(doc, rootElement) {
+  const activeEl = activeElement(doc);
+  const activeElementWithinRoot = Boolean(activeEl && 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(getTarget(event), win);
+}
+function isReactTouchEventOnRangeInput(event) {
+  return isEventOnRangeInput(event.nativeEvent, 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.createContext(undefined);
 if (process.env.NODE_ENV !== "production") ScrollAreaRootContext.displayName = "ScrollAreaRootContext";
@@ -2200,4 +4305,4 @@ function mergeHiddenState(prevState, nextState) {
   return nextState;
 }
 
-export { ScrollAreaRootCssVars as A, scrollAreaStateAttributesMapping as B, useScrollAreaViewportContext as C, DrawerTrigger as D, ScrollAreaRoot as S, DrawerRoot as a, DrawerPortal as b, DrawerBackdrop as c, DrawerPopup as d, ScrollAreaViewport as e, DrawerContent as f, DialogRoot as g, DialogTrigger as h, DialogPortal as i, useDialogPortalContext as j, DialogStore as k, createInitialPopupStoreState as l, useDrawerProviderContext as m, DrawerBackdropCssVars as n, DrawerPopupCssVars as o, popupStoreSelectors as p, DrawerProviderContext as q, useDrawerRootContext as r, DrawerPopupDataAttributes as s, useDrawerSnapPoints as t, useDialogRootContext as u, getSnapPointSwipeMovement as v, DrawerViewportContext as w, DRAWER_CONTENT_ATTRIBUTE as x, useScrollAreaRootContext as y, getOffset as z };
+export { getElementAtPoint as A, findScrollableTouchTarget as B, useScrollAreaRootContext as C, DrawerTrigger as D, getOffset as E, ScrollAreaRootCssVars as F, scrollAreaStateAttributesMapping as G, useScrollAreaViewportContext as H, ScrollAreaRoot as S, DrawerRoot as a, DrawerPortal as b, DrawerBackdrop as c, DrawerViewport as d, DrawerPopup as e, ScrollAreaViewport as f, DrawerContent as g, useDialogPortalContext as h, DialogStore as i, DialogRoot as j, DialogTrigger as k, DialogPortal as l, DialogViewport as m, createInitialPopupStoreState as n, useDrawerProviderContext as o, popupStoreSelectors as p, DrawerBackdropCssVars as q, DrawerPopupCssVars as r, DrawerProviderContext as s, useDrawerRootContext as t, useDialogRootContext as u, useSwipeDismiss as v, getDisplacement as w, DrawerPopupDataAttributes as x, getElementTransform as y, DrawerVirtualKeyboardContext as z };