solid-baseui 0.1.0-alpha.0

package/dist/lib/server/constants-9H__9xbS.js

@@ -0,0 +1,706 @@
+import { c as isHTMLElement, m as ownerWindow, n as contains, p as ownerDocument, r as getEventTarget } from "./dom-Crg_2R-j.js";
+import { r as hasScrollableAncestor, t as findScrollableTouchTarget } from "./scrollable-CjsSxbGr.js";
+import { createSignal } from "solid-js";
+//#region src/internals/clamp.ts
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(value, max));
+}
+//#endregion
+//#region src/internals/overlay/getElementAtPoint.ts
+/**
+* `Document.elementFromPoint` retargets shadow content to the shadow host, which then fails
+* `contains()` checks against a popup inside that shadow root, so callers pass `getRootNode()`
+* (a document or a shadow root) rather than `ownerDocument()`.
+*/
+function getElementAtPoint(root, x, y) {
+	return typeof root?.elementFromPoint === "function" ? root.elementFromPoint(x, y) : null;
+}
+//#endregion
+//#region src/internals/overlay/createSwipeDismiss.ts
+var DEFAULT_SWIPE_THRESHOLD = 40;
+var REVERSE_CANCEL_THRESHOLD = 10;
+var MIN_DRAG_THRESHOLD = 1;
+var MIN_VELOCITY_DURATION_MS = 50;
+var MIN_RELEASE_VELOCITY_DURATION_MS = 16;
+var MAX_RELEASE_VELOCITY_AGE_MS = 80;
+var 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 transform = ownerWindow(element).getComputedStyle(element).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(Number.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 isTouchEvent(event) {
+	return "touches" in event;
+}
+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 createSwipeDismiss(options) {
+	const ignoreSelector = DEFAULT_IGNORE_SELECTOR;
+	const trackDrag = options.trackDrag ?? true;
+	const ignoreSelectorWhenTouch = options.ignoreSelectorWhenTouch ?? true;
+	const ignoreScrollableAncestors = options.ignoreScrollableAncestors ?? false;
+	const primaryDirection = () => {
+		const directions = options.directions();
+		return directions.length === 1 ? directions[0] : void 0;
+	};
+	const swipeThresholdDefault = () => Math.max(0, typeof options.swipeThreshold === "number" ? options.swipeThreshold : DEFAULT_SWIPE_THRESHOLD);
+	const allowLeft = () => options.directions().includes("left");
+	const allowRight = () => options.directions().includes("right");
+	const allowUp = () => options.directions().includes("up");
+	const allowDown = () => options.directions().includes("down");
+	const hasHorizontal = () => allowLeft() || allowRight();
+	const hasVertical = () => allowUp() || allowDown();
+	const scrollAxes = () => {
+		const axes = [];
+		if (hasVertical()) axes.push("vertical");
+		if (hasHorizontal()) axes.push("horizontal");
+		return axes;
+	};
+	const [currentSwipeDirection, setCurrentSwipeDirection] = createSignal(void 0, { ownedWrite: true });
+	const [isSwiping, setIsSwiping] = createSignal(false, { ownedWrite: true });
+	const [dragDismissed, setDragDismissed] = createSignal(false, { ownedWrite: true });
+	let dragStartPos = {
+		x: 0,
+		y: 0
+	};
+	let dragOffset = {
+		x: 0,
+		y: 0
+	};
+	let lastMovePos = null;
+	let initialTransform = {
+		x: 0,
+		y: 0,
+		scale: 1
+	};
+	let intendedSwipeDirection;
+	let maxSwipeDisplacement = 0;
+	let cancelledSwipe = false;
+	let swipeCancelBaseline = {
+		x: 0,
+		y: 0
+	};
+	let lockedDirection = null;
+	let isFirstPointerMove = false;
+	let pendingSwipe = false;
+	let pendingSwipeStartPos = null;
+	let swipeFromScrollable = false;
+	let sawPrimaryButtonsOnMove = false;
+	let elementSize = {
+		width: 0,
+		height: 0
+	};
+	let swipeProgress = 0;
+	let swipeThreshold = swipeThresholdDefault();
+	let swipeThresholdFunction = null;
+	let swipeStartTime = null;
+	let lastDragSample = null;
+	let lastDragVelocity = {
+		x: 0,
+		y: 0
+	};
+	let lastProgressDetails = null;
+	let swiping = false;
+	let dragStyleSnapshot = null;
+	function setSwiping(nextSwiping) {
+		if (swiping === nextSwiping) return;
+		swiping = nextSwiping;
+		setIsSwiping(nextSwiping);
+		options.onSwipingChange?.(nextSwiping);
+	}
+	function resolveSwipeThreshold(direction) {
+		if (!direction) return;
+		const element = options.element();
+		if (!element || !swipeThresholdFunction) return;
+		swipeThreshold = Math.max(0, swipeThresholdFunction({
+			element,
+			direction
+		}));
+	}
+	function updateSwipeProgress(progress, details) {
+		const nextProgress = Number.isFinite(progress) ? clamp(progress, 0, 1) : 0;
+		const progressChanged = nextProgress !== swipeProgress;
+		let detailsChanged = false;
+		if (details) detailsChanged = !lastProgressDetails || lastProgressDetails.deltaX !== details.deltaX || lastProgressDetails.deltaY !== details.deltaY || lastProgressDetails.direction !== details.direction;
+		if (!progressChanged && !detailsChanged) return;
+		swipeProgress = nextProgress;
+		if (details) lastProgressDetails = details;
+		else if (progressChanged) lastProgressDetails = null;
+		options.onProgress?.(nextProgress, details);
+	}
+	function syncDragStyles(nextSwiping) {
+		const element = options.element();
+		if (!trackDrag || !element) {
+			if (!nextSwiping) dragStyleSnapshot = null;
+			return;
+		}
+		const style = element.style;
+		if (nextSwiping) {
+			dragStyleSnapshot ??= [style.transition, style.transform];
+			style.transition = "none";
+		} else if (dragStyleSnapshot) {
+			[style.transition, style.transform] = dragStyleSnapshot;
+			dragStyleSnapshot = null;
+		}
+		const deltaX = dragOffset.x - initialTransform.x;
+		const deltaY = dragOffset.y - initialTransform.y;
+		if (nextSwiping) style.transform = getDragTransform(dragOffset, initialTransform.scale);
+		style.setProperty(options.movementCssVars.x, `${deltaX}px`);
+		style.setProperty(options.movementCssVars.y, `${deltaY}px`);
+	}
+	function recordDragSample(offset, timeStamp) {
+		if (timeStamp === null) return;
+		if (lastDragSample && timeStamp > lastDragSample.time) {
+			const durationMs = Math.max(timeStamp - lastDragSample.time, MIN_RELEASE_VELOCITY_DURATION_MS);
+			lastDragVelocity = {
+				x: (offset.x - lastDragSample.x) / durationMs,
+				y: (offset.y - lastDragSample.y) / durationMs
+			};
+		}
+		lastDragSample = {
+			x: offset.x,
+			y: offset.y,
+			time: timeStamp
+		};
+	}
+	function reset() {
+		setCurrentSwipeDirection(void 0);
+		setSwiping(false);
+		setDragDismissed(false);
+		updateSwipeProgress(0);
+		swipeThreshold = swipeThresholdDefault();
+		swipeThresholdFunction = null;
+		dragStartPos = {
+			x: 0,
+			y: 0
+		};
+		dragOffset = {
+			x: 0,
+			y: 0
+		};
+		initialTransform = {
+			x: 0,
+			y: 0,
+			scale: 1
+		};
+		intendedSwipeDirection = void 0;
+		maxSwipeDisplacement = 0;
+		cancelledSwipe = false;
+		swipeCancelBaseline = {
+			x: 0,
+			y: 0
+		};
+		lockedDirection = null;
+		isFirstPointerMove = false;
+		lastMovePos = null;
+		pendingSwipe = false;
+		pendingSwipeStartPos = null;
+		swipeFromScrollable = false;
+		sawPrimaryButtonsOnMove = false;
+		elementSize = {
+			width: 0,
+			height: 0
+		};
+		swipeStartTime = null;
+		lastDragSample = null;
+		lastDragVelocity = {
+			x: 0,
+			y: 0
+		};
+		lastProgressDetails = null;
+		syncDragStyles(false);
+	}
+	function getPrimaryPointerPosition(event) {
+		if (isTouchEvent(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) {
+		return isTouchEvent(event) || event.pointerType === "touch";
+	}
+	function getTargetAtPoint(position, nativeEvent) {
+		const root = options.element()?.getRootNode();
+		const target = getElementAtPoint(root, position.x, position.y) ?? getEventTarget(nativeEvent);
+		return isHTMLElement(target) ? target : null;
+	}
+	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) {
+		swipeFromScrollable = false;
+		const touchLike = isTouchLikeEvent(event);
+		const target = getTargetAtPoint(position, event);
+		const body = ownerDocument(options.element()).body;
+		const scrollableTarget = touchLike && body ? findGestureScrollableTouchTarget(target, body) : null;
+		const ignoreScrollableTarget = startOptions?.ignoreScrollableTarget ?? false;
+		if (scrollableTarget && !ignoreScrollableTarget) return false;
+		swipeFromScrollable = Boolean(scrollableTarget && ignoreScrollableTarget);
+		if ((target ? target.closest(ignoreSelector) : false) && (!touchLike || ignoreSelectorWhenTouch)) return false;
+		const element = options.element();
+		const axes = scrollAxes();
+		if (ignoreScrollableAncestors && element && target && axes.length > 0) {
+			if (!(startOptions?.ignoreScrollableAncestors ?? false) && hasScrollableAncestor(target, element, axes)) return false;
+		}
+		cancelledSwipe = false;
+		intendedSwipeDirection = void 0;
+		maxSwipeDisplacement = 0;
+		dragStartPos = position;
+		swipeStartTime = getValidTimeStamp(event.timeStamp);
+		swipeCancelBaseline = position;
+		lastMovePos = position;
+		swipeThreshold = swipeThresholdDefault();
+		swipeThresholdFunction = typeof options.swipeThreshold === "function" ? options.swipeThreshold : null;
+		if (element) {
+			elementSize = {
+				width: element.offsetWidth,
+				height: element.offsetHeight
+			};
+			resolveSwipeThreshold(primaryDirection());
+			const transform = getElementTransform(element);
+			initialTransform = transform;
+			dragOffset = {
+				x: transform.x,
+				y: transform.y
+			};
+			recordDragSample({
+				x: transform.x,
+				y: transform.y
+			}, swipeStartTime);
+			if (!isTouchEvent(event)) safelyChangePointerCapture(element, event.pointerId, "setPointerCapture");
+		}
+		options.onSwipeStart?.(event);
+		setSwiping(true);
+		lockedDirection = null;
+		isFirstPointerMove = true;
+		updateSwipeProgress(0);
+		syncDragStyles(true);
+		return true;
+	}
+	function clearPendingSwipeStartState() {
+		pendingSwipe = false;
+		pendingSwipeStartPos = null;
+	}
+	function resetPendingSwipeState() {
+		clearPendingSwipeStartState();
+		swipeFromScrollable = false;
+		lastMovePos = null;
+	}
+	function cancelSwipeInteraction(event) {
+		resetPendingSwipeState();
+		if (!swiping) return;
+		setSwiping(false);
+		lockedDirection = null;
+		dragOffset = {
+			x: initialTransform.x,
+			y: initialTransform.y
+		};
+		setCurrentSwipeDirection(void 0);
+		sawPrimaryButtonsOnMove = false;
+		syncDragStyles(false);
+		const element = options.element();
+		if (element) safelyChangePointerCapture(element, event.pointerId, "releasePointerCapture");
+		updateSwipeProgress(0, {
+			deltaX: 0,
+			deltaY: 0,
+			direction: void 0
+		});
+		options.onCancel?.(event);
+	}
+	function applyDirectionalDamping(deltaX, deltaY) {
+		const exponent = (value) => Math.sign(value) * Math.abs(value) ** .5;
+		const dampAxis = (delta, allowNegative, allowPositive) => {
+			if (!allowNegative && delta < 0 || !allowPositive && delta > 0) return exponent(delta);
+			return delta;
+		};
+		return {
+			x: hasHorizontal() ? dampAxis(deltaX, allowLeft(), allowRight()) : exponent(deltaX),
+			y: hasVertical() ? dampAxis(deltaY, allowUp(), allowDown()) : exponent(deltaY)
+		};
+	}
+	function canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY) {
+		const canSwipeOnAxis = (delta, scrollOffset, maxScrollOffset, allowTowardStart, allowTowardEnd) => delta > 0 && scrollOffset <= 0 && allowTowardStart || delta < 0 && scrollOffset >= Math.max(0, maxScrollOffset) && allowTowardEnd;
+		const absDeltaX = Math.abs(deltaX);
+		const absDeltaY = Math.abs(deltaY);
+		if (hasVertical() && deltaY !== 0 && (!hasHorizontal() || absDeltaY >= absDeltaX)) return canSwipeOnAxis(deltaY, scrollTarget.scrollTop, scrollTarget.scrollHeight - scrollTarget.clientHeight, allowDown(), allowUp());
+		if (hasHorizontal() && deltaX !== 0 && (!hasVertical() || absDeltaX > absDeltaY)) return canSwipeOnAxis(deltaX, scrollTarget.scrollLeft, scrollTarget.scrollWidth - scrollTarget.clientWidth, allowRight(), allowLeft());
+		return null;
+	}
+	function handleStart(event) {
+		if (!options.enabled()) return;
+		if (event.defaultPrevented) return;
+		if (!isTouchEvent(event) && event.button !== 0) return;
+		const startPos = getPrimaryPointerPosition(event);
+		if (!startPos) return;
+		pendingSwipe = true;
+		pendingSwipeStartPos = startPos;
+		swipeFromScrollable = false;
+		sawPrimaryButtonsOnMove = !isTouchEvent(event);
+		if (!(options.canStart ? options.canStart(startPos, {
+			nativeEvent: event,
+			direction: primaryDirection()
+		}) : true)) return;
+		if (startSwipeAtPosition(event, startPos)) clearPendingSwipeStartState();
+	}
+	function handleMoveCore(event, currentTarget, position, movement) {
+		if (!options.enabled() || !swiping) return;
+		const target = getEventTarget(event);
+		if (isTouchLikeEvent(event) && !swipeFromScrollable && currentTarget) {
+			if (findGestureScrollableTouchTarget(target, currentTarget)) return;
+		}
+		if (!isTouchEvent(event)) event.preventDefault();
+		if (isFirstPointerMove) {
+			isFirstPointerMove = false;
+			if (trackDrag) {
+				dragStartPos = position;
+				const moveTime = getValidTimeStamp(event.timeStamp);
+				if (moveTime !== null) swipeStartTime = moveTime;
+			}
+		}
+		const clientX = position.x;
+		const clientY = position.y;
+		if (movement.y < 0 && clientY > swipeCancelBaseline.y || movement.y > 0 && clientY < swipeCancelBaseline.y) swipeCancelBaseline = {
+			x: swipeCancelBaseline.x,
+			y: clientY
+		};
+		if (movement.x < 0 && clientX > swipeCancelBaseline.x || movement.x > 0 && clientX < swipeCancelBaseline.x) swipeCancelBaseline = {
+			x: clientX,
+			y: swipeCancelBaseline.y
+		};
+		const deltaX = clientX - dragStartPos.x;
+		const deltaY = clientY - dragStartPos.y;
+		const cancelDeltaY = clientY - swipeCancelBaseline.y;
+		const cancelDeltaX = clientX - swipeCancelBaseline.x;
+		if (lockedDirection === null && hasHorizontal() && hasVertical()) {
+			if (Math.sqrt(deltaX * deltaX + deltaY * deltaY) >= MIN_DRAG_THRESHOLD) lockedDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "horizontal" : "vertical";
+		}
+		let candidate;
+		if (!intendedSwipeDirection) {
+			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) {
+				if (candidate === "left" && allowLeft() || candidate === "right" && allowRight() || candidate === "up" && allowUp() || candidate === "down" && allowDown()) {
+					intendedSwipeDirection = candidate;
+					maxSwipeDisplacement = getDisplacement(candidate, deltaX, deltaY);
+					setCurrentSwipeDirection(candidate);
+					resolveSwipeThreshold(candidate);
+				}
+			}
+		} else {
+			const direction = intendedSwipeDirection;
+			const currentDisplacement = getDisplacement(direction, cancelDeltaX, cancelDeltaY);
+			if (currentDisplacement > swipeThreshold) {
+				cancelledSwipe = false;
+				setCurrentSwipeDirection(direction);
+			} else if (!(allowLeft() && allowRight()) && !(allowUp() && allowDown()) && maxSwipeDisplacement - currentDisplacement >= REVERSE_CANCEL_THRESHOLD) cancelledSwipe = true;
+		}
+		const dampedDelta = applyDirectionalDamping(deltaX, deltaY);
+		let newOffsetX = initialTransform.x;
+		let newOffsetY = initialTransform.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;
+		}
+		const offsetChanged = newOffsetX !== dragOffset.x || newOffsetY !== dragOffset.y;
+		dragOffset = {
+			x: newOffsetX,
+			y: newOffsetY
+		};
+		if (offsetChanged) syncDragStyles(true);
+		recordDragSample({
+			x: newOffsetX,
+			y: newOffsetY
+		}, getValidTimeStamp(event.timeStamp));
+		const dragDeltaX = newOffsetX - initialTransform.x;
+		const dragDeltaY = newOffsetY - initialTransform.y;
+		const progressDetails = {
+			deltaX: dragDeltaX,
+			deltaY: dragDeltaY,
+			direction: intendedSwipeDirection
+		};
+		let progress = 0;
+		const progressDirection = primaryDirection() ?? intendedSwipeDirection;
+		if (progressDirection) {
+			const size = progressDirection === "left" || progressDirection === "right" ? elementSize.width : elementSize.height;
+			const scale = initialTransform.scale || 1;
+			const progressDisplacement = getDisplacement(progressDirection, dragDeltaX, dragDeltaY);
+			if (size > 0 && scale > 0 && progressDisplacement > 0) progress = progressDisplacement / (size * scale);
+		}
+		updateSwipeProgress(progress, progressDetails);
+	}
+	function handleEnd(event) {
+		if (!options.enabled()) return;
+		const resolvedDragOffset = dragOffset;
+		const resolvedInitialTransform = initialTransform;
+		const releaseDeltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
+		const releaseDeltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
+		const progressDetails = {
+			deltaX: releaseDeltaX,
+			deltaY: releaseDeltaY,
+			direction: intendedSwipeDirection
+		};
+		if (!swiping) {
+			resetPendingSwipeState();
+			updateSwipeProgress(0, progressDetails);
+			return;
+		}
+		setSwiping(false);
+		lockedDirection = null;
+		resetPendingSwipeState();
+		sawPrimaryButtonsOnMove = false;
+		const element = options.element();
+		if (element && !isTouchEvent(event)) safelyChangePointerCapture(element, event.pointerId, "releasePointerCapture");
+		const deltaX = releaseDeltaX;
+		const deltaY = releaseDeltaY;
+		const startTime = swipeStartTime;
+		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 = lastDragVelocity.x;
+		let releaseVelocityY = lastDragVelocity.y;
+		if (lastDragSample && endTime !== null && endTime >= lastDragSample.time) {
+			const ageMs = endTime - lastDragSample.time;
+			if (ageMs <= MAX_RELEASE_VELOCITY_AGE_MS) {
+				const sampleDurationMs = Math.max(ageMs, MIN_RELEASE_VELOCITY_DURATION_MS);
+				const sampleVelocityX = (resolvedDragOffset.x - lastDragSample.x) / sampleDurationMs;
+				const sampleVelocityY = (resolvedDragOffset.y - lastDragSample.y) / sampleDurationMs;
+				if (sampleVelocityX !== 0) releaseVelocityX = sampleVelocityX;
+				if (sampleVelocityY !== 0) releaseVelocityY = sampleVelocityY;
+			} else {
+				releaseVelocityX = 0;
+				releaseVelocityY = 0;
+			}
+		}
+		const releaseDecision = options.onRelease?.({
+			event,
+			direction: intendedSwipeDirection,
+			deltaX,
+			deltaY,
+			velocityX,
+			velocityY,
+			releaseVelocityX,
+			releaseVelocityY
+		});
+		const hasReleaseDecision = typeof releaseDecision === "boolean";
+		if (cancelledSwipe && !hasReleaseDecision) {
+			dragOffset = {
+				x: resolvedInitialTransform.x,
+				y: resolvedInitialTransform.y
+			};
+			setCurrentSwipeDirection(void 0);
+			syncDragStyles(false);
+			updateSwipeProgress(0, progressDetails);
+			return;
+		}
+		let shouldClose = false;
+		let dismissDirection;
+		if (hasReleaseDecision) {
+			shouldClose = releaseDecision;
+			dismissDirection = intendedSwipeDirection ?? primaryDirection();
+		} else for (const direction of options.directions()) if (getDisplacement(direction, deltaX, deltaY) > swipeThreshold) {
+			shouldClose = true;
+			dismissDirection = direction;
+			break;
+		}
+		if (shouldClose && dismissDirection) {
+			setCurrentSwipeDirection(dismissDirection);
+			setDragDismissed(true);
+			syncDragStyles(false);
+			options.onDismiss?.(event, { direction: dismissDirection });
+		} else {
+			dragOffset = {
+				x: resolvedInitialTransform.x,
+				y: resolvedInitialTransform.y
+			};
+			setCurrentSwipeDirection(void 0);
+			syncDragStyles(false);
+			updateSwipeProgress(0, progressDetails);
+		}
+	}
+	function handleMove(event, currentTarget) {
+		const currentPos = getPrimaryPointerPosition(event);
+		if (!currentPos) return;
+		const boundary = currentTarget ?? (isHTMLElement(event.currentTarget) ? event.currentTarget : null);
+		let endAfterMove = false;
+		if (!isTouchEvent(event)) {
+			const hasPrimaryButton = hasPrimaryMouseButton(event.buttons);
+			if (hasPrimaryButton) sawPrimaryButtonsOnMove = true;
+			if (event.buttons !== 0 && !hasPrimaryButton) {
+				cancelSwipeInteraction(event);
+				return;
+			}
+			if (event.buttons === 0 && sawPrimaryButtonsOnMove) {
+				if (!swiping) {
+					handleEnd(event);
+					return;
+				}
+				endAfterMove = true;
+			}
+		}
+		if (!swiping && pendingSwipe) {
+			if (!isTouchLikeEvent(event) && event.defaultPrevented) {
+				resetPendingSwipeState();
+				return;
+			}
+			if (options.canStart ? options.canStart(currentPos, {
+				nativeEvent: event,
+				direction: primaryDirection()
+			}) : true) {
+				const pendingStartPos = pendingSwipeStartPos;
+				let ignoreScrollableOnStart = false;
+				if (isTouchLikeEvent(event)) {
+					const element = options.element();
+					if (pendingStartPos && element) {
+						const target = getTargetAtPoint(currentPos, event);
+						const body = ownerDocument(element).body;
+						const scrollTarget = body ? findGestureScrollableTouchTarget(target, body) : null;
+						if (scrollTarget && (contains(element, scrollTarget) || contains(scrollTarget, element))) {
+							const canSwipeFromEdge = canSwipeFromScrollEdgeOnPendingMove(scrollTarget, currentPos.x - pendingStartPos.x, currentPos.y - pendingStartPos.y);
+							if (canSwipeFromEdge === false) return;
+							if (canSwipeFromEdge === true) ignoreScrollableOnStart = true;
+						}
+					}
+				}
+				if (startSwipeAtPosition(event, currentPos, {
+					ignoreScrollableTarget: ignoreScrollableOnStart,
+					ignoreScrollableAncestors: ignoreScrollableOnStart
+				})) {
+					if (pendingStartPos && ignoreScrollableOnStart) {
+						clearPendingSwipeStartState();
+						dragStartPos = pendingStartPos;
+						swipeCancelBaseline = pendingStartPos;
+						lastMovePos = pendingStartPos;
+						isFirstPointerMove = false;
+					} else {
+						clearPendingSwipeStartState();
+						swipeFromScrollable = false;
+					}
+				}
+			}
+		}
+		const previousPos = lastMovePos;
+		const movement = previousPos === null ? {
+			x: 0,
+			y: 0
+		} : {
+			x: currentPos.x - previousPos.x,
+			y: currentPos.y - previousPos.y
+		};
+		lastMovePos = currentPos;
+		handleMoveCore(event, boundary, currentPos, movement);
+		if (endAfterMove) handleEnd(event);
+	}
+	function getDragStyles() {
+		const active = swiping;
+		const deltaX = dragOffset.x - initialTransform.x;
+		const deltaY = dragOffset.y - initialTransform.y;
+		isSwiping();
+		const dismissed = dragDismissed();
+		if (!active && deltaX === 0 && deltaY === 0 && !dismissed) return {
+			[options.movementCssVars.x]: "0px",
+			[options.movementCssVars.y]: "0px"
+		};
+		return {
+			transition: active ? "none" : void 0,
+			transform: active ? getDragTransform(dragOffset, initialTransform.scale) : void 0,
+			[options.movementCssVars.x]: `${deltaX}px`,
+			[options.movementCssVars.y]: `${deltaY}px`
+		};
+	}
+	return {
+		swiping: isSwiping,
+		swipeDirection: currentSwipeDirection,
+		dragDismissed,
+		pointerHandlers: {
+			onPointerDown: handleStart,
+			onPointerMove: (event) => handleMove(event),
+			onPointerUp: handleEnd,
+			onPointerCancel: handleEnd
+		},
+		touchHandlers: {
+			onTouchStart: handleStart,
+			onTouchMove: (event) => handleMove(event),
+			onTouchEnd: handleEnd,
+			onTouchCancel: handleEnd
+		},
+		moveNative: (event, currentTarget) => handleMove(event, currentTarget),
+		getDragStyles,
+		reset
+	};
+}
+//#endregion
+//#region src/internals/constants.ts
+var BASE_UI_SWIPE_IGNORE_ATTRIBUTE = "data-base-ui-swipe-ignore";
+var LEGACY_SWIPE_IGNORE_ATTRIBUTE = "data-swipe-ignore";
+var BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
+var LEGACY_SWIPE_IGNORE_SELECTOR = `[${LEGACY_SWIPE_IGNORE_ATTRIBUTE}]`;
+//#endregion
+export { getElementTransform as a, getDisplacement as i, LEGACY_SWIPE_IGNORE_SELECTOR as n, getElementAtPoint as o, createSwipeDismiss as r, clamp as s, BASE_UI_SWIPE_IGNORE_SELECTOR as t };