@youcan/celeste 0.15.0 → 0.17.0

package/dist/es/chunks/drawer-content.js

@@ -0,0 +1,1193 @@
+import { t as clsx } from "./clsx.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { f as reactiveOmit } from "./dist.js";
+import { d as useResizeObserver, s as useEventListener } from "./dist2.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as DismissableLayer_default } from "./DismissableLayer.js";
+import { n as focus, r as useBodyScrollLock, t as FocusScope_default } from "./FocusScope.js";
+import { t as useEmitAsProps } from "./useEmitAsProps.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { t as useForwardPropsEmits } from "./useForwardPropsEmits.js";
+import { t as useHideOthers } from "./useHideOthers.js";
+import { t as Presence_default } from "./Presence.js";
+import { t as Teleport_default } from "./Teleport.js";
+import { a as getDisplacement, i as computeSwipeReleaseScalar, n as injectDrawerRootContext, o as getElementTransform, r as DRAWER_CSS_VARS, s as registerDrawerCssProperties } from "./DrawerRoot.js";
+import { computed, createBlock, createCommentVNode, createVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, onMounted, onUnmounted, openBlock, ref, renderSlot, toValue, unref, watch, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/composables/useDrawerSnapPoints.js
+var SNAP_VELOCITY_THRESHOLD = .5;
+var SNAP_VELOCITY_MULTIPLIER = 300;
+var MAX_SNAP_VELOCITY = 4;
+var FAST_SWIPE_VELOCITY = .5;
+function parseSnapPoint(value, viewportHeight, rootFontSize) {
+	let result = null;
+	if (typeof value === "number") result = value >= 0 && value <= 1 ? value * viewportHeight : value;
+	else if (value.endsWith("rem")) result = Number.parseFloat(value) * rootFontSize;
+	else if (value.endsWith("px")) result = Number.parseFloat(value);
+	if (result == null || !Number.isFinite(result) || result < 0) return null;
+	return Math.round(result);
+}
+function useDrawerSnapPoints(options) {
+	const { snapPoints, activeSnapPoint, popupHeight, viewportRef, onSnapPointChange } = options;
+	const viewportHeight = ref(typeof window !== "undefined" ? window.innerHeight : 0);
+	const rootFontSize = ref(typeof document !== "undefined" ? Number.parseFloat(getComputedStyle(document.documentElement).fontSize) || 16 : 16);
+	if (typeof window !== "undefined") useEventListener(window, "resize", () => {
+		viewportHeight.value = window.innerHeight;
+	});
+	const resolvedSnapPoints = computed(() => {
+		const points = snapPoints.value;
+		if (!points || points.length === 0) return [];
+		const vh = viewportHeight.value;
+		const fs = rootFontSize.value;
+		const ph = popupHeight.value;
+		const resolved = [];
+		for (const pt of points) {
+			const height = parseSnapPoint(pt, vh, fs);
+			if (height == null) continue;
+			if (resolved.some((r) => Math.abs(r.height - height) <= 1)) continue;
+			const clampedHeight = Math.min(height, Math.min(ph, vh));
+			resolved.push({
+				value: pt,
+				height: clampedHeight,
+				offset: Math.max(0, ph - clampedHeight)
+			});
+		}
+		return resolved.sort((a, b) => a.height - b.height);
+	});
+	/**
+	* Resolve the currently-active snap point to its resolved entry, matching by
+	* raw value OR by parsed-height equivalence. This lets a controlled drawer use
+	* interchangeable representations (`'16rem'` vs `256`, `0.5` vs `400`) without
+	* the release math falling back to offset `0` and jumping to the wrong target.
+	*/
+	function findActiveResolvedPoint() {
+		if (!activeSnapPoint.value || resolvedSnapPoints.value.length === 0) return void 0;
+		const activeHeight = parseSnapPoint(activeSnapPoint.value, viewportHeight.value, rootFontSize.value);
+		return resolvedSnapPoints.value.find((r) => r.value === activeSnapPoint.value || activeHeight != null && Math.abs(r.height - activeHeight) <= 1);
+	}
+	const activeSnapPointOffset = computed(() => findActiveResolvedPoint()?.offset ?? null);
+	/**
+	* BaseUI-parity snap release math (ported from `DrawerViewport.tsx` lines ~577-714).
+	*
+	* Takes a **dismiss-signed** drag delta (positive = dismiss direction, negative =
+	* open direction) and the raw velocity vector. Computes a velocity-boosted target
+	* offset, then either dismisses, snaps to the closest point, or (in sequential
+	* mode) advances one step based on physical crossing + fast-swipe velocity.
+	*/
+	function snapToNearest(dragDelta, velocity, direction, sequential) {
+		const points = resolvedSnapPoints.value;
+		if (points.length === 0) return;
+		const ph = popupHeight.value;
+		const axisVel = direction === "up" || direction === "down" ? velocity.y : velocity.x;
+		const velSigned = direction === "up" || direction === "left" ? -axisVel : axisVel;
+		const activePoint = findActiveResolvedPoint();
+		const currentOffset = activePoint?.offset ?? 0;
+		const dragTargetOffset = Math.max(0, Math.min(ph, currentOffset + dragDelta));
+		let targetOffset = dragTargetOffset;
+		if (Math.abs(velSigned) >= SNAP_VELOCITY_THRESHOLD) targetOffset = dragTargetOffset + Math.max(-4, Math.min(MAX_SNAP_VELOCITY, velSigned)) * SNAP_VELOCITY_MULTIPLIER;
+		let closest = points[0];
+		let closestDist = Math.abs(targetOffset - closest.offset);
+		for (const p of points) {
+			const d = Math.abs(targetOffset - p.offset);
+			if (d < closestDist) {
+				closest = p;
+				closestDist = d;
+			}
+		}
+		if (Math.abs(targetOffset - ph) < closestDist) {
+			onSnapPointChange(null);
+			return;
+		}
+		if (sequential) {
+			const sorted = [...points].sort((a, b) => a.offset - b.offset);
+			const currentIdx = activePoint ? sorted.indexOf(activePoint) : -1;
+			if (currentIdx < 0) {
+				onSnapPointChange(closest.value);
+				return;
+			}
+			const dragDir = Math.sign(dragDelta);
+			const shouldAdvance = Math.sign(velSigned) === dragDir && Math.abs(velSigned) >= FAST_SWIPE_VELOCITY;
+			const adjacent = sorted[Math.max(0, Math.min(sorted.length - 1, currentIdx + dragDir))];
+			if (shouldAdvance) {
+				onSnapPointChange(adjacent.value);
+				return;
+			}
+			const crossed = dragDir > 0 ? targetOffset > adjacent.offset : targetOffset < adjacent.offset;
+			onSnapPointChange(crossed ? adjacent.value : activeSnapPoint.value ?? closest.value);
+			return;
+		}
+		onSnapPointChange(closest.value);
+	}
+	return {
+		resolvedSnapPoints,
+		activeSnapPointOffset,
+		viewportHeight,
+		snapToNearest
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/composables/useSwipeDismiss.js
+var DEFAULT_SWIPE_THRESHOLD = 40;
+var REVERSE_CANCEL_THRESHOLD = 10;
+var MIN_DRAG_THRESHOLD = 1;
+var AXIS_LOCK_SLOP = 6;
+var AXIS_LOCK_BIAS = 2;
+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 findScrollableAncestor(el, axis) {
+	if (!el || el === document.body) return null;
+	const style = window.getComputedStyle(el);
+	const overflow = axis === "vertical" ? style.overflowY : style.overflowX;
+	if ((overflow === "auto" || overflow === "scroll") && (axis === "vertical" ? el.scrollHeight > el.clientHeight : el.scrollWidth > el.clientWidth)) return el;
+	return findScrollableAncestor(el.parentElement, axis);
+}
+/**
+* Returns whether the user can start a swipe dismiss from a scrollable element
+* based on the scroll position and drag direction.
+* Ported from BaseUI `useSwipeDismiss.ts:canSwipeFromScrollEdgeOnPendingMove`.
+*
+* Returns:
+*   true  → swipe is allowed (scroll is at the relevant edge)
+*   false → swipe is blocked (user is scrolling, not dismissing)
+*   null  → the drag is not along a recognized axis; caller should fall through
+*/
+function canSwipeFromScrollEdge(scrollTarget, deltaX, deltaY, flags) {
+	const absDx = Math.abs(deltaX);
+	const absDy = Math.abs(deltaY);
+	if (flags.hasVertical && deltaY !== 0 && (!flags.hasHorizontal || absDy >= absDx)) {
+		const maxScrollTop = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+		const atTop = scrollTarget.scrollTop <= 0;
+		const atBottom = scrollTarget.scrollTop >= maxScrollTop;
+		const movingDown = deltaY > 0;
+		const movingUp = deltaY < 0;
+		const canSwipeDown = movingDown && atTop && flags.allowDown;
+		const canSwipeUp = movingUp && atBottom && flags.allowUp;
+		return canSwipeDown || canSwipeUp;
+	}
+	if (flags.hasHorizontal && deltaX !== 0 && (!flags.hasVertical || absDx > absDy)) {
+		const maxScrollLeft = Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth);
+		const atLeft = scrollTarget.scrollLeft <= 0;
+		const atRight = scrollTarget.scrollLeft >= maxScrollLeft;
+		const movingRight = deltaX > 0;
+		const movingLeft = deltaX < 0;
+		const canSwipeRight = movingRight && atLeft && flags.allowRight;
+		const canSwipeLeft = movingLeft && atRight && flags.allowLeft;
+		return canSwipeRight || canSwipeLeft;
+	}
+	return null;
+}
+function useSwipeDismiss(options) {
+	const { elementRef, directions, movementCssVars, swipeThreshold: swipeThresholdProp, canStart, onDismiss, onProgress, onCancel, onSwipeStart, onRelease, onSwipingChange } = options;
+	const hasVertical = computed(() => toValue(directions).includes("up") || toValue(directions).includes("down"));
+	const hasHorizontal = computed(() => toValue(directions).includes("left") || toValue(directions).includes("right"));
+	const allowUp = computed(() => toValue(directions).includes("up"));
+	const allowDown = computed(() => toValue(directions).includes("down"));
+	const allowLeft = computed(() => toValue(directions).includes("left"));
+	const allowRight = computed(() => toValue(directions).includes("right"));
+	const drawerAxis = computed(() => {
+		if (hasVertical.value === hasHorizontal.value) return null;
+		return hasVertical.value ? "vertical" : "horizontal";
+	});
+	const isSwiping = ref(false);
+	const swipeDirection = ref(void 0);
+	const dragOffset = ref({
+		x: 0,
+		y: 0
+	});
+	let dragStartPos = {
+		x: 0,
+		y: 0
+	};
+	let intendedDirection;
+	let maxDisplacement = 0;
+	let cancelledSwipe = false;
+	let isFirstMove = false;
+	let pendingSwipe = false;
+	let pendingSwipeStartPos = null;
+	let swipeFromScrollable = false;
+	let scrollableAncestor = null;
+	let crossAxisScrollable = null;
+	let drawerAxisAttributed = false;
+	let preserveNativeCrossAxisScroll = false;
+	let elementSize = {
+		width: 0,
+		height: 0
+	};
+	let swipeProgress = 0;
+	let lastDragSample = null;
+	let lastVelocity = {
+		x: 0,
+		y: 0
+	};
+	let lockedAxis = null;
+	let activePointerId = null;
+	let pointerStarted = false;
+	function getThreshold(el, dir) {
+		if (typeof swipeThresholdProp === "function") return Math.max(0, swipeThresholdProp({
+			element: el,
+			direction: dir
+		}));
+		return typeof swipeThresholdProp === "number" ? swipeThresholdProp : DEFAULT_SWIPE_THRESHOLD;
+	}
+	function setSwiping(next) {
+		if (isSwiping.value === next) return;
+		isSwiping.value = next;
+		onSwipingChange?.(next);
+	}
+	function recordSample(offset, time) {
+		if (lastDragSample && time > lastDragSample.time) {
+			const dt = Math.max(time - lastDragSample.time, MIN_RELEASE_VELOCITY_DURATION_MS);
+			lastVelocity = {
+				x: (offset.x - lastDragSample.x) / dt,
+				y: (offset.y - lastDragSample.y) / dt
+			};
+		}
+		lastDragSample = {
+			x: offset.x,
+			y: offset.y,
+			time
+		};
+	}
+	function setCssVars(el, x, y) {
+		el.style.setProperty(movementCssVars.x, `${x}px`);
+		el.style.setProperty(movementCssVars.y, `${y}px`);
+	}
+	function clearCssVars(el) {
+		el.style.setProperty(movementCssVars.x, "0px");
+		el.style.setProperty(movementCssVars.y, "0px");
+	}
+	/**
+	* Clears the per-gesture tracking state. Deliberately leaves the pointer
+	* identity and the touch scroll-guard flags alone, so it is safe to call at
+	* the start of a gesture as well as at the end of one.
+	*/
+	function resetGestureState() {
+		setSwiping(false);
+		swipeDirection.value = void 0;
+		dragOffset.value = {
+			x: 0,
+			y: 0
+		};
+		dragStartPos = {
+			x: 0,
+			y: 0
+		};
+		intendedDirection = void 0;
+		maxDisplacement = 0;
+		cancelledSwipe = false;
+		isFirstMove = false;
+		pendingSwipe = false;
+		pendingSwipeStartPos = null;
+		elementSize = {
+			width: 0,
+			height: 0
+		};
+		swipeProgress = 0;
+		lastDragSample = null;
+		lastVelocity = {
+			x: 0,
+			y: 0
+		};
+		lockedAxis = null;
+	}
+	function reset() {
+		resetGestureState();
+		swipeFromScrollable = false;
+		scrollableAncestor = null;
+		crossAxisScrollable = null;
+		drawerAxisAttributed = false;
+		preserveNativeCrossAxisScroll = false;
+		activePointerId = null;
+		pointerStarted = false;
+	}
+	function startSwipe(el, pos) {
+		resetGestureState();
+		getElementTransform(el);
+		dragStartPos = pos;
+		pendingSwipeStartPos = pos;
+		elementSize = {
+			width: el.offsetWidth,
+			height: el.offsetHeight
+		};
+		isFirstMove = true;
+		pendingSwipe = true;
+	}
+	/**
+	* Applies sqrt-damping to any axis moving in a disallowed direction.
+	* Axes moving in an allowed direction pass through linearly.
+	* Ported from BaseUI `useSwipeDismiss.ts:applyDirectionalDamping`.
+	*/
+	function applyDirectionalDamping(deltaX, deltaY) {
+		const exponent = (value) => value >= 0 ? value ** .5 : -(Math.abs(value) ** .5);
+		const dampAxis = (delta, allowNegative, allowPositive) => {
+			if (!allowNegative && delta < 0) return exponent(delta);
+			if (!allowPositive && delta > 0) return exponent(delta);
+			return delta;
+		};
+		return {
+			x: hasHorizontal.value ? dampAxis(deltaX, allowLeft.value, allowRight.value) : exponent(deltaX),
+			y: hasVertical.value ? dampAxis(deltaY, allowUp.value, allowDown.value) : exponent(deltaY)
+		};
+	}
+	/**
+	* Arbitrates a touchmove between the drawer swipe and a native scroll on the
+	* cross axis. Returns `true` when the move must be left alone — the cross axis
+	* already won the gesture, or neither axis has passed the slop yet.
+	*/
+	function shouldYieldTouchMove(e, pos) {
+		if (preserveNativeCrossAxisScroll) return true;
+		if (drawerAxisAttributed || !crossAxisScrollable || !drawerAxis.value) return false;
+		if (!e.cancelable) {
+			preserveNativeCrossAxisScroll = true;
+			return true;
+		}
+		const isVerticalDrawerAxis = drawerAxis.value === "vertical";
+		const drawerAxisDelta = isVerticalDrawerAxis ? pos.y - dragStartPos.y : pos.x - dragStartPos.x;
+		const crossAxisDelta = isVerticalDrawerAxis ? pos.x - dragStartPos.x : pos.y - dragStartPos.y;
+		const absDrawerAxisDelta = Math.abs(drawerAxisDelta);
+		const absCrossAxisDelta = Math.abs(crossAxisDelta);
+		if (absCrossAxisDelta >= AXIS_LOCK_SLOP && absCrossAxisDelta > absDrawerAxisDelta + AXIS_LOCK_BIAS) {
+			preserveNativeCrossAxisScroll = true;
+			return true;
+		}
+		if (absDrawerAxisDelta >= AXIS_LOCK_SLOP) {
+			drawerAxisAttributed = true;
+			return false;
+		}
+		return true;
+	}
+	function processMove(el, pos, time) {
+		const rawDx = pos.x - dragStartPos.x;
+		const rawDy = pos.y - dragStartPos.y;
+		if (isFirstMove) {
+			isFirstMove = false;
+			const absX = Math.abs(rawDx);
+			const absY = Math.abs(rawDy);
+			if (hasVertical.value && hasHorizontal.value) lockedAxis = absX > absY ? "horizontal" : "vertical";
+			else if (hasVertical.value) lockedAxis = "vertical";
+			else lockedAxis = "horizontal";
+		}
+		const dx = lockedAxis === "vertical" ? 0 : rawDx;
+		const dy = lockedAxis === "horizontal" ? 0 : rawDy;
+		const dir = toValue(directions).find((d) => getDisplacement(d, dx, dy) > 0);
+		if (pendingSwipe && pendingSwipeStartPos) {
+			if (Math.max(Math.abs(dx), Math.abs(dy)) < MIN_DRAG_THRESHOLD) return;
+			pendingSwipe = false;
+			setSwiping(true);
+			onSwipeStart?.();
+		}
+		if (!isSwiping.value) return;
+		if (!intendedDirection && dir) {
+			intendedDirection = dir;
+			swipeDirection.value = dir;
+			maxDisplacement = getDisplacement(dir, dx, dy);
+		}
+		const currentDir = intendedDirection;
+		if (currentDir && !cancelledSwipe) {
+			const displacement = getDisplacement(currentDir, dx, dy);
+			maxDisplacement = Math.max(maxDisplacement, displacement);
+			if (maxDisplacement > DEFAULT_SWIPE_THRESHOLD / 2 && maxDisplacement - displacement > REVERSE_CANCEL_THRESHOLD) cancelledSwipe = true;
+		}
+		const damped = applyDirectionalDamping(dx, dy);
+		dragOffset.value = {
+			x: damped.x,
+			y: damped.y
+		};
+		setCssVars(el, damped.x, damped.y);
+		recordSample({
+			x: damped.x,
+			y: damped.y
+		}, time);
+		const currentEl = elementRef.value;
+		const progressDir = currentDir ?? toValue(directions)[0];
+		if (currentEl && progressDir) {
+			const dim = progressDir === "up" || progressDir === "down" ? elementSize.height || currentEl.offsetHeight : elementSize.width || currentEl.offsetWidth;
+			const threshold = getThreshold(currentEl, progressDir);
+			const p = Math.min(1, Math.max(0, getDisplacement(progressDir, dx, dy) / (dim + threshold)));
+			if (p !== swipeProgress) {
+				swipeProgress = p;
+				onProgress?.(p, {
+					deltaX: damped.x,
+					deltaY: damped.y,
+					direction: currentDir
+				});
+			}
+		}
+	}
+	function finishSwipe(el) {
+		if (!isSwiping.value) {
+			reset();
+			return;
+		}
+		const displacement = getDisplacement(intendedDirection ?? toValue(directions)[0], dragOffset.value.x, dragOffset.value.y);
+		const threshold = getThreshold(el, intendedDirection ?? toValue(directions)[0]);
+		const now = performance.now();
+		const velocity = (lastDragSample ? now - lastDragSample.time : Infinity) > MAX_RELEASE_VELOCITY_AGE_MS ? {
+			x: 0,
+			y: 0
+		} : lastVelocity;
+		if (!(onRelease?.(velocity) === true)) {
+			const velInDirection = getDisplacement(intendedDirection ?? toValue(directions)[0], velocity.x, velocity.y);
+			if (!cancelledSwipe && (displacement >= threshold || velInDirection > .3)) {
+				el.setAttribute("data-swipe-dismissed", "");
+				onDismiss?.();
+			} else {
+				clearCssVars(el);
+				onCancel?.();
+			}
+		}
+		reset();
+	}
+	function onPointerDown(e) {
+		if (!toValue(options.enabled)) return;
+		if (e.pointerType === "touch") return;
+		if (e.button !== 0) return;
+		if (canStart && !canStart()) return;
+		if (e.target?.closest(DEFAULT_IGNORE_SELECTOR)) return;
+		const el = elementRef.value;
+		if (!el) return;
+		startSwipe(el, {
+			x: e.clientX,
+			y: e.clientY
+		});
+		activePointerId = e.pointerId;
+		pointerStarted = true;
+		try {
+			el.setPointerCapture(e.pointerId);
+		} catch {}
+	}
+	function onPointerMove(e) {
+		if (!pointerStarted || e.pointerId !== activePointerId) return;
+		const el = elementRef.value;
+		if (!el) return;
+		if ((e.buttons & 1) === 0) {
+			finishSwipe(el);
+			return;
+		}
+		processMove(el, {
+			x: e.clientX,
+			y: e.clientY
+		}, e.timeStamp);
+	}
+	function onPointerUp(e) {
+		if (!pointerStarted || e.pointerId !== activePointerId) return;
+		const el = elementRef.value;
+		if (!el) {
+			reset();
+			return;
+		}
+		finishSwipe(el);
+	}
+	/**
+	* Ends an in-flight pointer drag that can no longer be tracked — pointer
+	* capture was lost, or the window lost focus mid-drag (which is what happens
+	* when the release lands over another application). The drawer settles from
+	* wherever it was last dragged to.
+	*/
+	function onPointerInterrupted() {
+		if (!pointerStarted) return;
+		const el = elementRef.value;
+		if (!el) {
+			reset();
+			return;
+		}
+		finishSwipe(el);
+	}
+	function onTouchStart(e) {
+		if (!toValue(options.enabled)) return;
+		if (canStart && !canStart()) return;
+		const target = e.target;
+		if (target?.closest(DEFAULT_IGNORE_SELECTOR)) return;
+		const el = elementRef.value;
+		if (!el) return;
+		crossAxisScrollable = null;
+		drawerAxisAttributed = false;
+		preserveNativeCrossAxisScroll = false;
+		if (!options.ignoreScrollableAncestors) {
+			const scrollable = findScrollableAncestor(target, hasVertical.value ? "vertical" : "horizontal");
+			if (scrollable) {
+				swipeFromScrollable = true;
+				scrollableAncestor = scrollable;
+			}
+		}
+		if (drawerAxis.value) crossAxisScrollable = findScrollableAncestor(target, drawerAxis.value === "vertical" ? "horizontal" : "vertical");
+		const t = e.touches[0];
+		if (!t) return;
+		startSwipe(el, {
+			x: t.clientX,
+			y: t.clientY
+		});
+	}
+	function onTouchMove(e) {
+		const el = elementRef.value;
+		if (!el || !pendingSwipe && !isSwiping.value) return;
+		const t = e.touches[0];
+		if (!t) return;
+		const pos = {
+			x: t.clientX,
+			y: t.clientY
+		};
+		if (shouldYieldTouchMove(e, pos)) return;
+		if (swipeFromScrollable && pendingSwipe && scrollableAncestor) {
+			const dx = pos.x - dragStartPos.x;
+			const dy = pos.y - dragStartPos.y;
+			const allowed = canSwipeFromScrollEdge(scrollableAncestor, dx, dy, {
+				hasVertical: hasVertical.value,
+				hasHorizontal: hasHorizontal.value,
+				allowUp: allowUp.value,
+				allowDown: allowDown.value,
+				allowLeft: allowLeft.value,
+				allowRight: allowRight.value
+			});
+			if (allowed === false) {
+				reset();
+				return;
+			}
+			if (allowed === true) {
+				swipeFromScrollable = false;
+				scrollableAncestor = null;
+			}
+		}
+		const wasSwiping = isSwiping.value;
+		processMove(el, pos, e.timeStamp);
+		if (wasSwiping || isSwiping.value) e.preventDefault();
+	}
+	function onTouchEnd() {
+		const el = elementRef.value;
+		if (!el) return;
+		finishSwipe(el);
+	}
+	const cleanups = [];
+	watch(() => elementRef.value, (el) => {
+		cleanups.forEach((fn) => fn());
+		cleanups.length = 0;
+		if (!el) return;
+		const doc = el.ownerDocument;
+		const win = doc.defaultView;
+		cleanups.push(useEventListener(el, "pointerdown", onPointerDown), useEventListener(el, "pointermove", onPointerMove), useEventListener(el, "pointerup", onPointerUp), useEventListener(el, "pointercancel", onPointerUp), useEventListener(el, "lostpointercapture", onPointerInterrupted), useEventListener(doc, "pointerup", onPointerUp), useEventListener(doc, "pointercancel", onPointerUp), useEventListener(el, "touchstart", onTouchStart, { passive: true }), useEventListener(el, "touchmove", onTouchMove, { passive: false }), useEventListener(el, "touchend", onTouchEnd), useEventListener(el, "touchcancel", onTouchEnd));
+		if (win) cleanups.push(useEventListener(win, "blur", onPointerInterrupted));
+	}, { immediate: true });
+	onUnmounted(() => {
+		cleanups.forEach((fn) => fn());
+		cleanups.length = 0;
+		reset();
+	});
+	return {
+		isSwiping,
+		swipeDirection,
+		dragOffset
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Drawer/DrawerContentImpl.js
+var DrawerContentImpl_default = /* @__PURE__ */ defineComponent({
+	__name: "DrawerContentImpl",
+	props: {
+		trapFocus: {
+			type: Boolean,
+			required: false
+		},
+		initialFocus: {
+			type: [Boolean, null],
+			required: false,
+			skipCheck: true,
+			default: true
+		},
+		finalFocus: {
+			type: [Boolean, null],
+			required: false,
+			skipCheck: true,
+			default: true
+		},
+		disableOutsidePointerEvents: {
+			type: Boolean,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: [
+		"escapeKeyDown",
+		"pointerDownOutside",
+		"focusOutside",
+		"interactOutside",
+		"openAutoFocus",
+		"closeAutoFocus"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rootContext = injectDrawerRootContext();
+		const { forwardRef, currentElement } = useForwardExpose();
+		registerDrawerCssProperties();
+		const { activeSnapPointOffset, snapToNearest } = useDrawerSnapPoints({
+			snapPoints: rootContext.snapPoints,
+			activeSnapPoint: rootContext.activeSnapPoint,
+			popupHeight: rootContext.popupHeight,
+			viewportRef: currentElement,
+			onSnapPointChange: (point) => {
+				if (point === null) rootContext.onOpenChange(false);
+				else rootContext.setActiveSnapPoint(point);
+			}
+		});
+		function writeSnapPointOffset() {
+			const el = currentElement.value;
+			if (!el) return;
+			const offset = activeSnapPointOffset.value;
+			if (offset != null) {
+				const dir = rootContext.swipeDirection.value;
+				const signedOffset = dir === "up" || dir === "left" ? -offset : offset;
+				el.style.setProperty(DRAWER_CSS_VARS.snapPointOffset, `${signedOffset}px`);
+			} else el.style.setProperty(DRAWER_CSS_VARS.snapPointOffset, "0px");
+		}
+		watch(activeSnapPointOffset, writeSnapPointOffset);
+		useResizeObserver(currentElement, ([entry]) => {
+			if (!entry) return;
+			if (rootContext.hasNestedDrawer.value && rootContext.popupHeight.value > 0) return;
+			const h$1 = entry.contentRect.height;
+			rootContext.onPopupHeightChange(h$1);
+			currentElement.value?.style.setProperty(DRAWER_CSS_VARS.height, `${h$1}px`);
+		});
+		watch(() => rootContext.frontmostHeight.value, (h$1) => {
+			currentElement.value?.style.setProperty(DRAWER_CSS_VARS.frontmostHeight, `${h$1}px`);
+		});
+		const hasSnapPoints = computed(() => (rootContext.snapPoints.value?.length ?? 0) > 0);
+		const swipeDirections = computed(() => {
+			const dismiss = rootContext.swipeDirection.value;
+			if (!hasSnapPoints.value) return [dismiss];
+			return [dismiss, {
+				up: "down",
+				down: "up",
+				left: "right",
+				right: "left"
+			}[dismiss]];
+		});
+		let lastRawDelta = {
+			x: 0,
+			y: 0
+		};
+		const { isSwiping, dragOffset } = useSwipeDismiss({
+			enabled: computed(() => rootContext.open.value),
+			elementRef: currentElement,
+			directions: swipeDirections,
+			movementCssVars: {
+				x: DRAWER_CSS_VARS.swipeMovementX,
+				y: DRAWER_CSS_VARS.swipeMovementY
+			},
+			canStart: () => !rootContext.nestedSwiping.value,
+			onDismiss() {
+				if (!hasSnapPoints.value) rootContext.onOpenChange(false, "swipe");
+			},
+			onRelease(velocity) {
+				const el = currentElement.value;
+				if (el) {
+					const dir = rootContext.swipeDirection.value;
+					const size = dir === "left" || dir === "right" ? el.offsetWidth : el.offsetHeight;
+					const axisDelta = dir === "left" || dir === "right" ? lastRawDelta.x : lastRawDelta.y;
+					const releaseVelocity = dir === "left" || dir === "right" ? velocity.x : velocity.y;
+					const scalar = computeSwipeReleaseScalar({
+						direction: dir,
+						size,
+						axisDelta,
+						snapPointOffset: activeSnapPointOffset.value ?? 0,
+						releaseVelocity
+					});
+					if (scalar != null) el.style.setProperty(DRAWER_CSS_VARS.swipeStrength, `${scalar}`);
+					else el.style.setProperty(DRAWER_CSS_VARS.swipeStrength, "1");
+				}
+				if (hasSnapPoints.value) {
+					const dir = rootContext.swipeDirection.value;
+					const dragDelta = getDisplacement(dir, lastRawDelta.x, lastRawDelta.y);
+					snapToNearest(dragDelta, velocity, dir, rootContext.snapToSequentialPoints.value);
+					if (el) {
+						writeSnapPointOffset();
+						el.style.setProperty(DRAWER_CSS_VARS.swipeMovementX, "0px");
+						el.style.setProperty(DRAWER_CSS_VARS.swipeMovementY, "0px");
+					}
+				}
+				return hasSnapPoints.value;
+			},
+			onSwipingChange(swiping) {
+				rootContext.onSwipingChange(swiping);
+				rootContext.onNestedSwipingChange(swiping);
+			},
+			onProgress(progress, details) {
+				if (details) lastRawDelta = {
+					x: details.deltaX,
+					y: details.deltaY
+				};
+				rootContext.onNestedSwipeProgressChange(progress);
+			}
+		});
+		let pendingDismissReason;
+		function onDismiss() {
+			if (isSwiping.value) return;
+			rootContext.onOpenChange(false, pendingDismissReason ?? "outside-press");
+			pendingDismissReason = void 0;
+		}
+		function onEscapeKeyDown(event) {
+			pendingDismissReason = "escape-key";
+			emits("escapeKeyDown", event);
+		}
+		function onPointerDownOutside(event) {
+			if (isSwiping.value) {
+				event.preventDefault();
+				return;
+			}
+			pendingDismissReason = "outside-press";
+			emits("pointerDownOutside", event);
+		}
+		function onFocusOutside(event) {
+			if (isSwiping.value) {
+				event.preventDefault();
+				return;
+			}
+			emits("focusOutside", event);
+		}
+		function onInteractOutside(event) {
+			if (isSwiping.value) {
+				event.preventDefault();
+				return;
+			}
+			emits("interactOutside", event);
+		}
+		function onMountAutoFocus(event) {
+			emits("openAutoFocus", event);
+			if (event.defaultPrevented) return;
+			if (props.initialFocus === false) event.preventDefault();
+			else if (props.initialFocus instanceof HTMLElement) {
+				event.preventDefault();
+				focus(props.initialFocus, { select: true });
+			}
+		}
+		let openCompleteCleanup;
+		function clearOpenCompleteListener() {
+			openCompleteCleanup?.();
+			openCompleteCleanup = void 0;
+		}
+		watch(() => rootContext.open.value, (isOpen) => {
+			clearOpenCompleteListener();
+			const el = currentElement.value;
+			if (!el) {
+				rootContext.notifyOpenComplete(isOpen);
+				return;
+			}
+			const handler = (event) => {
+				if (event.target !== el) return;
+				clearOpenCompleteListener();
+				rootContext.notifyOpenComplete(isOpen);
+			};
+			el.addEventListener("transitionend", handler);
+			el.addEventListener("animationend", handler);
+			openCompleteCleanup = () => {
+				el.removeEventListener("transitionend", handler);
+				el.removeEventListener("animationend", handler);
+			};
+		});
+		const dataAttributes = computed(() => {
+			const attrs = {
+				"data-state": rootContext.open.value ? "open" : "closed",
+				"data-swipe-direction": rootContext.swipeDirection.value
+			};
+			if (isSwiping.value) attrs["data-swiping"] = "";
+			if (rootContext.hasNestedDrawer.value) attrs["data-nested-drawer-open"] = "";
+			return attrs;
+		});
+		watch(() => rootContext.nestedOpenDrawerCount.value, (n) => {
+			currentElement.value?.style.setProperty(DRAWER_CSS_VARS.nestedDrawers, `${n}`);
+		});
+		let unsubscribeNestedProgress;
+		onMounted(() => {
+			rootContext.contentElement.value = currentElement.value;
+			rootContext.notifyParentHasNestedDrawer?.(true);
+			currentElement.value?.style.setProperty(DRAWER_CSS_VARS.nestedDrawers, `${rootContext.nestedOpenDrawerCount.value}`);
+			writeSnapPointOffset();
+			unsubscribeNestedProgress = rootContext.nestedSwipeProgressStore.subscribe(() => {
+				const progress = rootContext.nestedSwipeProgressStore.getSnapshot();
+				currentElement.value?.style.setProperty(DRAWER_CSS_VARS.swipeProgress, `${progress}`);
+			});
+		});
+		onUnmounted(() => {
+			rootContext.notifyParentHasNestedDrawer?.(false);
+			unsubscribeNestedProgress?.();
+			clearOpenCompleteListener();
+		});
+		if (process.env.NODE_ENV !== "production") onMounted(() => {
+			if (!document.getElementById(rootContext.titleId)) console.warn(`Warning: \`DrawerContent\` requires a \`DrawerTitle\` for accessibility.`);
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(FocusScope_default), {
+				"as-child": "",
+				loop: "",
+				trapped: props.trapFocus,
+				onMountAutoFocus,
+				onUnmountAutoFocus: _cache[0] || (_cache[0] = ($event) => emits("closeAutoFocus", $event))
+			}, {
+				default: withCtx(() => [createVNode(unref(DismissableLayer_default), mergeProps({
+					id: unref(rootContext).contentId,
+					ref: unref(forwardRef),
+					as: _ctx.as,
+					"as-child": _ctx.asChild,
+					"disable-outside-pointer-events": _ctx.disableOutsidePointerEvents,
+					role: "dialog",
+					"aria-describedby": unref(rootContext).descriptionId,
+					"aria-labelledby": unref(rootContext).titleId
+				}, {
+					...dataAttributes.value,
+					..._ctx.$attrs
+				}, {
+					onDismiss,
+					onEscapeKeyDown,
+					onFocusOutside,
+					onInteractOutside,
+					onPointerDownOutside
+				}), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, [
+					"id",
+					"as",
+					"as-child",
+					"disable-outside-pointer-events",
+					"aria-describedby",
+					"aria-labelledby"
+				])]),
+				_: 3
+			}, 8, ["trapped"]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Drawer/DrawerContent.js
+var DrawerContent_default = /* @__PURE__ */ defineComponent({
+	__name: "DrawerContent",
+	props: {
+		forceMount: {
+			type: Boolean,
+			required: false
+		},
+		initialFocus: {
+			type: [Boolean, null],
+			required: false,
+			skipCheck: true,
+			default: true
+		},
+		finalFocus: {
+			type: [Boolean, null],
+			required: false,
+			skipCheck: true,
+			default: true
+		},
+		disableOutsidePointerEvents: {
+			type: Boolean,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: [
+		"escapeKeyDown",
+		"pointerDownOutside",
+		"focusOutside",
+		"interactOutside",
+		"openAutoFocus",
+		"closeAutoFocus"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rootContext = injectDrawerRootContext();
+		const emitsAsProps = useEmitAsProps(emits);
+		const { forwardRef, currentElement } = useForwardExpose();
+		const hasInteractedOutside = ref(false);
+		const hasPointerDownOutside = ref(false);
+		const isFullModal = computed(() => rootContext.modal.value === true);
+		const isTrapFocusOnly = computed(() => rootContext.modal.value === "trap-focus");
+		const shouldTrapFocus = computed(() => (isFullModal.value || isTrapFocusOnly.value) && rootContext.open.value);
+		const shouldHideOthers = computed(() => isFullModal.value ? currentElement.value : void 0);
+		useHideOthers(shouldHideOthers);
+		function finalFocusElement() {
+			if (props.finalFocus === false) return void 0;
+			if (props.finalFocus instanceof HTMLElement) return props.finalFocus;
+			return rootContext.triggerElement.value;
+		}
+		function onCloseAutoFocusNonModal(e) {
+			if (!e.defaultPrevented) {
+				if (!hasInteractedOutside.value) finalFocusElement()?.focus();
+				e.preventDefault();
+			}
+			hasInteractedOutside.value = false;
+			hasPointerDownOutside.value = false;
+		}
+		function onInteractOutsideNonModal(e) {
+			if (!e.defaultPrevented) {
+				hasInteractedOutside.value = true;
+				if (e.detail.originalEvent.type === "pointerdown") hasPointerDownOutside.value = true;
+			}
+			const target = e.target;
+			if (rootContext.triggerElement.value?.contains(target)) e.preventDefault();
+			if (e.detail.originalEvent.type === "focusin" && hasPointerDownOutside.value) e.preventDefault();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Presence_default), { present: _ctx.forceMount || unref(rootContext).open.value }, {
+				default: withCtx(() => [isFullModal.value ? (openBlock(), createBlock(DrawerContentImpl_default, mergeProps({
+					key: 0,
+					ref: unref(forwardRef)
+				}, {
+					...props,
+					...unref(emitsAsProps),
+					..._ctx.$attrs
+				}, {
+					"trap-focus": shouldTrapFocus.value,
+					"disable-outside-pointer-events": true,
+					onCloseAutoFocus: _cache[0] || (_cache[0] = (e) => {
+						if (!e.defaultPrevented) {
+							e.preventDefault();
+							finalFocusElement()?.focus();
+						}
+					}),
+					onPointerDownOutside: _cache[1] || (_cache[1] = (e) => {
+						const orig = e.detail.originalEvent;
+						if (orig.button === 2 || orig.button === 0 && orig.ctrlKey) e.preventDefault();
+					}),
+					onFocusOutside: _cache[2] || (_cache[2] = (e) => e.preventDefault())
+				}), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, ["trap-focus"])) : (openBlock(), createBlock(DrawerContentImpl_default, mergeProps({
+					key: 1,
+					ref: unref(forwardRef)
+				}, {
+					...props,
+					...unref(emitsAsProps),
+					..._ctx.$attrs
+				}, {
+					"trap-focus": shouldTrapFocus.value,
+					"disable-outside-pointer-events": false,
+					onCloseAutoFocus: onCloseAutoFocusNonModal,
+					onInteractOutside: onInteractOutsideNonModal
+				}), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, ["trap-focus"]))]),
+				_: 3
+			}, 8, ["present"]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Drawer/DrawerHandle.js
+var DrawerHandle_default = /* @__PURE__ */ defineComponent({
+	__name: "DrawerHandle",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		useForwardExpose();
+		const rootContext = injectDrawerRootContext();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+				"aria-hidden": "true",
+				"data-state": unref(rootContext).open.value ? "open" : "closed"
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["data-state"]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Drawer/DrawerOverlayImpl.js
+var DrawerOverlayImpl_default = /* @__PURE__ */ defineComponent({
+	__name: "DrawerOverlayImpl",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const rootContext = injectDrawerRootContext();
+		const locked = useBodyScrollLock(rootContext.open.value);
+		watch(() => rootContext.open.value, (open) => {
+			locked.value = open;
+		}, { immediate: true });
+		useForwardExpose();
+		const dataAttributes = computed(() => {
+			const attrs = {
+				"data-state": rootContext.open.value ? "open" : "closed",
+				"data-swipe-direction": rootContext.swipeDirection.value
+			};
+			if (rootContext.isSwiping.value) attrs["data-swiping"] = "";
+			return attrs;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps({
+				as: _ctx.as,
+				"as-child": _ctx.asChild
+			}, dataAttributes.value, { style: {
+				pointerEvents: "auto",
+				userSelect: "none",
+				[unref(DRAWER_CSS_VARS).swipeProgress]: "0",
+				[unref(DRAWER_CSS_VARS).swipeStrength]: "1"
+			} }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, [
+				"as",
+				"as-child",
+				"style"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Drawer/DrawerOverlay.js
+var DrawerOverlay_default = /* @__PURE__ */ defineComponent({
+	__name: "DrawerOverlay",
+	props: {
+		forceMount: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		forceRender: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const rootContext = injectDrawerRootContext();
+		const isNested = !!rootContext.notifyParentHasNestedDrawer;
+		const { forwardRef } = useForwardExpose();
+		return (_ctx, _cache) => {
+			return unref(rootContext).modal.value && (!isNested || _ctx.forceRender) ? (openBlock(), createBlock(unref(Presence_default), {
+				key: 0,
+				present: _ctx.forceMount || unref(rootContext).open.value
+			}, {
+				default: withCtx(() => [createVNode(DrawerOverlayImpl_default, mergeProps(_ctx.$attrs, {
+					ref: unref(forwardRef),
+					as: _ctx.as,
+					"as-child": _ctx.asChild
+				}), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, ["as", "as-child"])]),
+				_: 3
+			}, 8, ["present"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Drawer/DrawerPortal.js
+var DrawerPortal_default = /* @__PURE__ */ defineComponent({
+	__name: "DrawerPortal",
+	props: {
+		to: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		defer: {
+			type: Boolean,
+			required: false
+		},
+		forceMount: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Teleport_default), normalizeProps(guardReactiveProps(_ctx.$props)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region src/components/drawer/drawer-content.vue
+var drawer_content_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "drawer-content",
+	props: {
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		forceMount: { type: Boolean },
+		initialFocus: { type: [Boolean, null] },
+		finalFocus: { type: [Boolean, null] },
+		disableOutsidePointerEvents: { type: Boolean },
+		asChild: { type: Boolean },
+		as: {}
+	},
+	emits: [
+		"escapeKeyDown",
+		"pointerDownOutside",
+		"focusOutside",
+		"interactOutside",
+		"openAutoFocus",
+		"closeAutoFocus"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const forwarded = useForwardPropsEmits(reactiveOmit(props, "class"), emits);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(DrawerPortal_default), null, {
+				default: withCtx(() => [createVNode(unref(DrawerOverlay_default), { class: "celeste-drawer-overlay" }), createVNode(unref(DrawerContent_default), mergeProps({ class: unref(clsx)("celeste-drawer-content", props.class) }, {
+					...unref(forwarded),
+					..._ctx.$attrs
+				}), {
+					default: withCtx(() => [createVNode(unref(DrawerHandle_default), { class: "celeste-drawer-handle" }), renderSlot(_ctx.$slots, "default", {}, void 0, true)]),
+					_: 3
+				}, 16, ["class"])]),
+				_: 3
+			});
+		};
+	}
+}), [["__scopeId", "data-v-3dfcd198"]]);
+//#endregion
+export { drawer_content_default as t };