@wix/site-ui 1.185.0 → 1.186.0

package/dist/1763.js

@@ -0,0 +1,836 @@
+import { getWindow, getComputedStyle, isHTMLElement } from "./3829.js";
+import { useStableCallback } from "./7541.js";
+import { clamp } from "./3296.js";
+import { ownerDocument } from "./9829.js";
+import { getTarget, contains } from "./4549.js";
+import * as __rspack_external_react from "react";
+function isScrollable(element, axis) {
+    const style = 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
+    };
+}
+export { findScrollableTouchTarget, getDisplacement, getElementAtPoint, getElementTransform, useSwipeDismiss };