@wix/site-ui 1.185.0 → 1.186.0

package/dist/Drawer/index.js

@@ -1,26 +1,29 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import clsx from "clsx";
-import { BASE_UI_SWIPE_IGNORE_SELECTOR, popupStateMapping, popupStateMapping_CommonPopupDataAttributes } from "../4388.js";
-import { transitionStatusMapping, stateAttributesMapping_TransitionStatusDataAttributes, useOpenChangeComplete } from "../880.js";
+import { popupStateMapping, popupStateMapping_CommonPopupDataAttributes } from "../6917.js";
+import { transitionStatusMapping, stateAttributesMapping_TransitionStatusDataAttributes, useOpenChangeComplete } from "../9369.js";
 import { IsDrawerContext, DialogClose_DialogClose, useDialogPortalContext, useDialogRootContext, DialogTitle_DialogTitle, DialogTrigger_DialogTrigger, DialogDescription_DialogDescription, DialogHandle, createDialogHandle, DialogViewport_DialogViewport, DialogPortal_DialogPortal } from "../6270.js";
 import { EMPTY_OBJECT, mergeProps, useRenderElement, esm_formatErrorMessage } from "../8272.js";
 import { useIsoLayoutEffect, SafeReact } from "../6499.js";
 import { clamp } from "../3296.js";
 import { useStableCallback } from "../7541.js";
 import { ownerDocument } from "../9829.js";
-import { error as error_error } from "../4026.js";
+import { error } from "../4026.js";
 import { FOCUSABLE_POPUP_PROPS, useTriggerRegistration } from "../8106.js";
 import { COMPOSITE_KEYS } from "../1500.js";
 import { FloatingFocusManager } from "../3485.js";
-import { getWindow, getComputedStyle as floating_ui_utils_dom_getComputedStyle, isElement, isHTMLElement } from "../3829.js";
-import { getTarget, contains, activeElement } from "../4549.js";
 import { useTimeout } from "../42.js";
-import { useBaseUiId, useId } from "../6046.js";
+import { useBaseUiId } from "../6046.js";
+import { getElementTransform, useSwipeDismiss, findScrollableTouchTarget, getDisplacement, getElementAtPoint } from "../1763.js";
 import { createChangeEventDetails } from "../4768.js";
 import { useAnimationFrame } from "../8996.js";
+import { getWindow, isElement } from "../3829.js";
+import { getTarget, contains, activeElement } from "../4549.js";
 import { addEventListener } from "../4723.js";
+import { BASE_UI_SWIPE_IGNORE_SELECTOR } from "../487.js";
 import { useControlled } from "../8527.js";
 import { DialogRoot } from "../3020.js";
+import { useId } from "../2205.js";
 import { isAndroid } from "../8971.js";
 import { closeWatcher as reason_parts_closeWatcher } from "../2418.js";
 import * as __rspack_external_react from "react";
@@ -426,7 +429,7 @@ const DrawerPopup_DrawerPopup = /*#__PURE__*/ __rspack_external_react.forwardRef
         if (swipe) return;
         const ownerStackMessage = SafeReact.captureOwnerStack?.() || '';
         const message = "<Drawer.Popup> expected to be rendered within <Drawer.Viewport>. Omitting the viewport disables drawer swipe handling and touch scroll locking. Wrap <Drawer.Popup> in <Drawer.Viewport>.";
-        error_error(`${message}${ownerStackMessage}`);
+        error(`${message}${ownerStackMessage}`);
     }, [
         swipe
     ]);
@@ -606,835 +609,6 @@ const DrawerPopup_DrawerPopup = /*#__PURE__*/ __rspack_external_react.forwardRef
     });
 });
 if ("production" !== process.env.NODE_ENV) DrawerPopup_DrawerPopup.displayName = "DrawerPopup";
-function isScrollable(element, axis) {
-    const style = floating_ui_utils_dom_getComputedStyle(element);
-    if ('vertical' === axis) {
-        const overflowY = style.overflowY;
-        return ('auto' === overflowY || 'scroll' === overflowY) && element.scrollHeight > element.clientHeight;
-    }
-    const overflowX = style.overflowX;
-    return ('auto' === overflowX || 'scroll' === overflowX) && element.scrollWidth > element.clientWidth;
-}
-function hasScrollableAncestor(target, root, axes) {
-    let node = target;
-    while(node && node !== root){
-        for (const axis of axes)if (isScrollable(node, axis)) return true;
-        node = node.parentElement;
-    }
-    return false;
-}
-function findScrollableTouchTarget(target, root, axis = 'vertical') {
-    let node = isHTMLElement(target) ? target : null;
-    while(node && node !== root){
-        if (isScrollable(node, axis)) return node;
-        node = node.parentElement;
-    }
-    return isScrollable(root, axis) ? root : null;
-}
-function getElementAtPoint(doc, x, y) {
-    return 'function' == typeof doc?.elementFromPoint ? 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 && 'none' !== transform) {
-        const matrix = transform.match(/matrix(?:3d)?\(([^)]+)\)/);
-        if (matrix) {
-            const values = matrix[1].split(', ').map(parseFloat);
-            if (6 === values.length) {
-                translateX = values[4];
-                translateY = values[5];
-                scale = Math.sqrt(values[0] * values[0] + values[1] * values[1]);
-            } else if (16 === values.length) {
-                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 hasPrimaryMouseButton(buttons) {
-    return buttons % 2 === 1;
-}
-function safelyChangePointerCapture(element, pointerId, method) {
-    const pointerCaptureMethod = element[method];
-    if ('function' != typeof pointerCaptureMethod) return;
-    try {
-        pointerCaptureMethod.call(element, pointerId);
-    } catch (error) {
-        if (error && 'object' == typeof error && 'name' in error && 'NotFoundError' === error.name) 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 = 1 === directions.length ? directions[0] : void 0;
-    const swipeThresholdDefault = Math.max(0, 'number' == typeof swipeThresholdProp ? 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 = __rspack_external_react.useMemo(()=>{
-        const axes = [];
-        if (hasVertical) axes.push('vertical');
-        if (hasHorizontal) axes.push('horizontal');
-        return axes;
-    }, [
-        hasHorizontal,
-        hasVertical
-    ]);
-    const [currentSwipeDirection, setCurrentSwipeDirection] = __rspack_external_react.useState(void 0);
-    const [isSwiping, setIsSwiping] = __rspack_external_react.useState(false);
-    const [isRealSwipe, setIsRealSwipe] = __rspack_external_react.useState(false);
-    const [dragDismissed, setDragDismissed] = __rspack_external_react.useState(false);
-    const [dragOffset, setDragOffset] = __rspack_external_react.useState({
-        x: 0,
-        y: 0
-    });
-    const [initialTransform, setInitialTransform] = __rspack_external_react.useState({
-        x: 0,
-        y: 0,
-        scale: 1
-    });
-    const [lockedDirection, setLockedDirection] = __rspack_external_react.useState(null);
-    const dragStartPosRef = __rspack_external_react.useRef({
-        x: 0,
-        y: 0
-    });
-    const dragOffsetRef = __rspack_external_react.useRef({
-        x: 0,
-        y: 0
-    });
-    const lastMovePosRef = __rspack_external_react.useRef(null);
-    const initialTransformRef = __rspack_external_react.useRef({
-        x: 0,
-        y: 0,
-        scale: 1
-    });
-    const intendedSwipeDirectionRef = __rspack_external_react.useRef(void 0);
-    const maxSwipeDisplacementRef = __rspack_external_react.useRef(0);
-    const cancelledSwipeRef = __rspack_external_react.useRef(false);
-    const swipeCancelBaselineRef = __rspack_external_react.useRef({
-        x: 0,
-        y: 0
-    });
-    const isFirstPointerMoveRef = __rspack_external_react.useRef(false);
-    const pendingSwipeRef = __rspack_external_react.useRef(false);
-    const pendingSwipeStartPosRef = __rspack_external_react.useRef(null);
-    const swipeFromScrollableRef = __rspack_external_react.useRef(false);
-    const sawPrimaryButtonsOnMoveRef = __rspack_external_react.useRef(false);
-    const elementSizeRef = __rspack_external_react.useRef({
-        width: 0,
-        height: 0
-    });
-    const swipeProgressRef = __rspack_external_react.useRef(0);
-    const swipeThresholdRef = __rspack_external_react.useRef(swipeThresholdDefault);
-    const swipeStartTimeRef = __rspack_external_react.useRef(null);
-    const lastDragSampleRef = __rspack_external_react.useRef(null);
-    const lastDragVelocityRef = __rspack_external_react.useRef({
-        x: 0,
-        y: 0
-    });
-    const lastProgressDetailsRef = __rspack_external_react.useRef(null);
-    const isSwipingRef = __rspack_external_react.useRef(false);
-    const setSwiping = useStableCallback((nextSwiping)=>{
-        if (isSwipingRef.current === nextSwiping) return;
-        isSwipingRef.current = nextSwiping;
-        setIsSwiping(nextSwiping);
-        onSwipingChange?.(nextSwiping);
-    });
-    function resolveSwipeThreshold(direction) {
-        if (!direction) return;
-        if ('function' != typeof swipeThresholdProp) {
-            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);
-    });
-    function recordDragSample(offset, timeStamp) {
-        if (null === timeStamp) 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 = __rspack_external_react.useCallback(()=>{
-        setCurrentSwipeDirection(void 0);
-        setSwiping(false);
-        setIsRealSwipe(false);
-        setDragDismissed(false);
-        setDragOffset({
-            x: 0,
-            y: 0
-        });
-        setInitialTransform({
-            x: 0,
-            y: 0,
-            scale: 1
-        });
-        setLockedDirection(null);
-        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 = void 0;
-        maxSwipeDisplacementRef.current = 0;
-        cancelledSwipeRef.current = false;
-        swipeCancelBaselineRef.current = {
-            x: 0,
-            y: 0
-        };
-        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;
-    }, [
-        setSwiping,
-        swipeThresholdDefault,
-        updateSwipeProgress
-    ]);
-    __rspack_external_react.useEffect(()=>{
-        if ('function' != typeof swipeThresholdProp) 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 'touch' === event.pointerType;
-    }
-    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 = void 0;
-        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
-            };
-            setInitialTransform(transform);
-            setDragOffset({
-                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);
-        setIsRealSwipe(false);
-        setLockedDirection(null);
-        isFirstPointerMoveRef.current = true;
-        updateSwipeProgress(0);
-        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);
-        setIsRealSwipe(false);
-        setLockedDirection(null);
-        const resolvedInitialTransform = trackDrag ? initialTransform : initialTransformRef.current;
-        dragOffsetRef.current = {
-            x: resolvedInitialTransform.x,
-            y: resolvedInitialTransform.y
-        };
-        setDragOffset({
-            x: resolvedInitialTransform.x,
-            y: resolvedInitialTransform.y
-        });
-        setCurrentSwipeDirection(void 0);
-        sawPrimaryButtonsOnMoveRef.current = false;
-        const element = elementRef.current;
-        if (element) safelyChangePointerCapture(element, event.pointerId, 'releasePointerCapture');
-        updateSwipeProgress(0, {
-            deltaX: 0,
-            deltaY: 0,
-            direction: void 0
-        });
-        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 && 0 !== deltaY && (!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 && 0 !== deltaX && (!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) && 0 !== event.button) 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)) event.preventDefault();
-        if (isFirstPointerMoveRef.current) {
-            dragStartPosRef.current = position;
-            const moveTime = getValidTimeStamp(event.timeStamp);
-            if (null !== moveTime) 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;
-        if (!isRealSwipe) {
-            const movementDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-            if (movementDistance >= MIN_DRAG_THRESHOLD) {
-                setIsRealSwipe(true);
-                if (null === lockedDirection) {
-                    if (hasHorizontal && hasVertical) {
-                        const absX = Math.abs(deltaX);
-                        const absY = Math.abs(deltaY);
-                        setLockedDirection(absX > absY ? 'horizontal' : 'vertical');
-                    }
-                }
-            }
-        }
-        let candidate;
-        if (intendedSwipeDirectionRef.current) {
-            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) cancelledSwipeRef.current = true;
-        } else {
-            if ('vertical' === lockedDirection) {
-                if (deltaY > 0) candidate = 'down';
-                else if (deltaY < 0) candidate = 'up';
-            } else if ('horizontal' === lockedDirection) {
-                if (deltaX > 0) candidate = 'right';
-                else if (deltaX < 0) candidate = 'left';
-            } else candidate = Math.abs(deltaX) >= Math.abs(deltaY) ? deltaX > 0 ? 'right' : 'left' : deltaY > 0 ? 'down' : 'up';
-            if (candidate) {
-                const isAllowed = 'left' === candidate && allowLeft || 'right' === candidate && allowRight || 'up' === candidate && allowUp || 'down' === candidate && allowDown;
-                if (isAllowed) {
-                    intendedSwipeDirectionRef.current = candidate;
-                    maxSwipeDisplacementRef.current = getDisplacement(candidate, deltaX, deltaY);
-                    setCurrentSwipeDirection(candidate);
-                    resolveSwipeThreshold(candidate);
-                }
-            }
-        }
-        const dampedDelta = applyDirectionalDamping(deltaX, deltaY);
-        let newOffsetX = initialTransformRef.current.x;
-        let newOffsetY = initialTransformRef.current.y;
-        if ('horizontal' === lockedDirection) {
-            if (hasHorizontal) newOffsetX += dampedDelta.x;
-        } else if ('vertical' === lockedDirection) {
-            if (hasVertical) newOffsetY += dampedDelta.y;
-        } else {
-            if (hasHorizontal) newOffsetX += dampedDelta.x;
-            if (hasVertical) newOffsetY += dampedDelta.y;
-        }
-        dragOffsetRef.current = {
-            x: newOffsetX,
-            y: newOffsetY
-        };
-        if (trackDrag) setDragOffset({
-            x: newOffsetX,
-            y: newOffsetY
-        });
-        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) return void updateSwipeProgress(0, {
-            deltaX: dragDeltaX,
-            deltaY: dragDeltaY,
-            direction: swipeDirectionDetails
-        });
-        const size = 'left' === progressDirection || 'right' === progressDirection ? elementSizeRef.current.width : elementSizeRef.current.height;
-        const scale = initialTransformRef.current.scale || 1;
-        if (size <= 0 || scale <= 0) return void updateSwipeProgress(0, {
-            deltaX: dragDeltaX,
-            deltaY: dragDeltaY,
-            direction: swipeDirectionDetails
-        });
-        const progressDisplacement = getDisplacement(progressDirection, newOffsetX - initialTransformRef.current.x, newOffsetY - initialTransformRef.current.y);
-        if (progressDisplacement <= 0) return void updateSwipeProgress(0, {
-            deltaX: dragDeltaX,
-            deltaY: dragDeltaY,
-            direction: swipeDirectionDetails
-        });
-        updateSwipeProgress(progressDisplacement / (size * scale), {
-            deltaX: dragDeltaX,
-            deltaY: dragDeltaY,
-            direction: swipeDirectionDetails
-        });
-    }
-    const handleMove = useStableCallback((event)=>{
-        const currentPos = getPrimaryPointerPosition(event);
-        if (!currentPos) return;
-        if (!('touches' in event)) {
-            const hasPrimaryButton = hasPrimaryMouseButton(event.buttons);
-            if (hasPrimaryButton) sawPrimaryButtonsOnMoveRef.current = true;
-            const lostPrimaryButtonDuringSwipe = 0 === event.buttons && sawPrimaryButtonsOnMoveRef.current;
-            if (0 !== event.buttons && !hasPrimaryButton || lostPrimaryButtonDuringSwipe) return void cancelSwipeInteraction(event);
-        }
-        if (!isSwiping && pendingSwipeRef.current) {
-            if (!isTouchLikeEvent(event) && (event.defaultPrevented || event.nativeEvent.defaultPrevented)) return void resetPendingSwipeState();
-            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 (false === canSwipeFromEdge) return;
-                            if (true === canSwipeFromEdge) ignoreScrollableOnStart = true;
-                        }
-                    }
-                }
-                const started = startSwipeAtPosition(event, currentPos, {
-                    ignoreScrollableTarget: ignoreScrollableOnStart,
-                    ignoreScrollableAncestors: ignoreScrollableOnStart
-                });
-                if (started) if (pendingStartPos && ignoreScrollableOnStart) {
-                    clearPendingSwipeStartState();
-                    dragStartPosRef.current = pendingStartPos;
-                    swipeCancelBaselineRef.current = pendingStartPos;
-                    lastMovePosRef.current = pendingStartPos;
-                    isFirstPointerMoveRef.current = false;
-                } else {
-                    clearPendingSwipeStartState();
-                    swipeFromScrollableRef.current = false;
-                }
-            }
-        }
-        const previousPos = lastMovePosRef.current;
-        const movement = null === previousPos ? {
-            x: 0,
-            y: 0
-        } : {
-            x: currentPos.x - previousPos.x,
-            y: currentPos.y - previousPos.y
-        };
-        lastMovePosRef.current = currentPos;
-        handleMoveCore(event, currentPos, movement);
-    });
-    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: currentSwipeDirection ?? intendedSwipeDirectionRef.current
-        };
-        if (!isSwipingRef.current) {
-            resetPendingSwipeState();
-            updateSwipeProgress(0, progressDetails);
-            return;
-        }
-        setSwiping(false);
-        setIsRealSwipe(false);
-        setLockedDirection(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 = null !== startTime && null !== endTime && 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 && null !== endTime && 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 (0 !== sampleVelocityX) releaseVelocityX = sampleVelocityX;
-                if (0 !== sampleVelocityY) releaseVelocityY = sampleVelocityY;
-            } else {
-                releaseVelocityX = 0;
-                releaseVelocityY = 0;
-            }
-        }
-        const releaseDecision = onRelease?.({
-            event: event.nativeEvent,
-            direction: currentSwipeDirection ?? intendedSwipeDirectionRef.current,
-            deltaX,
-            deltaY,
-            velocityX,
-            velocityY,
-            releaseVelocityX,
-            releaseVelocityY
-        });
-        const hasReleaseDecision = 'boolean' == typeof releaseDecision;
-        if (cancelledSwipeRef.current && !hasReleaseDecision) {
-            dragOffsetRef.current = {
-                x: resolvedInitialTransform.x,
-                y: resolvedInitialTransform.y
-            };
-            setDragOffset({
-                x: resolvedInitialTransform.x,
-                y: resolvedInitialTransform.y
-            });
-            setCurrentSwipeDirection(void 0);
-            updateSwipeProgress(0, progressDetails);
-            return;
-        }
-        let shouldClose = false;
-        let dismissDirection;
-        if (hasReleaseDecision) {
-            shouldClose = releaseDecision;
-            dismissDirection = currentSwipeDirection ?? 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;
-                default:
-                    break;
-            }
-            if (shouldClose) break;
-        }
-        if (shouldClose && dismissDirection) {
-            setCurrentSwipeDirection(dismissDirection);
-            setDragDismissed(true);
-            onDismiss?.(event.nativeEvent, {
-                direction: dismissDirection
-            });
-        } else {
-            dragOffsetRef.current = {
-                x: resolvedInitialTransform.x,
-                y: resolvedInitialTransform.y
-            };
-            setDragOffset({
-                x: resolvedInitialTransform.x,
-                y: resolvedInitialTransform.y
-            });
-            setCurrentSwipeDirection(void 0);
-            updateSwipeProgress(0, progressDetails);
-        }
-    });
-    const getDragStyles = __rspack_external_react.useCallback(()=>{
-        const resolvedDragOffset = trackDrag ? dragOffset : dragOffsetRef.current;
-        const resolvedInitialTransform = trackDrag ? initialTransform : initialTransformRef.current;
-        if (!isSwiping && resolvedDragOffset.x === resolvedInitialTransform.x && resolvedDragOffset.y === resolvedInitialTransform.y && !dragDismissed) return {
-            [movementCssVars.x]: '0px',
-            [movementCssVars.y]: '0px'
-        };
-        const deltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
-        const deltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
-        return {
-            transition: isSwiping ? 'none' : void 0,
-            transform: isSwiping ? `translateX(${resolvedDragOffset.x}px) translateY(${resolvedDragOffset.y}px) scale(${resolvedInitialTransform.scale})` : void 0,
-            [movementCssVars.x]: `${deltaX}px`,
-            [movementCssVars.y]: `${deltaY}px`
-        };
-    }, [
-        dragDismissed,
-        dragOffset,
-        initialTransform,
-        isSwiping,
-        movementCssVars,
-        trackDrag
-    ]);
-    const getPointerProps = __rspack_external_react.useCallback(()=>{
-        if (!enabled) return {};
-        return {
-            onPointerDown: handleStart,
-            onPointerMove: handleMove,
-            onPointerUp: handleEnd,
-            onPointerCancel: handleEnd
-        };
-    }, [
-        enabled,
-        handleEnd,
-        handleMove,
-        handleStart
-    ]);
-    const getTouchProps = __rspack_external_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,
-        getDragStyles,
-        reset
-    };
-}
 let DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes = function(DrawerSwipeAreaDataAttributes) {
     DrawerSwipeAreaDataAttributes[DrawerSwipeAreaDataAttributes["open"] = popupStateMapping_CommonPopupDataAttributes.open] = "open";
     DrawerSwipeAreaDataAttributes[DrawerSwipeAreaDataAttributes["closed"] = popupStateMapping_CommonPopupDataAttributes.closed] = "closed";