@sprawlify/primitives 0.0.109 → 0.0.111

package/dist/machines/drawer/index.mjs

@@ -0,0 +1,1927 @@
+import { t as createAnatomy } from "../../create-anatomy-Dr0evdYy.mjs";
+import { $t as contains, D as disableTextSelection, G as getInitialFocus, Qt as getComputedStyle$1, St as isLeftClick, W as raf, fn as isHTMLElement, ht as getEventTarget, m as resizeObserverBorderBox, pn as isInputElement, pt as getEventPoint, un as isEditableElement, ut as addDomEvent } from "../../dom-query-BFuRs3l4.mjs";
+import { t as _defineProperty } from "../../defineProperty-D5oW_HU_.mjs";
+import { t as ariaHidden } from "../../aria-hidden-C72KtklN.mjs";
+import { H as toPx, g as clampValue, l as compact, u as createSplitProps } from "../../utils-VVoZ_v29.mjs";
+import { a as createMachine, i as createGuards } from "../../core-Ci9Yu6QI.mjs";
+import "../../interact-outside-Ba50N1a5.mjs";
+import { n as trackDismissableElement } from "../../dismissable-B9k5K6f9.mjs";
+import { t as trapFocus } from "../../focus-trap-Do8IUXYh.mjs";
+import { t as createProps } from "../../create-props-DFW8DUsC.mjs";
+import { t as preventBodyScroll } from "../../remove-scroll-D55GZoBb.mjs";
+//#region src/machines/drawer/drawer.anatomy.ts
+const anatomy = createAnatomy("drawer").parts("positioner", "content", "title", "description", "trigger", "backdrop", "grabber", "grabberIndicator", "closeTrigger", "swipeArea");
+const parts = anatomy.build();
+//#endregion
+//#region src/machines/drawer/drawer.dom.ts
+const getContentId = (ctx) => ctx.ids?.content ?? `drawer:${ctx.id}:content`;
+const getPositionerId = (ctx) => ctx.ids?.positioner ?? `drawer:${ctx.id}:positioner`;
+const getTitleId = (ctx) => ctx.ids?.title ?? `drawer:${ctx.id}:title`;
+const getDescriptionId = (ctx) => ctx.ids?.description ?? `drawer:${ctx.id}:description`;
+const getTriggerId = (ctx) => ctx.ids?.trigger ?? `drawer:${ctx.id}:trigger`;
+const getBackdropId = (ctx) => ctx.ids?.backdrop ?? `drawer:${ctx.id}:backdrop`;
+const getGrabberId = (ctx) => ctx.ids?.grabber ?? `drawer:${ctx.id}:grabber`;
+const getGrabberIndicatorId = (ctx) => ctx.ids?.grabberIndicator ?? `drawer:${ctx.id}:grabber-indicator`;
+const getCloseTriggerId = (ctx) => ctx.ids?.closeTrigger ?? `drawer:${ctx.id}:close-trigger`;
+const getSwipeAreaId = (ctx) => ctx.ids?.swipeArea ?? `drawer:${ctx.id}:swipe-area`;
+const getContentEl = (ctx) => ctx.getById(getContentId(ctx));
+const getTitleEl = (ctx) => ctx.getById(getTitleId(ctx));
+const getDescriptionEl = (ctx) => ctx.getById(getDescriptionId(ctx));
+const getTriggerEl = (ctx) => ctx.getById(getTriggerId(ctx));
+const getBackdropEl = (ctx) => ctx.getById(getBackdropId(ctx));
+const getCloseTriggerEl = (ctx) => ctx.getById(getCloseTriggerId(ctx));
+const getSwipeAreaEl = (ctx) => ctx.getById(getSwipeAreaId(ctx));
+//#endregion
+//#region src/machines/drawer/utils/snap-point.ts
+function resolveSnapPointValue(snapPoint, viewportSize, rootFontSize) {
+	if (!Number.isFinite(viewportSize) || viewportSize <= 0) return null;
+	if (typeof snapPoint === "number") {
+		if (!Number.isFinite(snapPoint)) return null;
+		if (snapPoint <= 1) return clampValue(snapPoint, 0, 1) * viewportSize;
+		return snapPoint;
+	}
+	const trimmed = snapPoint.trim();
+	if (trimmed.endsWith("px")) {
+		const value = Number.parseFloat(trimmed);
+		return Number.isFinite(value) ? value : null;
+	}
+	if (trimmed.endsWith("rem")) {
+		const value = Number.parseFloat(trimmed);
+		return Number.isFinite(value) ? value * rootFontSize : null;
+	}
+	return null;
+}
+function resolveSnapPoint(snapPoint, options) {
+	const { contentSize, viewportSize, rootFontSize } = options;
+	const maxSize = Math.min(contentSize, viewportSize);
+	if (!Number.isFinite(maxSize) || maxSize <= 0) return null;
+	const resolvedSize = resolveSnapPointValue(snapPoint, viewportSize, rootFontSize);
+	if (resolvedSize === null || !Number.isFinite(resolvedSize)) return null;
+	const height = clampValue(resolvedSize, 0, maxSize);
+	return {
+		value: snapPoint,
+		height,
+		offset: Math.max(0, contentSize - height)
+	};
+}
+const HEIGHT_DEDUP_EPSILON_PX = 1;
+function dedupeSnapPoints(points) {
+	if (points.length <= 1) return points;
+	const deduped = [];
+	const seenHeights = [];
+	for (let index = points.length - 1; index >= 0; index -= 1) {
+		const point = points[index];
+		if (seenHeights.some((height) => Math.abs(height - point.height) <= HEIGHT_DEDUP_EPSILON_PX)) continue;
+		seenHeights.push(point.height);
+		deduped.push(point);
+	}
+	deduped.reverse();
+	return deduped;
+}
+function findClosestSnapPoint(offset, snapPoints) {
+	return snapPoints.reduce((acc, curr) => {
+		const closestDiff = Math.abs(offset - acc.offset);
+		return Math.abs(offset - curr.offset) < closestDiff ? curr : acc;
+	});
+}
+//#endregion
+//#region src/machines/drawer/utils/session.ts
+const VELOCITY_WINDOW_MS = 100;
+const MAX_RELEASE_VELOCITY_AGE_MS = 80;
+const MIN_GESTURE_DURATION_MS = 50;
+const MIN_VELOCITY_SAMPLES = 2;
+const SAMPLE_BUFFER_COMPACT_THRESHOLD = 8;
+const DEFERRED_DRAG_MIN_MAIN_AXIS_PX = 6;
+const DEFERRED_DRAG_MAIN_OVER_CROSS_RATIO = 1.35;
+function isVerticalSwipeDirection(direction) {
+	return direction === "down" || direction === "up";
+}
+function isNegativeSwipeDirection(direction) {
+	return direction === "up" || direction === "left";
+}
+var SwipeSession = class {
+	constructor() {
+		_defineProperty(this, "startPoint", null);
+		_defineProperty(this, "velocity", null);
+		_defineProperty(this, "samples", []);
+		_defineProperty(this, "sampleStartIndex", 0);
+		_defineProperty(this, "gestureStartAxis", null);
+		_defineProperty(this, "gestureStartTime", null);
+		_defineProperty(this, "gestureSign", 1);
+		_defineProperty(this, "pendingSwipe", null);
+	}
+	setStartPoint(point) {
+		this.startPoint = point;
+	}
+	clearStartPoint() {
+		this.startPoint = null;
+	}
+	getStartPoint() {
+		return this.startPoint;
+	}
+	getGestureAxis(direction) {
+		return direction === "left" || direction === "right" ? "x" : "y";
+	}
+	getGestureSign(direction) {
+		return isNegativeSwipeDirection(direction) ? -1 : 1;
+	}
+	getAxisValue(point, axis) {
+		return point[axis];
+	}
+	getMainAxisDisplacement(point, axis, sign) {
+		if (!this.startPoint) return 0;
+		return (this.getAxisValue(this.startPoint, axis) - this.getAxisValue(point, axis)) * sign;
+	}
+	getCrossAxisDisplacement(point, axis) {
+		if (!this.startPoint) return 0;
+		const crossAxis = axis === "x" ? "y" : "x";
+		const startAxis = this.getAxisValue(this.startPoint, crossAxis);
+		return this.getAxisValue(point, crossAxis) - startAxis;
+	}
+	track(point, axis, sign) {
+		const axisValue = this.getAxisValue(point, axis);
+		const now = performance.now();
+		if (this.gestureStartAxis === null) {
+			this.gestureStartAxis = axisValue;
+			this.gestureStartTime = now;
+			this.gestureSign = sign;
+		}
+		this.samples.push({
+			axis: axisValue,
+			time: now
+		});
+		const cutoff = now - VELOCITY_WINDOW_MS;
+		while (this.sampleStartIndex < this.samples.length && this.samples[this.sampleStartIndex].time < cutoff) this.sampleStartIndex += 1;
+		if (this.sampleStartIndex >= SAMPLE_BUFFER_COMPACT_THRESHOLD) {
+			this.samples = this.samples.slice(this.sampleStartIndex);
+			this.sampleStartIndex = 0;
+		}
+		if (this.samples.length - this.sampleStartIndex < MIN_VELOCITY_SAMPLES) {
+			this.velocity = 0;
+			return;
+		}
+		const oldest = this.samples[this.sampleStartIndex];
+		const newest = this.samples[this.samples.length - 1];
+		const dt = newest.time - oldest.time;
+		if (dt <= 0) {
+			this.velocity = 0;
+			return;
+		}
+		const velocity = (newest.axis - oldest.axis) * sign / dt * 1e3;
+		this.velocity = Number.isFinite(velocity) ? velocity : 0;
+	}
+	getReleaseVelocity() {
+		const now = performance.now();
+		if (this.samples.length - this.sampleStartIndex >= MIN_VELOCITY_SAMPLES) {
+			if (now - this.samples[this.samples.length - 1].time <= MAX_RELEASE_VELOCITY_AGE_MS) return this.velocity ?? 0;
+		}
+		if (this.gestureStartAxis !== null && this.gestureStartTime !== null) {
+			const lastSample = this.samples[this.samples.length - 1];
+			if (lastSample) {
+				const dt = Math.max(lastSample.time - this.gestureStartTime, MIN_GESTURE_DURATION_MS);
+				const velocity = (lastSample.axis - this.gestureStartAxis) * this.gestureSign / dt * 1e3;
+				return Number.isFinite(velocity) ? velocity : 0;
+			}
+		}
+		return this.velocity ?? 0;
+	}
+	clearVelocityTracking() {
+		this.samples = [];
+		this.sampleStartIndex = 0;
+		this.velocity = null;
+		this.gestureStartAxis = null;
+		this.gestureStartTime = null;
+		this.gestureSign = 1;
+	}
+	clear() {
+		this.cancelDeferredSwipe();
+		this.clearStartPoint();
+		this.clearVelocityTracking();
+	}
+	startDeferredSwipe(options) {
+		const { getWin, pointerId, startPoint, swipeDirection, onCommit, canCommit, onCancel } = options;
+		this.cancelDeferredSwipe();
+		const win = getWin();
+		const vertical = isVerticalSwipeDirection(swipeDirection);
+		const onMove = (event) => {
+			if (event.pointerId !== pointerId) return;
+			const dx = event.clientX - startPoint.x;
+			const dy = event.clientY - startPoint.y;
+			const mainDelta = vertical ? dy : dx;
+			const crossDelta = vertical ? dx : dy;
+			const absMain = Math.abs(mainDelta);
+			if (absMain >= DEFERRED_DRAG_MIN_MAIN_AXIS_PX && absMain >= Math.abs(crossDelta) * DEFERRED_DRAG_MAIN_OVER_CROSS_RATIO) {
+				if (!canCommit || canCommit()) onCommit(startPoint);
+				this.cancelDeferredSwipe();
+			}
+		};
+		const onEnd = (event) => {
+			if (event.pointerId !== pointerId) return;
+			onCancel?.();
+			this.cancelDeferredSwipe();
+		};
+		this.pendingSwipe = {
+			pointerId,
+			startPoint,
+			cleanups: [
+				addDomEvent(win, "pointermove", onMove, { capture: true }),
+				addDomEvent(win, "pointerup", onEnd, { capture: true }),
+				addDomEvent(win, "pointercancel", onEnd, { capture: true }),
+				addDomEvent(win, "lostpointercapture", onEnd, { capture: true })
+			]
+		};
+	}
+	cancelDeferredSwipe() {
+		if (!this.pendingSwipe) return;
+		this.pendingSwipe.cleanups.forEach((cleanup) => cleanup());
+		this.pendingSwipe = null;
+	}
+	bind(options) {
+		const { getDoc, getSelectionTarget, swipeDirection, onStart, onMove, onEnd, onCancel, preventDefault, cancelOnInterrupt } = options;
+		const doc = getDoc();
+		let usingTouchEvents = false;
+		let restoreSelection;
+		const axis = this.getGestureAxis(swipeDirection);
+		const sign = this.getGestureSign(swipeDirection);
+		const trackPoint = (point) => {
+			this.track(point, axis, sign);
+		};
+		const startSelectionGuard = () => {
+			restoreSelection ?? (restoreSelection = disableTextSelection({
+				doc,
+				target: getSelectionTarget?.()
+			}));
+		};
+		const stopSelectionGuard = () => {
+			restoreSelection?.();
+			restoreSelection = void 0;
+		};
+		function onPointerMove(event) {
+			if (event.pointerType === "touch" && usingTouchEvents) return;
+			const point = getEventPoint(event);
+			const target = getEventTarget(event);
+			startSelectionGuard();
+			trackPoint(point);
+			onMove({
+				point,
+				target,
+				event,
+				pointerType: event.pointerType,
+				axis,
+				swipeDirection
+			});
+		}
+		function onPointerUp(event) {
+			if (event.pointerType === "touch" && usingTouchEvents) {
+				usingTouchEvents = false;
+				return;
+			}
+			stopSelectionGuard();
+			onEnd({
+				point: getEventPoint(event),
+				swipeDirection
+			});
+		}
+		function onPointerCancel(event) {
+			if (event.pointerType === "touch" && usingTouchEvents) {
+				usingTouchEvents = false;
+				return;
+			}
+			stopSelectionGuard();
+			onCancel();
+		}
+		function onTouchStartEvent(event) {
+			if (!event.touches[0]) return;
+			usingTouchEvents = true;
+			const point = getEventPoint(event);
+			const target = getEventTarget(event);
+			onStart?.({
+				point,
+				target,
+				event,
+				pointerType: "touch",
+				axis,
+				swipeDirection
+			});
+		}
+		function onTouchMoveEvent(event) {
+			if (!event.touches[0]) return;
+			usingTouchEvents = true;
+			const point = getEventPoint(event);
+			const details = {
+				point,
+				target: getEventTarget(event),
+				event,
+				pointerType: "touch",
+				axis,
+				swipeDirection
+			};
+			if (preventDefault?.(details) && event.cancelable) event.preventDefault();
+			startSelectionGuard();
+			trackPoint(point);
+			onMove(details);
+		}
+		function onTouchEnd(event) {
+			if (event.touches.length !== 0) return;
+			stopSelectionGuard();
+			onEnd({
+				point: getEventPoint(event),
+				swipeDirection
+			});
+		}
+		function onTouchCancel() {
+			stopSelectionGuard();
+			onCancel();
+		}
+		function onVisibilityChange() {
+			if (doc.visibilityState !== "hidden") return;
+			if (cancelOnInterrupt?.({
+				reason: "visibility-hidden",
+				event: doc,
+				target: null,
+				pointerType: null
+			}) === false) return;
+			stopSelectionGuard();
+			onCancel();
+		}
+		function onLostPointerCapture(event) {
+			if (event.pointerType === "touch") return;
+			const target = getEventTarget(event);
+			if (cancelOnInterrupt?.({
+				reason: "lost-pointer-capture",
+				event,
+				target,
+				pointerType: event.pointerType
+			}) === false) return;
+			onCancel();
+		}
+		const cleanups = [
+			addDomEvent(doc, "pointermove", onPointerMove),
+			addDomEvent(doc, "pointerup", onPointerUp),
+			addDomEvent(doc, "pointercancel", onPointerCancel),
+			addDomEvent(doc, "touchstart", onTouchStartEvent, {
+				capture: true,
+				passive: false
+			}),
+			addDomEvent(doc, "touchmove", onTouchMoveEvent, {
+				capture: true,
+				passive: false
+			}),
+			addDomEvent(doc, "touchend", onTouchEnd, { capture: true }),
+			addDomEvent(doc, "touchcancel", onTouchCancel, { capture: true }),
+			addDomEvent(doc, "visibilitychange", onVisibilityChange),
+			addDomEvent(doc, "lostpointercapture", onLostPointerCapture, true)
+		];
+		return () => {
+			stopSelectionGuard();
+			cleanups.forEach((cleanup) => cleanup());
+		};
+	}
+};
+//#endregion
+//#region src/machines/drawer/utils/drawer-session.ts
+const RELEASE_DISPLACEMENT_TRUST_PX = 24;
+const OPEN_SWIPE_HIDDEN_VISIBLE_RATIO = .22;
+const OPEN_SWIPE_HIDDEN_VELOCITY_MULTIPLIER = 1.25;
+const OPEN_SWIPE_REVEALED_VISIBLE_RATIO = .5;
+const OPEN_SWIPE_REVEALED_OPPOSING_MAX_ABS_VELOCITY = 650;
+const DRAG_START_THRESHOLD = .3;
+const CROSS_AXIS_BIAS = .58;
+const SCROLL_SLACK_GATE = .5;
+const SCROLL_SLACK_EPSILON = 1;
+const SEQUENTIAL_THRESHOLD = 24;
+const SNAP_VELOCITY_THRESHOLD = 400;
+const SNAP_VELOCITY_MULTIPLIER = .4;
+const MAX_SNAP_VELOCITY = 4e3;
+const SWIPE_STRENGTH_MAX_DURATION_MS = 360;
+const SWIPE_STRENGTH_MIN_SCALAR = .1;
+const SWIPE_STRENGTH_MAX_SCALAR = 1;
+const SWIPE_AREA_OPEN_INTENT_MIN_PX = 5;
+const NO_DRAG_DATA_ATTR = "data-no-drag";
+const NO_DRAG_SELECTOR = `[${NO_DRAG_DATA_ATTR}]`;
+var DrawerSwipeSession = class {
+	constructor(options) {
+		_defineProperty(this, "session", new SwipeSession());
+		_defineProperty(this, "dragOffset", null);
+		_defineProperty(this, "preventDragOnScroll", void 0);
+		this.preventDragOnScroll = options.preventDragOnScroll;
+	}
+	contentPointerDown(options) {
+		const { event, getDoc, getContentEl, getWin, swipeDirection, canCommit, onCommit } = options;
+		if (shouldIgnorePointerDownForDrag(event)) return;
+		if (isTextSelectionInDrawer(getDoc(), getContentEl())) return;
+		if (!canCommit()) return;
+		const point = getEventPoint(event);
+		if (!(event.pointerType === "mouse" || event.pointerType === "pen")) {
+			onCommit(point);
+			return;
+		}
+		this.session.startDeferredSwipe({
+			getWin,
+			pointerId: event.pointerId,
+			startPoint: point,
+			swipeDirection,
+			onCommit,
+			canCommit
+		});
+	}
+	grabberPointerDown(options) {
+		const { event, point, canCommit, onCommit } = options;
+		if (shouldIgnorePointerDownForDrag(event)) return;
+		this.session.cancelDeferredSwipe();
+		if (!canCommit()) return;
+		onCommit(point);
+	}
+	adjustReleaseVelocityAgainstDisplacement(velocity, displacementFromSnap) {
+		const displacementSign = Math.sign(displacementFromSnap);
+		const velocitySign = Math.sign(velocity);
+		if (displacementSign !== 0 && Math.abs(displacementFromSnap) >= RELEASE_DISPLACEMENT_TRUST_PX && velocitySign !== 0 && velocitySign !== displacementSign) return 0;
+		return velocity;
+	}
+	adjustReleaseVelocityForOpenSwipe(velocity, visibleRatio, swipeVelocityThreshold) {
+		if (visibleRatio < OPEN_SWIPE_HIDDEN_VISIBLE_RATIO && velocity < 0 && Math.abs(velocity) < swipeVelocityThreshold * OPEN_SWIPE_HIDDEN_VELOCITY_MULTIPLIER) return 0;
+		if (visibleRatio > OPEN_SWIPE_REVEALED_VISIBLE_RATIO && velocity > 0 && Math.abs(velocity) < OPEN_SWIPE_REVEALED_OPPOSING_MAX_ABS_VELOCITY) return 0;
+		return velocity;
+	}
+	beginSwipe(point) {
+		this.session.setStartPoint(point);
+	}
+	clearSwipeStart() {
+		this.session.clearStartPoint();
+	}
+	getSwipeStart() {
+		return this.session.getStartPoint();
+	}
+	getDragOffset() {
+		return this.dragOffset;
+	}
+	resetDragOffset() {
+		this.dragOffset = null;
+	}
+	resetVelocity() {
+		this.session.clearVelocityTracking();
+	}
+	reset() {
+		this.dragOffset = null;
+		this.session.clear();
+	}
+	setDragOffset(point, resolvedActiveSnapPointOffset, direction) {
+		if (!this.session.getStartPoint()) {
+			this.dragOffset = null;
+			return;
+		}
+		const axis = this.session.getGestureAxis(direction);
+		const sign = this.session.getGestureSign(direction);
+		let delta = this.session.getMainAxisDisplacement(point, axis, sign) - resolvedActiveSnapPointOffset;
+		if (delta > 0) delta = Math.sqrt(delta);
+		this.dragOffset = -delta;
+	}
+	setSwipeOpenOffset(point, contentSize, direction) {
+		if (!this.session.getStartPoint()) {
+			this.dragOffset = null;
+			return;
+		}
+		const axis = this.session.getGestureAxis(direction);
+		const sign = this.session.getGestureSign(direction);
+		const openDisplacement = this.session.getMainAxisDisplacement(point, axis, sign);
+		let dragOffset = contentSize - Math.max(0, openDisplacement);
+		if (dragOffset < 0) dragOffset = -Math.sqrt(Math.abs(dragOffset));
+		this.dragOffset = dragOffset;
+	}
+	canStartDrag(point, target, container, preventDragOnScroll, direction) {
+		if (!isHTMLElement(target)) return false;
+		if (isDragExemptElement(target)) return false;
+		if (!this.session.getStartPoint() || !container) return false;
+		if (!preventDragOnScroll) return true;
+		const axis = this.session.getGestureAxis(direction);
+		const sign = this.session.getGestureSign(direction);
+		const delta = this.session.getMainAxisDisplacement(point, axis, sign);
+		if (Math.abs(delta) < DRAG_START_THRESHOLD) return false;
+		if (Math.abs(this.session.getCrossAxisDisplacement(point, axis)) > Math.abs(delta) * CROSS_AXIS_BIAS) {
+			const crossScroll = getScrollInfo(target, container, isVerticalSwipeDirection(direction) ? "right" : "down");
+			if (crossScroll.availableForwardScroll > SCROLL_SLACK_GATE || crossScroll.availableBackwardScroll > SCROLL_SLACK_GATE) return false;
+		}
+		const { availableForwardScroll, availableBackwardScroll } = getScrollInfo(target, container, direction);
+		if (delta > 0 && availableForwardScroll > SCROLL_SLACK_GATE || delta < 0 && availableBackwardScroll > SCROLL_SLACK_GATE) return false;
+		return true;
+	}
+	resolveSnapPointOnRelease(snapPoints, snapPoint, snapToSequentialPoints, contentSize) {
+		const dragOffset = this.dragOffset;
+		if (dragOffset === null) return snapPoints[0]?.value ?? 1;
+		const releaseVelocity = this.session.getReleaseVelocity();
+		if (snapToSequentialPoints && snapPoint) {
+			const ordered = [...snapPoints].sort((a, b) => a.offset - b.offset);
+			let currentIndex = 0;
+			let closestDist = Math.abs(snapPoint.offset - ordered[0].offset);
+			for (let i = 1; i < ordered.length; i++) {
+				const dist = Math.abs(snapPoint.offset - ordered[i].offset);
+				if (dist < closestDist) {
+					closestDist = dist;
+					currentIndex = i;
+				}
+			}
+			const currentPoint = ordered[currentIndex];
+			const delta = dragOffset - currentPoint.offset;
+			const dragDirection = Math.sign(delta);
+			const velocityAdjusted = this.adjustReleaseVelocityAgainstDisplacement(releaseVelocity, delta);
+			const velocityDirection = Math.sign(velocityAdjusted);
+			let targetSnapPoint = currentPoint;
+			let effectiveTargetOffset = dragOffset;
+			if (dragDirection !== 0 && velocityDirection === dragDirection && Math.abs(velocityAdjusted) >= SNAP_VELOCITY_THRESHOLD) {
+				const adjacentIndex = Math.min(Math.max(currentIndex + dragDirection, 0), ordered.length - 1);
+				if (adjacentIndex !== currentIndex) {
+					targetSnapPoint = ordered[adjacentIndex];
+					effectiveTargetOffset = targetSnapPoint.offset;
+				} else if (dragDirection > 0) return null;
+			} else if (delta > SEQUENTIAL_THRESHOLD) {
+				const nextPoint = ordered[Math.min(currentIndex + 1, ordered.length - 1)];
+				if (nextPoint) {
+					targetSnapPoint = nextPoint;
+					effectiveTargetOffset = nextPoint.offset;
+				}
+			} else if (delta < -SEQUENTIAL_THRESHOLD) {
+				const prevPoint = ordered[Math.max(currentIndex - 1, 0)];
+				if (prevPoint) {
+					targetSnapPoint = prevPoint;
+					effectiveTargetOffset = prevPoint.offset;
+				}
+			}
+			if (Math.abs(effectiveTargetOffset - contentSize) < Math.abs(effectiveTargetOffset - targetSnapPoint.offset)) return null;
+			return targetSnapPoint.value;
+		}
+		const snapRestOffset = snapPoint?.offset ?? 0;
+		const velocity = this.adjustReleaseVelocityAgainstDisplacement(releaseVelocity, dragOffset - snapRestOffset);
+		let targetOffset = dragOffset;
+		if (Math.abs(velocity) >= SNAP_VELOCITY_THRESHOLD) {
+			const clamped = clampValue(velocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY);
+			targetOffset += clamped * SNAP_VELOCITY_MULTIPLIER;
+			targetOffset = Math.max(0, targetOffset);
+		}
+		return findClosestSnapPoint(targetOffset, snapPoints).value;
+	}
+	shouldOpenOnRelease(contentSize, swipeVelocityThreshold, openThreshold) {
+		const dragOffset = this.dragOffset;
+		if (dragOffset === null || contentSize === null) return false;
+		const visibleSize = contentSize - dragOffset;
+		const visibleRatio = visibleSize / contentSize;
+		const velocity = this.adjustReleaseVelocityForOpenSwipe(this.session.getReleaseVelocity(), visibleRatio, swipeVelocityThreshold);
+		return velocity < 0 && Math.abs(velocity) >= swipeVelocityThreshold || visibleSize >= contentSize * openThreshold;
+	}
+	shouldDismissOnRelease(contentSize, snapPoints, resolvedSnapOffset) {
+		const dragOffset = this.dragOffset;
+		if (dragOffset === null || contentSize === null) return false;
+		const velocity = this.adjustReleaseVelocityAgainstDisplacement(this.session.getReleaseVelocity(), dragOffset - resolvedSnapOffset);
+		if (contentSize - dragOffset <= 0) return true;
+		let targetOffset = dragOffset;
+		if (Math.abs(velocity) >= SNAP_VELOCITY_THRESHOLD) {
+			const clamped = clampValue(velocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY);
+			targetOffset += clamped * SNAP_VELOCITY_MULTIPLIER;
+			targetOffset = Math.max(0, targetOffset);
+		}
+		const closeDistance = Math.abs(targetOffset - contentSize);
+		const closest = findClosestSnapPoint(targetOffset, snapPoints);
+		return closeDistance < Math.abs(targetOffset - closest.offset);
+	}
+	getSwipeStrength(targetOffset, resolvedSnapOffset = null) {
+		const dragOffset = this.dragOffset;
+		if (dragOffset === null) return SWIPE_STRENGTH_MAX_SCALAR;
+		let velocity = this.session.getReleaseVelocity();
+		if (resolvedSnapOffset != null) velocity = this.adjustReleaseVelocityAgainstDisplacement(velocity, dragOffset - resolvedSnapOffset);
+		const distance = Math.abs(dragOffset - targetOffset);
+		const absVelocity = Math.abs(velocity);
+		if (absVelocity <= 0 || distance <= 0) return SWIPE_STRENGTH_MAX_SCALAR;
+		return SWIPE_STRENGTH_MIN_SCALAR + clampValue(distance / absVelocity * 1e3 / SWIPE_STRENGTH_MAX_DURATION_MS, 0, 1) * (SWIPE_STRENGTH_MAX_SCALAR - SWIPE_STRENGTH_MIN_SCALAR);
+	}
+	bindDragTracking(options) {
+		const { getDoc, getContentEl, getSwipeAreaEl, swipeDirection, onMove, onEnd, onCancel } = options;
+		const preventDragOnScroll = this.preventDragOnScroll;
+		const isVertical = isVerticalSwipeDirection(swipeDirection);
+		let lastAxis = 0;
+		return this.session.bind({
+			getDoc,
+			getSelectionTarget: getContentEl,
+			swipeDirection,
+			onMove,
+			onEnd,
+			onCancel,
+			cancelOnInterrupt: ({ reason, target }) => {
+				if (reason !== "lost-pointer-capture") return true;
+				return isWithinDrawerInteractionSurface(target, getContentEl(), getSwipeAreaEl());
+			},
+			onStart({ pointerType, point }) {
+				if (pointerType !== "touch") return;
+				lastAxis = isVertical ? point.y : point.x;
+			},
+			preventDefault({ event, pointerType, point, target }) {
+				if (pointerType !== "touch") return false;
+				const contentEl = getContentEl();
+				const resolvedTarget = target ?? event.target;
+				if (!preventDragOnScroll()) return false;
+				if (!contentEl || !resolvedTarget || isDragExemptElement(resolvedTarget)) return false;
+				const scrollParent = findClosestScrollableAncestorOnSwipeAxis(resolvedTarget, contentEl, swipeDirection);
+				if (scrollParent) {
+					const currentAxis = isVertical ? point.y : point.x;
+					const shouldPrevent = shouldPreventTouchScroll({
+						scrollParent,
+						swipeDirection,
+						lastMainAxis: lastAxis,
+						currentMainAxis: currentAxis
+					});
+					lastAxis = currentAxis;
+					return shouldPrevent;
+				}
+				lastAxis = isVertical ? point.y : point.x;
+				return false;
+			}
+		});
+	}
+	bindSwipeOpenTracking(options) {
+		const { getDoc, getContentEl, getSwipeAreaEl, swipeDirection, onMove, onEnd, onCancel } = options;
+		return this.session.bind({
+			getDoc,
+			getSelectionTarget: getSwipeAreaEl,
+			swipeDirection,
+			onMove({ point }) {
+				onMove({ point });
+			},
+			onEnd,
+			onCancel,
+			cancelOnInterrupt: ({ reason, target }) => {
+				if (reason !== "lost-pointer-capture") return true;
+				return isWithinDrawerInteractionSurface(target, getContentEl(), getSwipeAreaEl());
+			}
+		});
+	}
+};
+function isWithinDrawerInteractionSurface(target, contentEl, swipeAreaEl) {
+	if (!target) return false;
+	return contains(contentEl, target) || contains(swipeAreaEl, target);
+}
+const oppositeSwipeDirection = {
+	up: "down",
+	down: "up",
+	start: "end",
+	end: "start"
+};
+function resolveSwipeDirection(direction, dir) {
+	if (direction === "start") return dir === "rtl" ? "right" : "left";
+	if (direction === "end") return dir === "rtl" ? "left" : "right";
+	return direction;
+}
+function getSwipeDirectionSize(rect, direction) {
+	return isVerticalSwipeDirection(direction) ? rect.height : rect.width;
+}
+function resolveSwipeProgress(contentSize, dragOffset, snapPointOffset) {
+	if (!contentSize || contentSize <= 0) return 0;
+	return clampValue(1 - (dragOffset ?? snapPointOffset) / contentSize, 0, 1);
+}
+function hasOpeningSwipeIntent(start, current, direction) {
+	const axis = isVerticalSwipeDirection(direction) ? "y" : "x";
+	const sign = isNegativeSwipeDirection(direction) ? -1 : 1;
+	return (start[axis] - current[axis]) * sign > SWIPE_AREA_OPEN_INTENT_MIN_PX;
+}
+function overflowAllowsScroll(overflow) {
+	return overflow === "auto" || overflow === "scroll" || overflow === "overlay";
+}
+function canScrollAlongY(el) {
+	if (!overflowAllowsScroll(getComputedStyle$1(el).overflowY)) return false;
+	return el.scrollHeight > el.clientHeight + SCROLL_SLACK_EPSILON;
+}
+function canScrollAlongX(el) {
+	if (!overflowAllowsScroll(getComputedStyle$1(el).overflowX)) return false;
+	return el.scrollWidth > el.clientWidth + SCROLL_SLACK_EPSILON;
+}
+function canScrollOnSwipeAxis(el, direction) {
+	return isVerticalSwipeDirection(direction) ? canScrollAlongY(el) : canScrollAlongX(el);
+}
+function findClosestScrollableAncestorOnSwipeAxis(target, container, direction) {
+	if (!container) return null;
+	let el = target;
+	while (el && el !== container) {
+		if (canScrollOnSwipeAxis(el, direction)) return el;
+		el = el.parentElement;
+	}
+	return null;
+}
+function getScrollInfo(target, container, direction) {
+	let availableForwardScroll = 0;
+	let availableBackwardScroll = 0;
+	if (!container) return {
+		availableForwardScroll,
+		availableBackwardScroll
+	};
+	const vertical = isVerticalSwipeDirection(direction);
+	let element = target;
+	while (element) {
+		if (vertical ? canScrollAlongY(element) : canScrollAlongX(element)) {
+			const clientSize = vertical ? element.clientHeight : element.clientWidth;
+			const scrollPos = vertical ? element.scrollTop : element.scrollLeft;
+			const scrolled = (vertical ? element.scrollHeight : element.scrollWidth) - scrollPos - clientSize;
+			availableForwardScroll += scrolled;
+			availableBackwardScroll += scrollPos;
+		}
+		if (element === container || element === element.ownerDocument.documentElement) break;
+		element = element.parentElement;
+	}
+	return {
+		availableForwardScroll,
+		availableBackwardScroll
+	};
+}
+function shouldPreventTouchScroll(options) {
+	const { scrollParent, swipeDirection, lastMainAxis, currentMainAxis } = options;
+	const vertical = isVerticalSwipeDirection(swipeDirection);
+	const movingPositive = currentMainAxis > lastMainAxis;
+	if (vertical) {
+		const scrollPos = scrollParent.scrollTop;
+		const maxScroll = Math.max(0, scrollParent.scrollHeight - scrollParent.clientHeight);
+		if (swipeDirection === "down") return scrollPos <= SCROLL_SLACK_EPSILON && movingPositive;
+		if (swipeDirection === "up") return scrollPos >= maxScroll - SCROLL_SLACK_EPSILON && !movingPositive;
+	} else {
+		const scrollPos = scrollParent.scrollLeft;
+		const maxScroll = Math.max(0, scrollParent.scrollWidth - scrollParent.clientWidth);
+		if (swipeDirection === "right") return scrollPos <= SCROLL_SLACK_EPSILON && movingPositive;
+		if (swipeDirection === "left") return scrollPos >= maxScroll - SCROLL_SLACK_EPSILON && !movingPositive;
+	}
+	return false;
+}
+function isDragExemptElement(el) {
+	if (!isHTMLElement(el)) return false;
+	if (el.closest(NO_DRAG_SELECTOR)) return true;
+	let node = el;
+	while (node) {
+		if (isEditableElement(node)) return true;
+		node = node.parentElement;
+	}
+	const input = el.closest("input");
+	if (isInputElement(input)) {
+		const type = input.type;
+		if (type === "range" || type === "file") return true;
+	}
+	return false;
+}
+function isTextSelectionInDrawer(doc, contentEl) {
+	if (!contentEl) return false;
+	const selection = doc.getSelection();
+	if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return false;
+	try {
+		const range = selection.getRangeAt(0);
+		if (contains(contentEl, range.commonAncestorContainer)) return true;
+		if (contains(contentEl, selection.anchorNode)) return true;
+		if (contains(contentEl, selection.focusNode)) return true;
+		if (typeof range.intersectsNode === "function" && range.intersectsNode(contentEl)) return true;
+	} catch {
+		return false;
+	}
+	return false;
+}
+function isDragExemptFromComposedPath(event) {
+	const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+	for (const node of path) if (isDragExemptElement(node)) return true;
+	return isDragExemptElement(event.target);
+}
+function shouldIgnorePointerDownForDrag(event) {
+	if (!isLeftClick(event)) return true;
+	const target = getEventTarget(event);
+	if (target?.hasAttribute(NO_DRAG_DATA_ATTR) || target?.closest(NO_DRAG_SELECTOR)) return true;
+	return isDragExemptFromComposedPath(event);
+}
+//#endregion
+//#region src/machines/drawer/drawer.connect.ts
+const SWIPE_OPEN_HIDDEN_OFFSET = 9999;
+function getSwipeOpenOffset(swipingOpen, dragOffset, contentSize) {
+	if (!swipingOpen || dragOffset !== null) return null;
+	return contentSize ?? SWIPE_OPEN_HIDDEN_OFFSET;
+}
+function connect(service, normalize) {
+	const { state, send, context, scope, prop, refs } = service;
+	const open = state.hasTag("open");
+	const closed = state.matches("closed");
+	const swipingOpen = state.matches("swiping-open");
+	const dragOffset = context.get("dragOffset");
+	const dragging = dragOffset !== null;
+	const snapPoint = context.get("snapPoint");
+	const swipeDirection = prop("swipeDirection");
+	const physicalDirection = resolveSwipeDirection(swipeDirection, prop("dir"));
+	const contentSize = context.get("contentSize");
+	const swipeStrength = context.get("swipeStrength");
+	const resolvedActiveSnapPoint = context.get("resolvedActiveSnapPoint");
+	const snapPointOffset = resolvedActiveSnapPoint?.offset ?? 0;
+	const currentOffset = getSwipeOpenOffset(swipingOpen, dragOffset, contentSize) ?? dragOffset ?? snapPointOffset;
+	const signedSnapPointOffset = isNegativeSwipeDirection(physicalDirection) ? -snapPointOffset : snapPointOffset;
+	const isActivelySwiping = dragging || swipingOpen;
+	const swipeMovement = dragging || swipingOpen ? currentOffset - snapPointOffset : 0;
+	const signedMovement = isNegativeSwipeDirection(physicalDirection) ? -swipeMovement : swipeMovement;
+	const swipeProgress = isActivelySwiping && contentSize && contentSize > 0 ? clampValue(Math.abs(signedMovement) / contentSize, 0, 1) : swipingOpen ? 1 : 0;
+	const signedCurrentOffset = isNegativeSwipeDirection(physicalDirection) ? -currentOffset : currentOffset;
+	const translateX = isVerticalSwipeDirection(physicalDirection) ? 0 : signedCurrentOffset;
+	const translateY = isVerticalSwipeDirection(physicalDirection) ? signedCurrentOffset : 0;
+	function onContentPointerDown(event) {
+		refs.get("swipeSession").contentPointerDown({
+			event,
+			getDoc: () => scope.getDoc(),
+			getContentEl: () => getContentEl(scope),
+			getWin: () => scope.getWin(),
+			swipeDirection: physicalDirection,
+			canCommit: () => state.hasTag("open") && !state.matches("closing"),
+			onCommit(point) {
+				send({
+					type: "POINTER_DOWN",
+					point
+				});
+			}
+		});
+	}
+	function onGrabberPointerDown(event) {
+		refs.get("swipeSession").grabberPointerDown({
+			event,
+			point: getEventPoint(event),
+			canCommit: () => state.hasTag("open") && !state.matches("closing"),
+			onCommit(point) {
+				send({
+					type: "POINTER_DOWN",
+					point
+				});
+			}
+		});
+	}
+	return {
+		open,
+		dragging,
+		setOpen(nextOpen) {
+			if (state.hasTag("open") === nextOpen) return;
+			send({ type: nextOpen ? "OPEN" : "CLOSE" });
+		},
+		snapPoints: prop("snapPoints"),
+		swipeDirection,
+		snapPoint,
+		setSnapPoint(snapPoint) {
+			if (context.get("snapPoint") === snapPoint) return;
+			send({
+				type: "SNAP_POINT.SET",
+				snapPoint
+			});
+		},
+		getOpenPercentage() {
+			if (!open || !contentSize) return 0;
+			return clampValue(1 - currentOffset / contentSize, 0, 1);
+		},
+		getSnapPointIndex() {
+			if (snapPoint === null) return -1;
+			return prop("snapPoints").indexOf(snapPoint);
+		},
+		getContentSize() {
+			return contentSize;
+		},
+		getPositionerProps() {
+			return normalize.element({
+				...parts.positioner.attrs,
+				id: getPositionerId(scope),
+				dir: prop("dir"),
+				hidden: closed,
+				"data-state": open ? "open" : "closed",
+				"data-swipe-direction": physicalDirection,
+				style: compact({ pointerEvents: prop("modal") ? void 0 : "none" })
+			});
+		},
+		getContentProps(props = { draggable: true }) {
+			const movementX = isVerticalSwipeDirection(physicalDirection) ? 0 : signedMovement;
+			const movementY = isVerticalSwipeDirection(physicalDirection) ? signedMovement : 0;
+			const rendered = context.get("rendered");
+			return normalize.element({
+				...parts.content.attrs,
+				dir: prop("dir"),
+				id: getContentId(scope),
+				tabIndex: -1,
+				role: prop("role"),
+				"aria-modal": prop("modal"),
+				"aria-labelledby": rendered.title ? getTitleId(scope) : void 0,
+				"aria-describedby": rendered.description ? getDescriptionId(scope) : void 0,
+				hidden: !open,
+				"data-state": open ? "open" : "closed",
+				"data-expanded": resolvedActiveSnapPoint?.offset === 0 ? "" : void 0,
+				"data-swipe-direction": physicalDirection,
+				"data-swiping": dragging || swipingOpen ? "" : void 0,
+				"data-dragging": dragging ? "" : void 0,
+				style: compact({
+					pointerEvents: prop("modal") ? void 0 : "auto",
+					visibility: swipingOpen && dragOffset === null ? "hidden" : void 0,
+					transform: "translate3d(var(--drawer-translate-x, 0px), var(--drawer-translate-y, 0px), 0)",
+					transitionDuration: dragging || swipingOpen ? "0s" : void 0,
+					"--drawer-translate": toPx(translateY),
+					"--drawer-translate-x": toPx(translateX),
+					"--drawer-translate-y": toPx(translateY),
+					"--drawer-snap-point-offset-x": isVerticalSwipeDirection(physicalDirection) ? "0px" : toPx(signedSnapPointOffset),
+					"--drawer-snap-point-offset-y": isVerticalSwipeDirection(physicalDirection) ? toPx(signedSnapPointOffset) : "0px",
+					"--drawer-swipe-movement-x": toPx(movementX),
+					"--drawer-swipe-movement-y": toPx(movementY),
+					"--drawer-swipe-strength": `${swipeStrength}`,
+					willChange: "transform"
+				}),
+				onPointerDown(event) {
+					if (!props.draggable) return;
+					onContentPointerDown(event);
+				}
+			});
+		},
+		getTitleProps() {
+			return normalize.element({
+				...parts.title.attrs,
+				id: getTitleId(scope),
+				dir: prop("dir")
+			});
+		},
+		getDescriptionProps() {
+			return normalize.element({
+				...parts.description.attrs,
+				id: getDescriptionId(scope),
+				dir: prop("dir")
+			});
+		},
+		getTriggerProps() {
+			return normalize.button({
+				...parts.trigger.attrs,
+				id: getTriggerId(scope),
+				type: "button",
+				onClick() {
+					send({ type: open ? "CLOSE" : "OPEN" });
+				}
+			});
+		},
+		getBackdropProps() {
+			return normalize.element({
+				...parts.backdrop.attrs,
+				id: getBackdropId(scope),
+				hidden: !open || swipingOpen && dragOffset === null,
+				"data-state": open ? "open" : "closed",
+				"data-swiping": dragging || swipingOpen ? "" : void 0,
+				style: {
+					willChange: "opacity",
+					"--drawer-swipe-progress": `${swipeProgress}`,
+					"--drawer-swipe-strength": `${swipeStrength}`
+				}
+			});
+		},
+		getGrabberProps() {
+			return normalize.element({
+				...parts.grabber.attrs,
+				id: getGrabberId(scope),
+				onPointerDown(event) {
+					onGrabberPointerDown(event);
+				},
+				style: { touchAction: "none" }
+			});
+		},
+		getGrabberIndicatorProps() {
+			return normalize.element({
+				...parts.grabberIndicator.attrs,
+				id: getGrabberIndicatorId(scope)
+			});
+		},
+		getCloseTriggerProps() {
+			return normalize.button({
+				...parts.closeTrigger.attrs,
+				id: getCloseTriggerId(scope),
+				onClick() {
+					send({ type: "CLOSE" });
+				}
+			});
+		},
+		getSwipeAreaProps(props = {}) {
+			const disabled = props.disabled ?? false;
+			const physicalOpenDirection = resolveSwipeDirection(props.swipeDirection ?? oppositeSwipeDirection[swipeDirection], prop("dir"));
+			return normalize.element({
+				...parts.swipeArea.attrs,
+				id: getSwipeAreaId(scope),
+				role: "presentation",
+				"aria-hidden": true,
+				"data-state": open ? "open" : "closed",
+				"data-swiping": swipingOpen ? "" : void 0,
+				"data-swipe-direction": physicalOpenDirection,
+				"data-disabled": disabled ? "" : void 0,
+				style: {
+					touchAction: isVerticalSwipeDirection(physicalOpenDirection) ? "pan-x" : "pan-y",
+					pointerEvents: disabled || open && !swipingOpen ? "none" : void 0
+				},
+				onPointerDown(event) {
+					if (disabled) return;
+					if (!isLeftClick(event)) return;
+					if (event.pointerType === "touch") return;
+					if (open && !swipingOpen) return;
+					send({
+						type: "SWIPE_AREA.START",
+						point: getEventPoint(event)
+					});
+					if (event.cancelable) event.preventDefault();
+				},
+				onTouchStart(event) {
+					if (disabled) return;
+					if (open && !swipingOpen) return;
+					const touch = event.touches[0];
+					if (!touch) return;
+					send({
+						type: "SWIPE_AREA.START",
+						point: {
+							x: touch.clientX,
+							y: touch.clientY
+						}
+					});
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/machines/drawer/drawer.registry.ts
+var DrawerRegistry = class {
+	constructor() {
+		_defineProperty(this, "elements", /* @__PURE__ */ new Map());
+		_defineProperty(this, "swipingIds", /* @__PURE__ */ new Set());
+		_defineProperty(this, "swipeProgress", /* @__PURE__ */ new Map());
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Set());
+	}
+	notify() {
+		this.listeners.forEach((fn) => fn());
+	}
+	register(id, el) {
+		this.elements.set(id, el);
+		this.notify();
+	}
+	unregister(id) {
+		this.swipingIds.delete(id);
+		this.swipeProgress.delete(id);
+		if (!this.elements.delete(id)) return;
+		this.notify();
+	}
+	setSwiping(id, swiping) {
+		if (!(swiping ? !this.swipingIds.has(id) : this.swipingIds.has(id)) && swiping) return;
+		if (swiping) this.swipingIds.add(id);
+		else {
+			this.swipingIds.delete(id);
+			this.swipeProgress.delete(id);
+		}
+		this.notify();
+	}
+	setSwipeProgress(id, progress) {
+		this.swipeProgress.set(id, progress);
+		this.notify();
+	}
+	getSwipeProgressAfter(id) {
+		const keys = [...this.elements.keys()];
+		const myIndex = keys.indexOf(id);
+		if (myIndex === -1) return 0;
+		for (let i = keys.length - 1; i > myIndex; i -= 1) if (this.swipingIds.has(keys[i])) return this.swipeProgress.get(keys[i]) ?? 0;
+		return 0;
+	}
+	hasSwipingAfter(id) {
+		const keys = [...this.elements.keys()];
+		const myIndex = keys.indexOf(id);
+		if (myIndex === -1) return false;
+		return keys.slice(myIndex + 1).some((key) => this.swipingIds.has(key));
+	}
+	getEntries() {
+		return this.elements;
+	}
+	subscribe(fn) {
+		this.listeners.add(fn);
+		return () => {
+			this.listeners.delete(fn);
+		};
+	}
+};
+const drawerRegistry = new DrawerRegistry();
+//#endregion
+//#region src/machines/drawer/drawer.machine.ts
+const { and } = createGuards();
+const getActiveSnapOffset = (context) => context.get("resolvedActiveSnapPoint")?.offset ?? 0;
+const hasRemSnapPoints = (snapPoints) => snapPoints.some((snapPoint) => typeof snapPoint === "string" && snapPoint.trim().endsWith("rem"));
+const DEFAULT_SNAP_POINTS = [1];
+const machine = createMachine({
+	props({ props, scope }) {
+		const initialFocusEl = props.role === "alertdialog" ? () => getCloseTriggerEl(scope) : void 0;
+		const modal = typeof props.modal === "boolean" ? props.modal : true;
+		const snapPoints = props.snapPoints ?? DEFAULT_SNAP_POINTS;
+		return {
+			modal,
+			trapFocus: modal,
+			preventScroll: modal,
+			closeOnInteractOutside: true,
+			closeOnEscape: true,
+			restoreFocus: true,
+			role: "dialog",
+			initialFocusEl,
+			snapPoints,
+			defaultSnapPoint: props.defaultSnapPoint ?? snapPoints[0] ?? null,
+			swipeDirection: "down",
+			snapToSequentialPoints: false,
+			swipeVelocityThreshold: 500,
+			closeThreshold: .5,
+			preventDragOnScroll: true,
+			...props
+		};
+	},
+	context({ bindable, prop }) {
+		return {
+			dragOffset: bindable(() => ({ defaultValue: null })),
+			snapPoint: bindable(() => ({
+				defaultValue: prop("defaultSnapPoint"),
+				value: prop("snapPoint"),
+				onChange(snapPoint) {
+					return prop("onSnapPointChange")?.({ snapPoint });
+				}
+			})),
+			resolvedActiveSnapPoint: bindable(() => ({ defaultValue: null })),
+			contentSize: bindable(() => ({ defaultValue: null })),
+			viewportSize: bindable(() => ({ defaultValue: 0 })),
+			rootFontSize: bindable(() => ({ defaultValue: 16 })),
+			swipeStrength: bindable(() => ({ defaultValue: 1 })),
+			rendered: bindable(() => ({ defaultValue: {
+				title: true,
+				description: true
+			} }))
+		};
+	},
+	refs({ prop }) {
+		return { swipeSession: new DrawerSwipeSession({ preventDragOnScroll: () => prop("preventDragOnScroll") }) };
+	},
+	computed: {
+		drawerId({ prop, scope }) {
+			return String(prop("id") ?? scope.id);
+		},
+		physicalSwipeDirection({ prop }) {
+			return resolveSwipeDirection(prop("swipeDirection"), prop("dir"));
+		},
+		resolvedSnapPoints({ context, prop }) {
+			const contentSize = context.get("contentSize");
+			const viewportSize = context.get("viewportSize");
+			const rootFontSize = context.get("rootFontSize");
+			if (contentSize === null) return [];
+			return dedupeSnapPoints(prop("snapPoints").map((snapPoint) => resolveSnapPoint(snapPoint, {
+				contentSize,
+				viewportSize,
+				rootFontSize
+			})).filter((point) => point !== null));
+		}
+	},
+	watch({ track, context, prop, action, computed }) {
+		track([
+			() => context.get("snapPoint"),
+			() => context.get("contentSize"),
+			() => context.get("viewportSize"),
+			() => context.get("rootFontSize"),
+			() => prop("snapPoints").join("|")
+		], () => {
+			const snapPoint = context.get("snapPoint");
+			const contentSize = context.get("contentSize");
+			const viewportSize = context.get("viewportSize");
+			const rootFontSize = context.get("rootFontSize");
+			if (snapPoint === null || contentSize === null) {
+				context.set("resolvedActiveSnapPoint", null);
+				return;
+			}
+			const resolvedPoints = computed("resolvedSnapPoints");
+			const matchedPoint = resolvedPoints.find((point) => Object.is(point.value, snapPoint));
+			if (matchedPoint) {
+				context.set("resolvedActiveSnapPoint", matchedPoint);
+				return;
+			}
+			const resolvedActiveSnapPoint = resolveSnapPoint(snapPoint, {
+				contentSize,
+				viewportSize,
+				rootFontSize
+			});
+			if (resolvedActiveSnapPoint) {
+				context.set("resolvedActiveSnapPoint", resolvedActiveSnapPoint);
+				return;
+			}
+			const fallbackPoint = resolvedPoints[0];
+			if (!fallbackPoint) {
+				context.set("resolvedActiveSnapPoint", null);
+				return;
+			}
+			context.set("snapPoint", fallbackPoint.value);
+			context.set("resolvedActiveSnapPoint", fallbackPoint);
+		});
+		track([() => prop("open")], () => {
+			action(["toggleVisibility"]);
+		});
+		track([
+			() => context.get("dragOffset"),
+			() => context.get("contentSize"),
+			() => getActiveSnapOffset(context)
+		], () => {
+			action(["syncDrawerStack"]);
+		});
+	},
+	initialState({ prop }) {
+		return prop("open") || prop("defaultOpen") ? "open" : "closed";
+	},
+	on: { "SNAP_POINT.SET": { actions: ["setSnapPoint"] } },
+	states: {
+		open: {
+			tags: ["open"],
+			entry: [
+				"checkRenderedElements",
+				"setInitialFocus",
+				"deferClearDragOffset"
+			],
+			effects: [
+				"trackDismissableElement",
+				"preventScroll",
+				"trapFocus",
+				"hideContentBelow",
+				"trackPointerMove",
+				"trackSizeMeasurements",
+				"trackNestedDrawerMetrics",
+				"trackDrawerStack"
+			],
+			on: {
+				"CONTROLLED.CLOSE": {
+					target: "closing",
+					actions: ["clearSwipeOpenAnimation", "resetSwipeStrength"]
+				},
+				POINTER_DOWN: { actions: ["setPointerStart"] },
+				POINTER_MOVE: [{
+					guard: "isDragging",
+					actions: ["setDragOffset"]
+				}, {
+					guard: "shouldStartDragging",
+					actions: ["setRegistrySwiping", "setDragOffset"]
+				}],
+				POINTER_UP: [
+					{
+						guard: and("shouldCloseOnSwipe", "isOpenControlled"),
+						actions: [
+							"clearSwipeOpenAnimation",
+							"clearRegistrySwiping",
+							"clearPointerStart",
+							"clearDragOffset",
+							"invokeOnClose"
+						]
+					},
+					{
+						guard: "shouldCloseOnSwipe",
+						target: "closing",
+						actions: [
+							"clearSwipeOpenAnimation",
+							"clearRegistrySwiping",
+							"setDismissSwipeStrength"
+						]
+					},
+					{
+						guard: "isDragging",
+						actions: [
+							"clearRegistrySwiping",
+							"suppressBackdropAnimation",
+							"setSnapSwipeStrength",
+							"setClosestSnapPoint",
+							"clearPointerStart",
+							"clearDragOffset",
+							"clearVelocityTracking"
+						]
+					},
+					{ actions: [
+						"clearRegistrySwiping",
+						"clearPointerStart",
+						"clearDragOffset",
+						"clearVelocityTracking"
+					] }
+				],
+				POINTER_CANCEL: [{
+					guard: "isDragging",
+					actions: [
+						"clearRegistrySwiping",
+						"clearPointerStart",
+						"clearDragOffset",
+						"clearVelocityTracking"
+					]
+				}, { actions: [
+					"clearRegistrySwiping",
+					"clearPointerStart",
+					"clearVelocityTracking"
+				] }],
+				CLOSE: [{
+					guard: "isOpenControlled",
+					actions: ["clearSwipeOpenAnimation", "invokeOnClose"]
+				}, {
+					target: "closing",
+					actions: [
+						"clearSwipeOpenAnimation",
+						"resetSwipeStrength",
+						"invokeOnClose"
+					]
+				}]
+			}
+		},
+		closing: {
+			effects: ["trackExitAnimation", "trackDrawerStack"],
+			on: { ANIMATION_END: {
+				target: "closed",
+				actions: [
+					"invokeOnClose",
+					"clearPointerStart",
+					"clearDragOffset",
+					"clearActiveSnapPoint",
+					"clearResolvedActiveSnapPoint",
+					"clearSizeMeasurements",
+					"clearVelocityTracking"
+				]
+			} }
+		},
+		"swipe-area-dragging": {
+			tags: ["closed"],
+			effects: ["trackSwipeOpenPointerMove"],
+			on: {
+				POINTER_MOVE: {
+					guard: "hasSwipeIntent",
+					target: "swiping-open"
+				},
+				POINTER_UP: {
+					target: "closed",
+					actions: ["clearPointerStart", "clearVelocityTracking"]
+				},
+				POINTER_CANCEL: {
+					target: "closed",
+					actions: ["clearPointerStart", "clearVelocityTracking"]
+				}
+			}
+		},
+		"swiping-open": {
+			tags: ["open"],
+			effects: ["trackSwipeOpenPointerMove", "trackSizeMeasurements"],
+			on: {
+				POINTER_MOVE: { actions: ["setSwipeOpenDragOffset"] },
+				POINTER_UP: [
+					{
+						guard: and("shouldOpenOnSwipe", "isOpenControlled"),
+						actions: ["clearPointerStart", "invokeOnOpen"]
+					},
+					{
+						guard: "shouldOpenOnSwipe",
+						target: "open",
+						actions: ["clearPointerStart", "invokeOnOpen"]
+					},
+					{
+						target: "closed",
+						actions: [
+							"clearPointerStart",
+							"clearDragOffset",
+							"clearSizeMeasurements"
+						]
+					}
+				],
+				POINTER_CANCEL: {
+					target: "closed",
+					actions: [
+						"clearPointerStart",
+						"clearDragOffset",
+						"clearSizeMeasurements",
+						"clearVelocityTracking"
+					]
+				},
+				"CONTROLLED.OPEN": { target: "open" },
+				CLOSE: {
+					target: "closed",
+					actions: [
+						"clearPointerStart",
+						"clearDragOffset",
+						"clearSizeMeasurements"
+					]
+				}
+			}
+		},
+		closed: {
+			tags: ["closed"],
+			on: {
+				"CONTROLLED.OPEN": { target: "open" },
+				OPEN: [{
+					guard: "isOpenControlled",
+					actions: ["invokeOnOpen"]
+				}, {
+					target: "open",
+					actions: ["invokeOnOpen"]
+				}],
+				"SWIPE_AREA.START": {
+					target: "swipe-area-dragging",
+					actions: ["setPointerStart"]
+				}
+			}
+		}
+	},
+	implementations: {
+		guards: {
+			isOpenControlled: ({ prop }) => prop("open") !== void 0,
+			isDragging({ context }) {
+				return context.get("dragOffset") !== null;
+			},
+			shouldStartDragging({ computed, prop, refs, event, scope }) {
+				return refs.get("swipeSession").canStartDrag(event.point, event.target, getContentEl(scope), prop("preventDragOnScroll"), computed("physicalSwipeDirection"));
+			},
+			shouldCloseOnSwipe({ prop, context, computed, refs }) {
+				if (prop("snapToSequentialPoints")) return false;
+				return refs.get("swipeSession").shouldDismissOnRelease(context.get("contentSize"), computed("resolvedSnapPoints"), getActiveSnapOffset(context));
+			},
+			hasSwipeIntent({ refs, computed, event }) {
+				const start = refs.get("swipeSession").getSwipeStart();
+				if (!start || !event.point) return false;
+				return hasOpeningSwipeIntent(start, event.point, computed("physicalSwipeDirection"));
+			},
+			shouldOpenOnSwipe({ context, refs, prop }) {
+				return refs.get("swipeSession").shouldOpenOnRelease(context.get("contentSize"), prop("swipeVelocityThreshold"), prop("closeThreshold"));
+			}
+		},
+		actions: {
+			setInitialFocus({ prop, scope }) {
+				if (prop("trapFocus")) return;
+				raf(() => {
+					getInitialFocus({
+						root: getContentEl(scope),
+						getInitialEl: prop("initialFocusEl")
+					})?.focus({ preventScroll: true });
+				});
+			},
+			checkRenderedElements({ context, scope }) {
+				raf(() => {
+					context.set("rendered", {
+						title: !!getTitleEl(scope),
+						description: !!getDescriptionEl(scope)
+					});
+				});
+			},
+			deferClearDragOffset({ context, refs, scope }) {
+				if (context.get("dragOffset") === null) return;
+				const contentEl = getContentEl(scope);
+				const backdropEl = getBackdropEl(scope);
+				if (contentEl) contentEl.style.setProperty("animation", "none", "important");
+				if (backdropEl) backdropEl.style.setProperty("animation", "none", "important");
+				raf(() => {
+					refs.get("swipeSession").resetDragOffset();
+					context.set("dragOffset", null);
+				});
+			},
+			suppressBackdropAnimation({ scope }) {
+				const backdropEl = getBackdropEl(scope);
+				if (!backdropEl) return;
+				backdropEl.style.setProperty("animation", "none", "important");
+			},
+			clearSwipeOpenAnimation({ scope }) {
+				const contentEl = getContentEl(scope);
+				const backdropEl = getBackdropEl(scope);
+				if (contentEl) contentEl.style.removeProperty("animation");
+				if (backdropEl) backdropEl.style.removeProperty("animation");
+			},
+			invokeOnOpen({ prop }) {
+				prop("onOpenChange")?.({ open: true });
+			},
+			invokeOnClose({ prop }) {
+				prop("onOpenChange")?.({ open: false });
+			},
+			setSnapPoint({ context, event }) {
+				context.set("snapPoint", event.snapPoint);
+			},
+			setPointerStart({ event, refs }) {
+				refs.get("swipeSession").beginSwipe(event.point);
+			},
+			setDragOffset({ context, event, refs, computed }) {
+				const swipeSession = refs.get("swipeSession");
+				const physicalSwipeDirection = event.swipeDirection ?? computed("physicalSwipeDirection");
+				swipeSession.setDragOffset(event.point, getActiveSnapOffset(context), physicalSwipeDirection);
+				context.set("dragOffset", swipeSession.getDragOffset());
+			},
+			setSwipeOpenDragOffset({ context, event, refs, computed }) {
+				const swipeSession = refs.get("swipeSession");
+				const contentSize = context.get("contentSize");
+				if (!contentSize) return;
+				swipeSession.setSwipeOpenOffset(event.point, contentSize, computed("physicalSwipeDirection"));
+				context.set("dragOffset", swipeSession.getDragOffset());
+			},
+			setClosestSnapPoint({ computed, context, refs, prop, send }) {
+				const snapPoints = computed("resolvedSnapPoints");
+				const contentSize = context.get("contentSize");
+				const viewportSize = context.get("viewportSize");
+				const rootFontSize = context.get("rootFontSize");
+				if (!snapPoints.length || contentSize === null) return;
+				const closestSnapPoint = refs.get("swipeSession").resolveSnapPointOnRelease(snapPoints, context.get("resolvedActiveSnapPoint"), prop("snapToSequentialPoints"), contentSize);
+				if (closestSnapPoint === null) {
+					send({ type: "CLOSE" });
+					return;
+				}
+				context.set("snapPoint", closestSnapPoint);
+				const resolved = resolveSnapPoint(closestSnapPoint, {
+					contentSize,
+					viewportSize,
+					rootFontSize
+				});
+				context.set("resolvedActiveSnapPoint", resolved);
+			},
+			clearDragOffset({ context, refs }) {
+				refs.get("swipeSession").resetDragOffset();
+				context.set("dragOffset", null);
+			},
+			clearActiveSnapPoint({ context }) {
+				context.set("snapPoint", context.initial("snapPoint"));
+			},
+			clearSizeMeasurements({ context }) {
+				context.set("contentSize", null);
+				context.set("viewportSize", 0);
+				context.set("rootFontSize", 16);
+			},
+			clearResolvedActiveSnapPoint({ context }) {
+				context.set("resolvedActiveSnapPoint", null);
+			},
+			clearPointerStart({ refs }) {
+				refs.get("swipeSession").clearSwipeStart();
+			},
+			clearVelocityTracking({ refs }) {
+				refs.get("swipeSession").resetVelocity();
+			},
+			setSnapSwipeStrength({ context, refs, computed, prop }) {
+				const swipeSession = refs.get("swipeSession");
+				const snapPoints = computed("resolvedSnapPoints");
+				const contentSize = context.get("contentSize");
+				const closestSnapPoint = swipeSession.resolveSnapPointOnRelease(snapPoints, context.get("resolvedActiveSnapPoint"), prop("snapToSequentialPoints"), contentSize ?? 0);
+				if (closestSnapPoint === null) return;
+				const viewportSize = context.get("viewportSize");
+				const rootFontSize = context.get("rootFontSize");
+				const resolved = resolveSnapPoint(closestSnapPoint, {
+					contentSize: contentSize ?? 0,
+					viewportSize,
+					rootFontSize
+				});
+				const restOffset = getActiveSnapOffset(context);
+				context.set("swipeStrength", swipeSession.getSwipeStrength(resolved?.offset ?? 0, restOffset));
+			},
+			setDismissSwipeStrength({ context, refs }) {
+				const swipeSession = refs.get("swipeSession");
+				const contentSize = context.get("contentSize");
+				const restOffset = getActiveSnapOffset(context);
+				context.set("swipeStrength", swipeSession.getSwipeStrength(contentSize ?? 0, restOffset));
+			},
+			resetSwipeStrength({ context }) {
+				context.set("swipeStrength", 1);
+			},
+			setRegistrySwiping({ computed }) {
+				drawerRegistry.setSwiping(computed("drawerId"), true);
+			},
+			clearRegistrySwiping({ computed }) {
+				drawerRegistry.setSwiping(computed("drawerId"), false);
+			},
+			toggleVisibility({ event, send, prop }) {
+				send({
+					type: prop("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
+					previousEvent: event
+				});
+			},
+			syncDrawerStack({ context, prop, computed }) {
+				const contentSize = context.get("contentSize");
+				if (contentSize === null) return;
+				const dragOffset = context.get("dragOffset");
+				const progress = resolveSwipeProgress(contentSize, dragOffset, getActiveSnapOffset(context));
+				const id = computed("drawerId");
+				if (dragOffset !== null) drawerRegistry.setSwipeProgress(id, progress);
+				const stack = prop("stack");
+				if (!stack) return;
+				stack.setHeight(id, contentSize);
+				stack.setSwipe(id, dragOffset !== null, progress);
+			}
+		},
+		effects: {
+			trackDrawerStack({ context, prop, computed }) {
+				const stack = prop("stack");
+				if (!stack) return;
+				const id = computed("drawerId");
+				stack.register(id);
+				stack.setOpen(id, true);
+				const sync = () => {
+					const contentSize = context.get("contentSize");
+					const dragOffset = context.get("dragOffset");
+					const snapPointOffset = getActiveSnapOffset(context);
+					stack.setHeight(id, contentSize ?? 0);
+					stack.setSwipe(id, dragOffset !== null, resolveSwipeProgress(contentSize, dragOffset, snapPointOffset));
+				};
+				sync();
+				return () => {
+					stack.setSwipe(id, false, 0);
+					stack.setOpen(id, false);
+					stack.unregister(id);
+				};
+			},
+			trackDismissableElement({ scope, prop, send }) {
+				const getContentEl$1 = () => getContentEl(scope);
+				return trackDismissableElement(getContentEl$1, {
+					type: "drawer",
+					defer: true,
+					pointerBlocking: prop("modal"),
+					exclude: [getTriggerEl(scope)],
+					onInteractOutside(event) {
+						prop("onInteractOutside")?.(event);
+						if (!prop("closeOnInteractOutside")) event.preventDefault();
+					},
+					onFocusOutside: prop("onFocusOutside"),
+					onEscapeKeyDown(event) {
+						prop("onEscapeKeyDown")?.(event);
+						if (!prop("closeOnEscape")) event.preventDefault();
+					},
+					onPointerDownOutside: prop("onPointerDownOutside"),
+					onRequestDismiss: prop("onRequestDismiss"),
+					onDismiss() {
+						send({
+							type: "CLOSE",
+							src: "interact-outside"
+						});
+					}
+				});
+			},
+			preventScroll({ scope, prop }) {
+				if (!prop("preventScroll")) return;
+				return preventBodyScroll(scope.getDoc());
+			},
+			trapFocus({ scope, prop }) {
+				if (!prop("trapFocus")) return;
+				const contentEl = () => getContentEl(scope);
+				return trapFocus(contentEl, {
+					preventScroll: true,
+					returnFocusOnDeactivate: !!prop("restoreFocus"),
+					initialFocus: prop("initialFocusEl"),
+					setReturnFocus: (el) => prop("finalFocusEl")?.() ?? getTriggerEl(scope) ?? el,
+					getShadowRoot: true
+				});
+			},
+			hideContentBelow({ scope, prop }) {
+				if (!prop("modal")) return;
+				const getElements = () => [getContentEl(scope)];
+				return ariaHidden(getElements, { defer: true });
+			},
+			trackPointerMove({ scope, send, refs, computed }) {
+				return refs.get("swipeSession").bindDragTracking({
+					getDoc: () => scope.getDoc(),
+					getContentEl: () => getContentEl(scope),
+					getSwipeAreaEl: () => getSwipeAreaEl(scope),
+					swipeDirection: computed("physicalSwipeDirection"),
+					onMove(details) {
+						send({
+							type: "POINTER_MOVE",
+							...details
+						});
+					},
+					onEnd(details) {
+						send({
+							type: "POINTER_UP",
+							...details
+						});
+					},
+					onCancel() {
+						send({ type: "POINTER_CANCEL" });
+					}
+				});
+			},
+			trackSizeMeasurements({ context, scope, computed, prop }) {
+				const contentEl = getContentEl(scope);
+				if (!contentEl) return;
+				const html = scope.getDoc().documentElement;
+				const shouldMeasureRootFontSize = hasRemSnapPoints(prop("snapPoints"));
+				const updateSize = () => {
+					const direction = computed("physicalSwipeDirection");
+					const rect = contentEl.getBoundingClientRect();
+					const viewportSize = isVerticalSwipeDirection(direction) ? html.clientHeight : html.clientWidth;
+					context.set("contentSize", getSwipeDirectionSize(rect, direction));
+					context.set("viewportSize", viewportSize);
+					if (shouldMeasureRootFontSize) {
+						const rootFontSize = Number.parseFloat(getComputedStyle(html).fontSize);
+						if (Number.isFinite(rootFontSize)) context.set("rootFontSize", rootFontSize);
+					}
+				};
+				updateSize();
+				const cleanups = [resizeObserverBorderBox.observe(contentEl, updateSize), addDomEvent(scope.getWin(), "resize", updateSize)];
+				return () => {
+					cleanups.forEach((cleanup) => cleanup?.());
+				};
+			},
+			trackNestedDrawerMetrics({ scope, computed }) {
+				const contentEl = getContentEl(scope);
+				if (!contentEl) return;
+				const id = computed("drawerId");
+				drawerRegistry.register(id, contentEl);
+				const sync = () => {
+					const entries = [...drawerRegistry.getEntries().entries()];
+					const myIndex = entries.findIndex(([entryId]) => entryId === id);
+					if (myIndex === -1) return;
+					const nestedCount = entries.length - 1 - myIndex;
+					const frontmostHeight = (entries[entries.length - 1]?.[1])?.getBoundingClientRect().height ?? 0;
+					const myHeight = contentEl.getBoundingClientRect().height;
+					contentEl.style.setProperty("--nested-drawers", `${nestedCount}`);
+					contentEl.style.setProperty("--drawer-height", `${myHeight}px`);
+					contentEl.style.setProperty("--drawer-frontmost-height", `${frontmostHeight}px`);
+					if (nestedCount > 0 && frontmostHeight > 0) contentEl.setAttribute("data-nested-drawer-open", "");
+					else if (nestedCount === 0) contentEl.removeAttribute("data-nested-drawer-open");
+					if (drawerRegistry.hasSwipingAfter(id)) contentEl.setAttribute("data-nested-drawer-swiping", "");
+					else contentEl.removeAttribute("data-nested-drawer-swiping");
+				};
+				sync();
+				const cleanups = [
+					drawerRegistry.subscribe(sync),
+					resizeObserverBorderBox.observe(contentEl, () => drawerRegistry.notify()),
+					addDomEvent(scope.getWin(), "resize", () => drawerRegistry.notify())
+				];
+				return () => {
+					cleanups.forEach((cleanup) => cleanup?.());
+					contentEl.removeAttribute("data-nested-drawer-open");
+					contentEl.removeAttribute("data-nested-drawer-swiping");
+					contentEl.style.setProperty("--nested-drawers", "0");
+					contentEl.style.removeProperty("--drawer-frontmost-height");
+					drawerRegistry.unregister(id);
+				};
+			},
+			trackSwipeOpenPointerMove({ scope, send, refs, computed }) {
+				return refs.get("swipeSession").bindSwipeOpenTracking({
+					getDoc: () => scope.getDoc(),
+					getContentEl: () => getContentEl(scope),
+					getSwipeAreaEl: () => getSwipeAreaEl(scope),
+					swipeDirection: computed("physicalSwipeDirection"),
+					onMove(details) {
+						send({
+							type: "POINTER_MOVE",
+							...details
+						});
+					},
+					onEnd(details) {
+						send({
+							type: "POINTER_UP",
+							...details
+						});
+					},
+					onCancel() {
+						send({ type: "POINTER_CANCEL" });
+					}
+				});
+			},
+			trackExitAnimation({ send, scope }) {
+				const contentEl = getContentEl(scope);
+				if (!contentEl) return;
+				return addDomEvent(contentEl, "exitcomplete", () => {
+					send({ type: "ANIMATION_END" });
+				});
+			}
+		}
+	}
+});
+//#endregion
+//#region src/machines/drawer/drawer.props.ts
+const props = createProps()([
+	"id",
+	"ids",
+	"dir",
+	"modal",
+	"initialFocusEl",
+	"finalFocusEl",
+	"open",
+	"defaultOpen",
+	"getRootNode",
+	"snapPoints",
+	"swipeDirection",
+	"snapToSequentialPoints",
+	"swipeVelocityThreshold",
+	"closeThreshold",
+	"preventDragOnScroll",
+	"closeOnEscape",
+	"closeOnInteractOutside",
+	"onEscapeKeyDown",
+	"onFocusOutside",
+	"onInteractOutside",
+	"onOpenChange",
+	"onPointerDownOutside",
+	"onRequestDismiss",
+	"preventScroll",
+	"restoreFocus",
+	"role",
+	"trapFocus",
+	"defaultSnapPoint",
+	"snapPoint",
+	"onSnapPointChange",
+	"stack"
+]);
+const splitProps = createSplitProps(props);
+//#endregion
+//#region src/machines/drawer/drawer.stack.ts
+function resolveSnapshot(entries) {
+	let openCount = 0;
+	let frontmostHeight = 0;
+	let swipeProgress = 0;
+	let frontmostOrder = -1;
+	entries.forEach((entry) => {
+		if (!entry.open) return;
+		openCount += 1;
+		if (entry.order < frontmostOrder) return;
+		frontmostOrder = entry.order;
+		frontmostHeight = entry.height > 0 ? entry.height : 0;
+		swipeProgress = entry.swiping ? clampValue(entry.swipeProgress, 0, 1) : 0;
+	});
+	return {
+		active: openCount > 0,
+		openCount,
+		swipeProgress,
+		frontmostHeight
+	};
+}
+function createStack() {
+	const entries = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let order = 0;
+	let pendingNotify = false;
+	let snapshot = Object.freeze({
+		active: false,
+		openCount: 0,
+		swipeProgress: 0,
+		frontmostHeight: 0
+	});
+	const scheduleNotify = () => {
+		if (pendingNotify) return;
+		pendingNotify = true;
+		queueMicrotask(() => {
+			pendingNotify = false;
+			listeners.forEach((listener) => listener());
+		});
+	};
+	const notify = () => {
+		const nextSnapshot = resolveSnapshot(entries);
+		if (snapshot.active === nextSnapshot.active && snapshot.openCount === nextSnapshot.openCount && snapshot.swipeProgress === nextSnapshot.swipeProgress && snapshot.frontmostHeight === nextSnapshot.frontmostHeight) return;
+		snapshot = Object.freeze(nextSnapshot);
+		scheduleNotify();
+	};
+	const ensureEntry = (id) => {
+		let entry = entries.get(id);
+		if (!entry) {
+			entry = {
+				order: ++order,
+				open: false,
+				height: 0,
+				swiping: false,
+				swipeProgress: 0
+			};
+			entries.set(id, entry);
+		}
+		return entry;
+	};
+	return {
+		getSnapshot() {
+			return snapshot;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		register(id) {
+			ensureEntry(id);
+			notify();
+		},
+		unregister(id) {
+			if (!entries.delete(id)) return;
+			notify();
+		},
+		setOpen(id, open) {
+			const entry = ensureEntry(id);
+			if (entry.open === open) return;
+			entry.open = open;
+			if (!open) {
+				entry.swiping = false;
+				entry.swipeProgress = 0;
+			}
+			notify();
+		},
+		setHeight(id, height) {
+			const entry = ensureEntry(id);
+			const nextHeight = Number.isFinite(height) && height > 0 ? height : 0;
+			if (entry.height === nextHeight) return;
+			entry.height = nextHeight;
+			notify();
+		},
+		setSwipe(id, swiping, progress) {
+			const entry = ensureEntry(id);
+			const nextProgress = swiping ? clampValue(Number.isFinite(progress) ? progress : 0, 0, 1) : 0;
+			if (entry.swiping === swiping && entry.swipeProgress === nextProgress) return;
+			entry.swiping = swiping;
+			entry.swipeProgress = nextProgress;
+			notify();
+		}
+	};
+}
+function connectStack(snapshot, normalize) {
+	const getIndentProps = () => {
+		return normalize.element({
+			"data-active": snapshot.active ? "" : void 0,
+			"data-inactive": snapshot.active ? void 0 : "",
+			style: {
+				"--drawer-swipe-progress": `${clampValue(snapshot.swipeProgress, 0, 1)}`,
+				"--drawer-frontmost-height": snapshot.frontmostHeight > 0 ? `${snapshot.frontmostHeight}px` : void 0
+			}
+		});
+	};
+	return {
+		getIndentProps,
+		getIndentBackgroundProps: getIndentProps
+	};
+}
+//#endregion
+export { anatomy, connect, connectStack, createStack, machine, props, splitProps };