solid-baseui 0.1.0-alpha.0

package/dist/lib/server/drawer/index.js

@@ -0,0 +1,2351 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
+import { getStateAttributesProps } from "../internals/getStateAttributesProps.js";
+import { a as closeWatcher, k as swipe } from "../internals/reasons.js";
+import { n as resolveClass, t as resolveStyle } from "../resolveStyle-XCSFDHAL.js";
+import { createChangeEventDetails } from "../internals/createBaseUIEventDetails.js";
+import { TransitionStatusDataAttributes } from "../internals/stateAttributesMapping.js";
+import { composeEventHandlers } from "../internals/composeEventHandlers.js";
+import { a as isElement, c as isHTMLElement, l as isInteractiveElement, m as ownerWindow, n as contains, p as ownerDocument, r as getEventTarget, t as activeElement } from "../dom-Crg_2R-j.js";
+import { n as createTriggerRegistration } from "../PopupStore-DEs3FAEe.js";
+import { r as popupTransitionStateMapping, t as CommonPopupDataAttributes } from "../popupStateMapping-nKoUwoke.js";
+import { t as FocusManager } from "../FocusManager-BrbZVWME.js";
+import { a as DialogTitle, c as DialogDescription, d as dialogTransitionStateAttributesMapping, f as mergeDialogStyles, h as useDialogRootContext, i as DialogTrigger, l as DialogClose, m as renderDialogRoot, o as DialogPortal, r as DialogViewport, s as useDialogPortalContext, t as DialogHandle } from "../DialogHandle-ATZlm9RC.js";
+import { n as getComposedParentNode, t as findScrollableTouchTarget } from "../scrollable-CjsSxbGr.js";
+import { t as isAndroid } from "../platform-DYukKUir.js";
+import { a as getElementTransform, i as getDisplacement, o as getElementAtPoint, r as createSwipeDismiss, s as clamp, t as BASE_UI_SWIPE_IGNORE_SELECTOR } from "../constants-9H__9xbS.js";
+import { Dynamic, mergeProps, ssrElement } from "@solidjs/web";
+import { Show, createContext, createEffect, createMemo, createSignal, createUniqueId, flush, merge, omit, onCleanup, untrack, useContext } from "solid-js";
+//#region src/drawer/popup/DrawerPopupCssVars.ts
+var DrawerPopupCssVars = /* @__PURE__ */ function(DrawerPopupCssVars) {
+	/**
+	* The number of nested drawers that are currently open.
+	* @type {number}
+	*/
+	DrawerPopupCssVars["nestedDrawers"] = "--nested-drawers";
+	/**
+	* The height of the drawer popup.
+	* @type {CSS length}
+	*/
+	DrawerPopupCssVars["height"] = "--drawer-height";
+	/**
+	* The height of the frontmost open drawer in the current nested drawer stack.
+	* @type {CSS length}
+	*/
+	DrawerPopupCssVars["frontmostHeight"] = "--drawer-frontmost-height";
+	/**
+	* The swipe movement on the X axis.
+	* @type {CSS length}
+	*/
+	DrawerPopupCssVars["swipeMovementX"] = "--drawer-swipe-movement-x";
+	/**
+	* The swipe movement on the Y axis.
+	* @type {CSS length}
+	*/
+	DrawerPopupCssVars["swipeMovementY"] = "--drawer-swipe-movement-y";
+	/**
+	* The snap point offset used for translating the drawer.
+	* @type {CSS length}
+	*/
+	DrawerPopupCssVars["snapPointOffset"] = "--drawer-snap-point-offset";
+	/**
+	* A scalar (0.1-1) used to scale the swipe release transition duration in CSS.
+	* @type {number}
+	*/
+	DrawerPopupCssVars["swipeStrength"] = "--drawer-swipe-strength";
+	return DrawerPopupCssVars;
+}({});
+//#endregion
+//#region src/drawer/backdrop/DrawerBackdropCssVars.ts
+var DrawerBackdropCssVars = /* @__PURE__ */ function(DrawerBackdropCssVars) {
+	/**
+	* The swipe progress of the drawer gesture.
+	* @type {number}
+	*/
+	DrawerBackdropCssVars["swipeProgress"] = "--drawer-swipe-progress";
+	return DrawerBackdropCssVars;
+}({});
+//#endregion
+//#region src/drawer/backdrop/DrawerBackdrop.tsx
+/** An overlay displayed beneath the drawer popup. */
+function DrawerBackdrop(props) {
+	const context = useDialogRootContext();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "forceRender", "ref", "style");
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		transitionStatus: context.presence.transitionStatus()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeDialogStyles({
+		"pointer-events": context.store.open() ? void 0 : "none",
+		"user-select": "none",
+		"-webkit-user-select": "none",
+		[DrawerBackdropCssVars.swipeProgress]: "0",
+		[DrawerPopupCssVars.swipeStrength]: "1"
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), dialogTransitionStateAttributesMapping));
+	const shouldRender = createMemo(() => Boolean(internalProps.forceRender) || !context.nested);
+	function BackdropElement() {
+		let backdropElement = null;
+		onCleanup(() => {
+			if (context.backdropElement() === backdropElement) context.setBackdropElement(null);
+		});
+		return Dynamic(mergeProps({
+			get component() {
+				return props.as ?? "div";
+			},
+			ref: [((element) => {
+				backdropElement = element;
+				context.setBackdropElement(element);
+			}), internalProps.ref],
+			role: "presentation",
+			get hidden() {
+				return !context.presence.mounted();
+			},
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			}
+		}, stateAttributes, others));
+	}
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return BackdropElement({});
+		}
+	});
+}
+//#endregion
+//#region src/drawer/content/DrawerContentDataAttributes.ts
+var DRAWER_CONTENT_ATTRIBUTE = "data-drawer-content";
+//#endregion
+//#region src/drawer/content/DrawerContent.tsx
+/**
+* A container for the drawer contents. Allows text selection of its children without swipe
+* interference when using a mouse pointer.
+*/
+function DrawerContent(props) {
+	useDialogRootContext();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "ref", "style");
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref]
+	}, { [DRAWER_CONTENT_ATTRIBUTE]: "" }, {
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others));
+}
+//#endregion
+//#region src/drawer/provider/DrawerProviderContext.ts
+var MISSING_CONTEXT$3 = Symbol("DrawerProviderContext");
+var DrawerProviderContext = createContext(MISSING_CONTEXT$3);
+function useDrawerProviderContext() {
+	const context = useContext(DrawerProviderContext);
+	return context === MISSING_CONTEXT$3 ? void 0 : context;
+}
+function createVisualStateStore() {
+	let state = {
+		swipeProgress: 0,
+		frontmostHeight: 0
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getSnapshot: () => state,
+		set(nextState) {
+			let nextSwipeProgress = state.swipeProgress;
+			if (nextState.swipeProgress !== void 0) nextSwipeProgress = Number.isFinite(nextState.swipeProgress) ? nextState.swipeProgress : 0;
+			let nextFrontmostHeight = state.frontmostHeight;
+			if (nextState.frontmostHeight !== void 0) nextFrontmostHeight = Number.isFinite(nextState.frontmostHeight) ? nextState.frontmostHeight : 0;
+			if (nextSwipeProgress === state.swipeProgress && nextFrontmostHeight === state.frontmostHeight) return;
+			state = {
+				swipeProgress: nextSwipeProgress,
+				frontmostHeight: nextFrontmostHeight
+			};
+			listeners.forEach((listener) => {
+				listener();
+			});
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/drawer/indent-background/DrawerIndentBackground.tsx
+var ACTIVE = { "data-active": "" };
+var INACTIVE = { "data-inactive": "" };
+var drawerIndentStateAttributesMapping = { active: (value) => value ? ACTIVE : INACTIVE };
+/**
+* An element placed before `<Drawer.Indent>` to render a background layer that can be styled
+* based on whether any drawer is open.
+*/
+function DrawerIndentBackground(props) {
+	const provider = useDrawerProviderContext();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "ref", "style");
+	const state = () => ({ active: provider?.active() ?? false });
+	const classValue = () => resolveClass(props.class, state());
+	const styleValue = () => resolveStyle(props.style, state());
+	const stateAttributes = () => getStateAttributesProps(state(), drawerIndentStateAttributesMapping);
+	const component = untrack(() => props.as);
+	return component === void 0 ? ssrElement("div", () => {
+		return mergeProps({
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			}
+		}, stateAttributes, others);
+	}, void 0, true) : Dynamic(mergeProps({
+		component,
+		ref: [internalProps.ref],
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/drawer/indent/DrawerIndent.tsx
+/**
+* A wrapper element intended to contain your app's main UI. Applies `data-active` when any drawer
+* within the nearest `<Drawer.Provider>` is open.
+*/
+function DrawerIndent(props) {
+	const provider = useDrawerProviderContext();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "ref", "style");
+	const state = () => ({ active: provider?.active() ?? false });
+	const classValue = () => resolveClass(props.class, state());
+	const styleValue = () => mergeDialogStyles({ [DrawerBackdropCssVars.swipeProgress]: "0" }, resolveStyle(props.style, state()));
+	const stateAttributes = () => getStateAttributesProps(state(), drawerIndentStateAttributesMapping);
+	let indentElement = null;
+	const indentRef = [((element) => {
+		indentElement = element;
+	}), internalProps.ref];
+	const component = untrack(() => props.as);
+	const element = component === void 0 ? ssrElement("div", () => {
+		return mergeProps({
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			}
+		}, stateAttributes, others);
+	}, void 0, true) : Dynamic(mergeProps({
+		component,
+		ref: indentRef,
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+	createEffect(() => provider?.visualStateStore, (visualStateStore) => {
+		const indent = indentElement;
+		if (!indent || !visualStateStore) return;
+		function syncVisualState() {
+			const { swipeProgress, frontmostHeight } = visualStateStore.getSnapshot();
+			indent.style.setProperty(DrawerBackdropCssVars.swipeProgress, swipeProgress <= 0 ? "0" : `${swipeProgress}`);
+			if (frontmostHeight <= 0) indent.style.removeProperty(DrawerPopupCssVars.height);
+			else indent.style.setProperty(DrawerPopupCssVars.height, `${frontmostHeight}px`);
+		}
+		syncVisualState();
+		const unsubscribe = visualStateStore.subscribe(syncVisualState);
+		return () => {
+			unsubscribe();
+			indent.style.setProperty(DrawerBackdropCssVars.swipeProgress, "0");
+			indent.style.removeProperty(DrawerPopupCssVars.height);
+		};
+	});
+	return element;
+}
+//#endregion
+//#region src/drawer/root/DrawerRootContext.ts
+var MISSING_CONTEXT$2 = Symbol("DrawerRootContext");
+var DrawerRootContext = createContext(MISSING_CONTEXT$2);
+function useDrawerRootContext(optional = false) {
+	const context = useContext(DrawerRootContext);
+	if (context === MISSING_CONTEXT$2) {
+		if (optional) return;
+		throw new Error("Base UI: DrawerRootContext is missing. Drawer parts must be placed within <Drawer.Root>.");
+	}
+	return context;
+}
+//#endregion
+//#region src/drawer/root/createDrawerSnapPoints.ts
+/**
+* Resolves the vertical swipe movement for a snap point, applying square-root damping once the
+* drag overshoots the fully-open edge (`nextOffset < 0`) so the popup resists travelling past it.
+*/
+function getSnapPointSwipeMovement(baseOffset, movementValue) {
+	const nextOffset = baseOffset + movementValue;
+	if (nextOffset >= 0) return movementValue;
+	return -Math.sqrt(-nextOffset) - baseOffset;
+}
+function resolveSnapPointValue(snapPoint, viewportHeight, rootFontSize) {
+	if (!Number.isFinite(viewportHeight) || viewportHeight <= 0) return null;
+	if (typeof snapPoint === "number") {
+		if (!Number.isFinite(snapPoint)) return null;
+		if (snapPoint <= 1) return clamp(snapPoint, 0, 1) * viewportHeight;
+		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;
+}
+/** Returns the index of the value closest to `target`, or `-1` if `values` is empty. */
+function closestSnapPointIndex(values, target) {
+	let closestIndex = -1;
+	let closestDistance = Infinity;
+	for (let index = 0; index < values.length; index += 1) {
+		const distance = Math.abs(values[index] - target);
+		if (distance < closestDistance) {
+			closestDistance = distance;
+			closestIndex = index;
+		}
+	}
+	return closestIndex;
+}
+function createDrawerSnapPoints() {
+	const dialog = useDialogRootContext();
+	const drawer = useDrawerRootContext();
+	const [viewportHeight, setViewportHeight] = createSignal(0, { ownedWrite: true });
+	const [rootFontSize, setRootFontSize] = createSignal(16, { ownedWrite: true });
+	createEffect(() => dialog.viewportElement(), (viewportElement) => {
+		function measure() {
+			const html = ownerDocument(viewportElement).documentElement;
+			setViewportHeight(viewportElement ? viewportElement.offsetHeight : html.clientHeight);
+			const fontSize = Number.parseFloat(ownerWindow(html).getComputedStyle(html).fontSize);
+			if (Number.isFinite(fontSize)) setRootFontSize(fontSize);
+		}
+		measure();
+		if (!viewportElement || typeof ResizeObserver !== "function") return;
+		const resizeObserver = new ResizeObserver(measure);
+		resizeObserver.observe(viewportElement);
+		return () => resizeObserver.disconnect();
+	});
+	const resolvedSnapPoints = createMemo(() => {
+		const points = drawer.snapPoints();
+		const height = viewportHeight();
+		const popup = drawer.popupHeight();
+		if (!points || points.length === 0 || height <= 0 || popup <= 0) return [];
+		const fontSize = rootFontSize();
+		const maxHeight = Math.min(popup, height);
+		const resolved = points.map((value) => {
+			const resolvedHeight = resolveSnapPointValue(value, height, fontSize);
+			if (resolvedHeight === null) return null;
+			const clampedHeight = clamp(resolvedHeight, 0, maxHeight);
+			return {
+				value,
+				height: clampedHeight,
+				offset: Math.max(0, popup - clampedHeight)
+			};
+		}).filter((point) => Boolean(point));
+		if (resolved.length <= 1) return resolved;
+		const deduped = [];
+		const seenHeights = [];
+		for (let index = resolved.length - 1; index >= 0; index -= 1) {
+			const point = resolved[index];
+			if (seenHeights.some((seen) => Math.abs(seen - point.height) <= 1)) continue;
+			seenHeights.push(point.height);
+			deduped.push(point);
+		}
+		deduped.reverse();
+		return deduped;
+	});
+	const activeResolvedSnapPoint = createMemo(() => {
+		const active = drawer.activeSnapPoint();
+		if (active === null) return;
+		const points = resolvedSnapPoints();
+		const exactMatch = points.find((point) => Object.is(point.value, active));
+		if (exactMatch) return exactMatch;
+		const height = viewportHeight();
+		const maxHeight = Math.min(drawer.popupHeight(), height);
+		const resolvedHeight = resolveSnapPointValue(active, height, rootFontSize());
+		if (resolvedHeight === null) return;
+		const clampedHeight = clamp(resolvedHeight, 0, maxHeight);
+		return points[closestSnapPointIndex(points.map((point) => point.height), clampedHeight)];
+	});
+	return {
+		snapPoints: drawer.snapPoints,
+		activeSnapPoint: drawer.activeSnapPoint,
+		setActiveSnapPoint: drawer.setActiveSnapPoint,
+		popupHeight: drawer.popupHeight,
+		viewportHeight,
+		resolvedSnapPoints,
+		activeSnapPointOffset: () => activeResolvedSnapPoint()?.offset ?? null
+	};
+}
+//#endregion
+//#region src/drawer/viewport/DrawerViewportContext.ts
+var MISSING_CONTEXT$1 = Symbol("DrawerViewportContext");
+var DrawerViewportContext = createContext(MISSING_CONTEXT$1);
+function useDrawerViewportContext() {
+	const context = useContext(DrawerViewportContext);
+	return context === MISSING_CONTEXT$1 ? void 0 : context;
+}
+//#endregion
+//#region src/drawer/popup/DrawerPopupDataAttributes.ts
+var DrawerPopupDataAttributes = /* @__PURE__ */ function(DrawerPopupDataAttributes) {
+	/** Present when the drawer is open. */
+	DrawerPopupDataAttributes[DrawerPopupDataAttributes["open"] = CommonPopupDataAttributes.open] = "open";
+	/** Present when the drawer is closed. */
+	DrawerPopupDataAttributes[DrawerPopupDataAttributes["closed"] = CommonPopupDataAttributes.closed] = "closed";
+	/** Present when the drawer begins animating in. */
+	DrawerPopupDataAttributes[DrawerPopupDataAttributes["startingStyle"] = CommonPopupDataAttributes.startingStyle] = "startingStyle";
+	/** Present when the drawer is animating out. */
+	DrawerPopupDataAttributes[DrawerPopupDataAttributes["endingStyle"] = CommonPopupDataAttributes.endingStyle] = "endingStyle";
+	/** Present when the drawer is at the expanded (full-height) snap point. */
+	DrawerPopupDataAttributes["expanded"] = "data-expanded";
+	/** Present when a nested drawer is open. */
+	DrawerPopupDataAttributes["nestedDrawerOpen"] = "data-nested-drawer-open";
+	/** Present when a nested drawer is being swiped. */
+	DrawerPopupDataAttributes["nestedDrawerSwiping"] = "data-nested-drawer-swiping";
+	/** Present when the drawer is dismissed by swiping. */
+	DrawerPopupDataAttributes["swipeDismiss"] = "data-swipe-dismiss";
+	/**
+	* Indicates the swipe direction.
+	* @type {'up' | 'down' | 'left' | 'right'}
+	*/
+	DrawerPopupDataAttributes["swipeDirection"] = "data-swipe-direction";
+	/** Present when the drawer is being swiped. */
+	DrawerPopupDataAttributes["swiping"] = "data-swiping";
+	return DrawerPopupDataAttributes;
+}({});
+//#endregion
+//#region src/drawer/popup/DrawerPopup.tsx
+var COMPOSITE_KEYS = /* @__PURE__ */ new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End"
+]);
+var drawerSwipeVarsRegistered = false;
+/**
+* Removes inheritance of high-frequency drawer swipe CSS variables, which reduces style
+* recalculation cost in complex drawers with deep subtrees.
+* See https://motion.dev/blog/web-animation-performance-tier-list under the
+* "Improving CSS variable performance" section.
+*/
+function removeCssVariableInheritance() {
+	if (drawerSwipeVarsRegistered) return;
+	if (typeof CSS !== "undefined" && "registerProperty" in CSS) {
+		for (const name of [
+			DrawerPopupCssVars.swipeMovementX,
+			DrawerPopupCssVars.swipeMovementY,
+			DrawerPopupCssVars.snapPointOffset
+		]) try {
+			CSS.registerProperty({
+				name,
+				syntax: "<length>",
+				inherits: false,
+				initialValue: "0px"
+			});
+		} catch {}
+		for (const { name, initialValue } of [{
+			name: DrawerBackdropCssVars.swipeProgress,
+			initialValue: "0"
+		}, {
+			name: DrawerPopupCssVars.swipeStrength,
+			initialValue: "1"
+		}]) try {
+			CSS.registerProperty({
+				name,
+				syntax: "<number>",
+				inherits: false,
+				initialValue
+			});
+		} catch {}
+	}
+	drawerSwipeVarsRegistered = true;
+}
+var EXPANDED = { [DrawerPopupDataAttributes.expanded]: "" };
+var NESTED_DRAWER_OPEN = { [DrawerPopupDataAttributes.nestedDrawerOpen]: "" };
+var NESTED_DRAWER_SWIPING = { [DrawerPopupDataAttributes.nestedDrawerSwiping]: "" };
+var SWIPING = { [DrawerPopupDataAttributes.swiping]: "" };
+var stateAttributesMapping$1 = {
+	...popupTransitionStateMapping,
+	expanded: (value) => value ? EXPANDED : null,
+	nestedDrawerOpen: (value) => value ? NESTED_DRAWER_OPEN : null,
+	nestedDrawerSwiping: (value) => value ? NESTED_DRAWER_SWIPING : null,
+	swipeDirection: (value) => ({ [DrawerPopupDataAttributes.swipeDirection]: value }),
+	swiping: (value) => value ? SWIPING : null
+};
+/** A container for the drawer contents. */
+function DrawerPopup(props) {
+	useDialogPortalContext();
+	const context = useDialogRootContext();
+	const drawer = useDrawerRootContext();
+	const swipe = useDrawerViewportContext();
+	const snap = createDrawerSnapPoints();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "finalFocus", "id", "initialFocus", "onKeyDown", "ref", "style");
+	const nestedDrawerOpen = createMemo(() => context.nestedOpenDrawerCount() > 0);
+	const swiping = createMemo(() => swipe?.swiping() ?? false);
+	let popupElement = null;
+	let measuredPopupHeight = 0;
+	function measureHeight() {
+		if (!popupElement) return;
+		const offsetHeight = popupElement.offsetHeight;
+		const frontmostHeight = untrack(drawer.frontmostHeight);
+		if (measuredPopupHeight > 0 && frontmostHeight > measuredPopupHeight && offsetHeight > measuredPopupHeight) return;
+		if (measuredPopupHeight > 0 && untrack(drawer.hasNestedDrawer)) {
+			drawer.onPopupHeightChange(measuredPopupHeight);
+			return;
+		}
+		if (offsetHeight === measuredPopupHeight) return;
+		measuredPopupHeight = offsetHeight;
+		drawer.onPopupHeightChange(offsetHeight);
+	}
+	createEffect(() => ({
+		mounted: context.presence.mounted(),
+		nestedDrawerOpen: nestedDrawerOpen(),
+		element: context.store.track().popupElement
+	}), (state) => {
+		if (!state.mounted) {
+			measuredPopupHeight = 0;
+			drawer.onPopupHeightChange(0);
+			return;
+		}
+		if (!state.element) return;
+		removeCssVariableInheritance();
+		measureHeight();
+		if (typeof ResizeObserver !== "function") return;
+		const resizeObserver = new ResizeObserver(measureHeight);
+		resizeObserver.observe(state.element);
+		return () => resizeObserver.disconnect();
+	});
+	createEffect(() => context.store.track().popupElement, (element) => {
+		function syncNestedSwipeProgress() {
+			if (!element) return;
+			const progress = drawer.nestedSwipeProgressStore.getSnapshot();
+			element.style.setProperty(DrawerBackdropCssVars.swipeProgress, progress > 0 ? `${progress}` : "0");
+		}
+		syncNestedSwipeProgress();
+		const unsubscribe = drawer.nestedSwipeProgressStore.subscribe(syncNestedSwipeProgress);
+		return () => {
+			unsubscribe();
+			element?.style.setProperty(DrawerBackdropCssVars.swipeProgress, "0");
+		};
+	});
+	createEffect(() => ({
+		open: context.store.open(),
+		frontmostHeight: drawer.frontmostHeight()
+	}), (state) => {
+		if (!state.open) return;
+		drawer.notifyParentFrontmostHeight?.(state.frontmostHeight);
+		return () => drawer.notifyParentFrontmostHeight?.(0);
+	});
+	createEffect(() => ({
+		open: context.store.open(),
+		transitionStatus: context.presence.transitionStatus()
+	}), (state) => {
+		if (!drawer.notifyParentHasNestedDrawer) return;
+		drawer.notifyParentHasNestedDrawer(state.open || state.transitionStatus === "ending");
+		return () => drawer.notifyParentHasNestedDrawer?.(false);
+	});
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		transitionStatus: context.presence.transitionStatus(),
+		expanded: drawer.activeSnapPoint() === 1,
+		nested: context.nested,
+		nestedDrawerOpen: nestedDrawerOpen(),
+		nestedDrawerSwiping: drawer.nestedSwiping(),
+		swipeDirection: drawer.swipeDirection(),
+		swiping: swiping()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), stateAttributesMapping$1));
+	const snapPointOffsetValue = createMemo(() => {
+		const points = snap.snapPoints();
+		const direction = drawer.swipeDirection();
+		const shouldApply = points && points.length > 0 && (direction === "down" || direction === "up");
+		const offset = snap.activeSnapPointOffset();
+		if (!shouldApply || offset === null) return null;
+		return direction === "up" ? -offset : offset;
+	});
+	const dragStyles = createMemo(() => {
+		const base = swipe ? swipe.getDragStyles() : {};
+		const points = snap.snapPoints();
+		const direction = drawer.swipeDirection();
+		if (!(points && points.length > 0 && (direction === "down" || direction === "up")) || direction !== "down") return base;
+		const movementValue = Number.parseFloat(String(base[DrawerPopupCssVars.swipeMovementY]));
+		if (swiping() && Number.isFinite(movementValue)) return {
+			...base,
+			transform: void 0,
+			[DrawerPopupCssVars.swipeMovementY]: `${getSnapPointSwipeMovement(snap.activeSnapPointOffset() ?? 0, movementValue)}px`
+		};
+		return {
+			...base,
+			transform: void 0
+		};
+	});
+	const styleValue = createMemo(() => {
+		const frontmostHeight = drawer.frontmostHeight();
+		const shouldUseAutoHeight = !drawer.hasNestedDrawer() && context.presence.transitionStatus() !== "ending";
+		const height = drawer.popupHeight();
+		const swipeStrength = swipe?.swipeStrength() ?? null;
+		const offset = snapPointOffsetValue();
+		return mergeDialogStyles({
+			...dragStyles(),
+			[DrawerBackdropCssVars.swipeProgress]: "0",
+			[DrawerPopupCssVars.nestedDrawers]: context.nestedOpenDrawerCount(),
+			[DrawerPopupCssVars.height]: height && !shouldUseAutoHeight ? `${height}px` : void 0,
+			[DrawerPopupCssVars.snapPointOffset]: typeof offset === "number" ? `${offset}px` : "0px",
+			[DrawerPopupCssVars.frontmostHeight]: frontmostHeight ? `${frontmostHeight}px` : void 0,
+			[DrawerPopupCssVars.swipeStrength]: typeof swipeStrength === "number" && Number.isFinite(swipeStrength) && swipeStrength > 0 ? `${swipeStrength}` : "1"
+		}, resolveStyle(props.style, state()));
+	});
+	const id = createMemo(() => internalProps.id ?? context.store.context.floatingId);
+	const initialFocus = createMemo(() => internalProps.initialFocus ?? (() => context.store.state.popupElement));
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => (event) => {
+		if (COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+	});
+	createEffect(() => id(), (currentId) => {
+		context.store.setPopupId(currentId);
+	});
+	onCleanup(() => {
+		if (context.store.state.popupElement === popupElement) context.store.setPopupElement(null);
+	});
+	const popup = Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			popupElement = element;
+			context.store.setPopupElement(element);
+		}), internalProps.ref],
+		get id() {
+			return id();
+		},
+		get role() {
+			return context.role;
+		},
+		tabIndex: -1,
+		"data-base-ui-focusable": "",
+		get hidden() {
+			return !context.presence.mounted();
+		},
+		get ["aria-labelledby"]() {
+			return context.titleId();
+		},
+		get ["aria-describedby"]() {
+			return context.descriptionId();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onKeyDown
+	}, stateAttributes, others));
+	return FocusManager({
+		get context() {
+			return context.store.context.floatingRoot;
+		},
+		get tree() {
+			return context.tree;
+		},
+		get disabled() {
+			return !context.presence.mounted();
+		},
+		get closeOnFocusOut() {
+			return !context.disablePointerDismissal();
+		},
+		get initialFocus() {
+			return initialFocus();
+		},
+		get returnFocus() {
+			return internalProps.finalFocus;
+		},
+		get modal() {
+			return context.modal() !== false;
+		},
+		restoreFocus: "popup",
+		get openInteractionType() {
+			return context.store.openMethod();
+		},
+		children: popup
+	});
+}
+//#endregion
+//#region src/drawer/provider/DrawerProvider.tsx
+/**
+* Provides a shared context for coordinating global Drawer UI, such as indent/background effects
+* based on whether any Drawer is open. Doesn't render its own HTML element.
+*/
+function DrawerProvider(props) {
+	const [revision, setRevision] = createSignal(0, {
+		equals: false,
+		ownedWrite: true
+	});
+	const openDrawers = /* @__PURE__ */ new Set();
+	const visualStateStore = createVisualStateStore();
+	const active = () => {
+		revision();
+		return openDrawers.size > 0;
+	};
+	function setDrawerOpen(drawer, open) {
+		if (openDrawers.has(drawer) === open) return;
+		if (open) openDrawers.add(drawer);
+		else openDrawers.delete(drawer);
+		setRevision((value) => value + 1);
+	}
+	return DrawerProviderContext({
+		value: {
+			setDrawerOpen,
+			removeDrawer: (drawer) => setDrawerOpen(drawer, false),
+			active,
+			visualStateStore
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+//#endregion
+//#region src/drawer/root/DrawerRoot.tsx
+function createNestedSwipeProgressStore() {
+	let progress = 0;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getSnapshot: () => progress,
+		set(nextProgress) {
+			const resolved = Number.isFinite(nextProgress) ? nextProgress : 0;
+			if (resolved === progress) return;
+			progress = resolved;
+			listeners.forEach((listener) => {
+				listener();
+			});
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/** Groups all parts of the drawer. Doesn't render its own HTML element. */
+function DrawerRoot(props) {
+	const parentDrawer = useDrawerRootContext(true);
+	const [popupHeight, setPopupHeight] = createSignal(0, { ownedWrite: true });
+	const [frontmostHeight, setFrontmostHeight] = createSignal(0, { ownedWrite: true });
+	const [hasNestedDrawer, setHasNestedDrawer] = createSignal(false, { ownedWrite: true });
+	const [nestedSwiping, setNestedSwiping] = createSignal(false, { ownedWrite: true });
+	const nestedSwipeProgressStore = createNestedSwipeProgressStore();
+	const snapPoints = () => props.snapPoints;
+	const resolvedDefaultSnapPoint = () => props.defaultSnapPoint !== void 0 ? props.defaultSnapPoint : snapPoints()?.[0] ?? null;
+	const snapPointControlled = untrack(() => props.snapPoint !== void 0);
+	const [uncontrolledSnapPoint, setUncontrolledSnapPoint] = createSignal(untrack(resolvedDefaultSnapPoint), { ownedWrite: true });
+	const activeSnapPointValue = () => snapPointControlled ? props.snapPoint ?? null : uncontrolledSnapPoint();
+	let nestedDrawerOpen = false;
+	function setActiveSnapPoint(nextSnapPoint, eventDetails) {
+		const resolvedEventDetails = eventDetails ?? createChangeEventDetails("none");
+		props.onSnapPointChange?.(nextSnapPoint, resolvedEventDetails);
+		if (resolvedEventDetails.isCanceled) return;
+		setUncontrolledSnapPoint(() => nextSnapPoint);
+	}
+	const resolvedActiveSnapPoint = () => {
+		const active = activeSnapPointValue();
+		if (snapPointControlled) return active;
+		const points = snapPoints();
+		if (!points || points.length === 0) return active;
+		if (active === null || !points.some((snapPoint) => Object.is(snapPoint, active))) return resolvedDefaultSnapPoint();
+		return active;
+	};
+	function onPopupHeightChange(height) {
+		setPopupHeight(height);
+		if (!nestedDrawerOpen && height > 0) setFrontmostHeight(height);
+	}
+	function onNestedFrontmostHeightChange(height) {
+		if (height > 0) {
+			nestedDrawerOpen = true;
+			setFrontmostHeight(height);
+			return;
+		}
+		nestedDrawerOpen = false;
+		const ownHeight = untrack(popupHeight);
+		if (ownHeight > 0) setFrontmostHeight(ownHeight);
+	}
+	function onNestedSwipeProgressChange(progress) {
+		nestedSwipeProgressStore.set(progress);
+		parentDrawer?.onNestedSwipeProgressChange(progress);
+	}
+	function onNestedSwipingChange(swiping) {
+		setNestedSwiping(swiping);
+		parentDrawer?.onNestedSwipingChange(swiping);
+	}
+	function handleOpenChange(open, eventDetails) {
+		props.onOpenChange?.(open, eventDetails);
+		if (eventDetails.isCanceled) return;
+		const points = untrack(snapPoints);
+		if (!open && points && points.length > 0) setActiveSnapPoint(untrack(resolvedDefaultSnapPoint), createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
+	}
+	const context = {
+		swipeDirection: () => props.swipeDirection ?? "down",
+		swipeAreaActive: { current: false },
+		snapToSequentialPoints: () => props.snapToSequentialPoints ?? false,
+		snapPoints,
+		activeSnapPoint: resolvedActiveSnapPoint,
+		setActiveSnapPoint,
+		frontmostHeight,
+		popupHeight,
+		hasNestedDrawer,
+		onPopupHeightChange,
+		nestedSwiping,
+		nestedSwipeProgressStore,
+		onNestedDrawerPresenceChange: setHasNestedDrawer,
+		onNestedFrontmostHeightChange,
+		onNestedSwipingChange,
+		onNestedSwipeProgressChange,
+		notifyParentFrontmostHeight: parentDrawer ? (height) => parentDrawer.onNestedFrontmostHeightChange(height) : void 0,
+		notifyParentSwipingChange: parentDrawer ? (swiping) => parentDrawer.onNestedSwipingChange(swiping) : void 0,
+		notifyParentSwipeProgressChange: parentDrawer ? (progress) => parentDrawer.onNestedSwipeProgressChange(progress) : void 0,
+		notifyParentHasNestedDrawer: parentDrawer ? (present) => parentDrawer.onNestedDrawerPresenceChange(present) : void 0
+	};
+	const dialogProps = merge(props, { onOpenChange: handleOpenChange });
+	function DrawerDialogRoot() {
+		return renderDialogRoot("drawer", dialogProps, { extraContent: () => DrawerProviderReporter({}) });
+	}
+	return DrawerRootContext({
+		value: context,
+		get children() {
+			return DrawerDialogRoot({});
+		}
+	});
+}
+/**
+* Reports the drawer's open state to the nearest `Drawer.Provider` and wires the Android back
+* gesture through `CloseWatcher`. Renders nothing.
+*/
+function DrawerProviderReporter() {
+	const provider = useDrawerProviderContext();
+	const dialog = useDialogRootContext();
+	const store = dialog.store;
+	const token = {};
+	createEffect(() => store.open(), (open) => {
+		provider?.setDrawerOpen(token, open);
+	});
+	createEffect(() => provider, (current) => () => current?.removeDrawer(token));
+	createEffect(() => ({
+		open: store.open(),
+		topmost: dialog.nestedOpenDialogCount() === 0,
+		popupElement: store.track().popupElement
+	}), (state) => {
+		if (!state.open || !state.topmost || !isAndroid()) return;
+		const CloseWatcherCtor = ownerWindow(state.popupElement).CloseWatcher;
+		if (!CloseWatcherCtor) return;
+		function handleCloseWatcher(event) {
+			if (!store.open()) return;
+			store.setOpen(false, createChangeEventDetails(closeWatcher, event));
+		}
+		const closeWatcher$1 = new CloseWatcherCtor();
+		closeWatcher$1.addEventListener("close", handleCloseWatcher);
+		return () => {
+			closeWatcher$1.removeEventListener("close", handleCloseWatcher);
+			closeWatcher$1.destroy();
+		};
+	});
+	return null;
+}
+//#endregion
+//#region src/drawer/swipe-area/DrawerSwipeAreaDataAttributes.ts
+var DrawerSwipeAreaDataAttributes = /* @__PURE__ */ function(DrawerSwipeAreaDataAttributes) {
+	/** Present when the drawer is open. */
+	DrawerSwipeAreaDataAttributes[DrawerSwipeAreaDataAttributes["open"] = CommonPopupDataAttributes.open] = "open";
+	/** Present when the drawer is closed. */
+	DrawerSwipeAreaDataAttributes[DrawerSwipeAreaDataAttributes["closed"] = CommonPopupDataAttributes.closed] = "closed";
+	/** Present when the swipe area is disabled. */
+	DrawerSwipeAreaDataAttributes["disabled"] = "data-disabled";
+	/**
+	* Indicates the swipe direction.
+	* @type {'up' | 'down' | 'left' | 'right'}
+	*/
+	DrawerSwipeAreaDataAttributes["swipeDirection"] = "data-swipe-direction";
+	/** Present when the drawer is being swiped. */
+	DrawerSwipeAreaDataAttributes["swiping"] = "data-swiping";
+	return DrawerSwipeAreaDataAttributes;
+}({});
+//#endregion
+//#region src/drawer/swipe-area/DrawerSwipeArea.tsx
+var DEFAULT_SWIPE_OPEN_RATIO = .5;
+var MIN_SWIPE_START_DISTANCE = 1;
+var VELOCITY_THRESHOLD = .1;
+var FALLBACK_SWIPE_OPEN_THRESHOLD = 40;
+var SWIPE_AREA_OPEN = { [DrawerSwipeAreaDataAttributes.open]: "" };
+var SWIPE_AREA_CLOSED = { [DrawerSwipeAreaDataAttributes.closed]: "" };
+var SWIPE_AREA_SWIPING = { [DrawerSwipeAreaDataAttributes.swiping]: "" };
+var SWIPE_AREA_DISABLED = { [DrawerSwipeAreaDataAttributes.disabled]: "" };
+var stateAttributesMapping = {
+	open: (value) => value ? SWIPE_AREA_OPEN : SWIPE_AREA_CLOSED,
+	swiping: (value) => value ? SWIPE_AREA_SWIPING : null,
+	swipeDirection: (value) => ({ [DrawerSwipeAreaDataAttributes.swipeDirection]: value }),
+	disabled: (value) => value ? SWIPE_AREA_DISABLED : null
+};
+var oppositeSwipeDirection = {
+	up: "down",
+	down: "up",
+	left: "right",
+	right: "left"
+};
+function resolveTouchAction(direction) {
+	return direction === "left" || direction === "right" ? "pan-y" : "pan-x";
+}
+function isVirtualClick(event) {
+	return event.mozInputSource === 0 ? event.isTrusted : event.detail === 0 && !event.pointerType;
+}
+/** An invisible area that listens for swipe gestures to open the drawer. */
+function DrawerSwipeArea(props) {
+	const context = useDialogRootContext();
+	const store = context.store;
+	const drawer = useDrawerRootContext();
+	const provider = useDrawerProviderContext();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "disabled", "id", "onPointerCancel", "onPointerDown", "onPointerMove", "onPointerUp", "onTouchCancel", "onTouchEnd", "onTouchMove", "onTouchStart", "ref", "style", "swipeDirection");
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const id = createMemo(() => internalProps.id || generatedId);
+	const disabled = createMemo(() => internalProps.disabled ?? false);
+	const [swipeAreaElement, setSwipeAreaElement] = createSignal(null, { ownedWrite: true });
+	const [swipeActive, setSwipeActive] = createSignal(false, { ownedWrite: true });
+	let swipeStartEvent = null;
+	let openedBySwipe = false;
+	const dragDelta = {
+		x: 0,
+		y: 0
+	};
+	let closedOffset = null;
+	let appliedSwipeStyles = false;
+	let swipePopupElement = null;
+	let swipeBackdropElement = null;
+	let popupTransition = null;
+	let releaseGuardCleanup = null;
+	const resolvedSwipeDirection = createMemo(() => internalProps.swipeDirection ?? oppositeSwipeDirection[drawer.swipeDirection()]);
+	const dismissDirection = createMemo(() => oppositeSwipeDirection[resolvedSwipeDirection()]);
+	const enabled = createMemo(() => !disabled() && (!store.open() || swipeActive()));
+	createTriggerRegistration(() => store, id, swipeAreaElement);
+	function resetDragDelta() {
+		dragDelta.x = 0;
+		dragDelta.y = 0;
+	}
+	function disableDismissForSwipe() {
+		releaseGuardCleanup?.();
+		context.outsidePressEnabled.current = false;
+	}
+	function enableDismissAfterRelease() {
+		releaseGuardCleanup?.();
+		const doc = ownerDocument(swipeAreaElement());
+		function restore(event) {
+			if (event?.type === "click" && event.detail !== 0 && !isVirtualClick(event)) return;
+			releaseGuardCleanup = null;
+			doc.removeEventListener("pointerdown", restore, true);
+			doc.removeEventListener("click", restore, true);
+			context.outsidePressEnabled.current = true;
+		}
+		releaseGuardCleanup = restore;
+		doc.addEventListener("pointerdown", restore, true);
+		doc.addEventListener("click", restore, true);
+	}
+	function getPopupSize(popupElement) {
+		const direction = dismissDirection();
+		const size = direction === "left" || direction === "right" ? popupElement.offsetWidth : popupElement.offsetHeight;
+		return size <= 0 ? null : size;
+	}
+	function resolvePopupSize() {
+		const popupElement = store.state.popupElement;
+		return popupElement ? getPopupSize(popupElement) : null;
+	}
+	function resolveClosedOffset(popupElement) {
+		const offset = getPopupSize(popupElement);
+		if (offset == null) return null;
+		const direction = dismissDirection();
+		const isHorizontal = direction === "left" || direction === "right";
+		const transform = getElementTransform(popupElement);
+		const transformOffset = isHorizontal ? transform.x : transform.y;
+		if (Number.isFinite(transformOffset) && Math.abs(transformOffset) > .5) return Math.min(offset, Math.abs(transformOffset));
+		return offset;
+	}
+	function resolveSwipeOpenThreshold() {
+		const popupSize = resolvePopupSize();
+		return popupSize == null ? FALLBACK_SWIPE_OPEN_THRESHOLD : popupSize * DEFAULT_SWIPE_OPEN_RATIO;
+	}
+	function applySwipeMovement() {
+		const popupElement = store.state.popupElement;
+		if (!popupElement) return;
+		if (!store.open() || !context.presence.mounted()) return;
+		closedOffset ??= resolveClosedOffset(popupElement);
+		if (closedOffset === null) return;
+		const direction = resolvedSwipeDirection();
+		const dismiss = dismissDirection();
+		const displacement = Math.max(0, getDisplacement(direction, dragDelta.x, dragDelta.y));
+		const dampedDisplacement = displacement > closedOffset ? closedOffset + Math.sqrt(displacement - closedOffset) : displacement;
+		const movement = (closedOffset - dampedDisplacement) * (dismiss === "left" || dismiss === "up" ? -1 : 1);
+		const isHorizontal = dismiss === "left" || dismiss === "right";
+		const movementX = isHorizontal ? movement : 0;
+		const movementY = isHorizontal ? 0 : movement;
+		const openProgress = Math.max(0, Math.min(1, displacement / closedOffset));
+		const backdropProgress = Math.max(0, Math.min(1, 1 - openProgress));
+		const frontmostHeight = drawer.frontmostHeight();
+		popupElement.style.setProperty(DrawerPopupCssVars.swipeMovementX, `${movementX}px`);
+		popupElement.style.setProperty(DrawerPopupCssVars.swipeMovementY, `${movementY}px`);
+		popupElement.setAttribute(DrawerPopupDataAttributes.swiping, "");
+		swipePopupElement = popupElement;
+		popupTransition ??= popupElement.style.transition;
+		popupElement.style.transition = "none";
+		const backdropElement = context.backdropElement();
+		if (backdropElement) {
+			backdropElement.setAttribute(DrawerPopupDataAttributes.swiping, "");
+			swipeBackdropElement = backdropElement;
+			backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, `${backdropProgress}`);
+			if (openProgress > 0 && frontmostHeight > 0) backdropElement.style.setProperty(DrawerPopupCssVars.height, `${frontmostHeight}px`);
+			else backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+		}
+		provider?.visualStateStore.set({
+			swipeProgress: openProgress,
+			frontmostHeight: openProgress > 0 ? frontmostHeight : 0
+		});
+		appliedSwipeStyles = true;
+		drawer.swipeAreaActive.current = true;
+	}
+	function clearSwipeStyles() {
+		if (swipePopupElement) {
+			swipePopupElement.style.removeProperty(DrawerPopupCssVars.swipeMovementX);
+			swipePopupElement.style.removeProperty(DrawerPopupCssVars.swipeMovementY);
+			swipePopupElement.removeAttribute(DrawerPopupDataAttributes.swiping);
+			if (popupTransition !== null) {
+				swipePopupElement.style.transition = popupTransition;
+				popupTransition = null;
+			}
+		}
+		if (swipeBackdropElement) {
+			swipeBackdropElement.removeAttribute(DrawerPopupDataAttributes.swiping);
+			swipeBackdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, "0");
+			swipeBackdropElement.style.removeProperty(DrawerPopupCssVars.height);
+		}
+		provider?.visualStateStore.set({
+			swipeProgress: 0,
+			frontmostHeight: 0
+		});
+		appliedSwipeStyles = false;
+		swipePopupElement = null;
+		swipeBackdropElement = null;
+		drawer.swipeAreaActive.current = false;
+	}
+	function openDrawer(event) {
+		openedBySwipe = true;
+		store.setOpen(true, createChangeEventDetails(swipe, event, swipeAreaElement() ?? void 0));
+	}
+	function closeDrawer(event) {
+		store.setOpen(false, createChangeEventDetails(swipe, event, swipeAreaElement() ?? void 0));
+	}
+	function resetSwipeInteractionState() {
+		swipeStartEvent = null;
+		openedBySwipe = false;
+		closedOffset = null;
+		setSwipeActive(false);
+	}
+	function finishSwipeInteraction() {
+		resetSwipeInteractionState();
+		enableDismissAfterRelease();
+		resetDragDelta();
+		clearSwipeStyles();
+	}
+	const swipe$2 = createSwipeDismiss({
+		enabled,
+		directions: () => [resolvedSwipeDirection()],
+		element: swipeAreaElement,
+		trackDrag: false,
+		movementCssVars: {
+			x: DrawerPopupCssVars.swipeMovementX,
+			y: DrawerPopupCssVars.swipeMovementY
+		},
+		onSwipeStart(event) {
+			disableDismissForSwipe();
+			swipeStartEvent = event;
+			openedBySwipe = false;
+			setSwipeActive(true);
+			resetDragDelta();
+		},
+		onProgress(_progress, details) {
+			if (!details || !swipeStartEvent) return;
+			dragDelta.x = details.deltaX;
+			dragDelta.y = details.deltaY;
+			const direction = resolvedSwipeDirection();
+			if (details.direction !== direction) return;
+			const displacement = getDisplacement(direction, details.deltaX, details.deltaY);
+			if (!openedBySwipe && displacement < MIN_SWIPE_START_DISTANCE) return;
+			if (!openedBySwipe && !store.open()) openDrawer(swipeStartEvent);
+			applySwipeMovement();
+		},
+		onRelease({ event, direction, deltaX, deltaY, releaseVelocityX, releaseVelocityY }) {
+			const swipeOpenDirection = resolvedSwipeDirection();
+			const displacement = getDisplacement(swipeOpenDirection, deltaX, deltaY);
+			const releaseVelocity = getDisplacement(swipeOpenDirection, releaseVelocityX, releaseVelocityY);
+			const hasEnoughDistance = displacement >= resolveSwipeOpenThreshold();
+			if (direction === swipeOpenDirection && (hasEnoughDistance || releaseVelocity >= VELOCITY_THRESHOLD) && !disabled()) {
+				if (!store.open()) openDrawer(event);
+			} else if (openedBySwipe && store.open()) closeDrawer(event);
+			finishSwipeInteraction();
+			return false;
+		},
+		onCancel: finishSwipeInteraction
+	});
+	createEffect(() => ({
+		active: swipeActive(),
+		open: store.open(),
+		mounted: context.presence.mounted(),
+		popupElement: store.track().popupElement,
+		frontmostHeight: drawer.frontmostHeight()
+	}), (state) => {
+		if (state.active && appliedSwipeStyles) untrack(applySwipeMovement);
+	});
+	createEffect(() => enabled(), (isEnabled) => {
+		if (isEnabled) return;
+		untrack(() => {
+			if (swipeActive()) enableDismissAfterRelease();
+			swipe$2.reset();
+			resetDragDelta();
+			clearSwipeStyles();
+			resetSwipeInteractionState();
+		});
+	});
+	onCleanup(() => {
+		releaseGuardCleanup?.();
+		context.outsidePressEnabled.current = true;
+	});
+	const state = createMemo(() => ({
+		open: store.open(),
+		swiping: swipe$2.swiping(),
+		swipeDirection: resolvedSwipeDirection(),
+		disabled: disabled()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeDialogStyles({
+		"pointer-events": enabled() ? void 0 : "none",
+		"touch-action": resolveTouchAction(resolvedSwipeDirection())
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), stateAttributesMapping));
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => (event) => {
+		if (event.pointerType === "touch") return;
+		swipe$2.pointerHandlers.onPointerDown(event);
+		if (event.cancelable) event.preventDefault();
+	});
+	const onPointerMove = composeEventHandlers(() => internalProps.onPointerMove, () => (event) => {
+		if (event.pointerType === "touch") return;
+		swipe$2.pointerHandlers.onPointerMove(event);
+	});
+	const onPointerUp = composeEventHandlers(() => internalProps.onPointerUp, () => (event) => {
+		if (event.pointerType === "touch") return;
+		swipe$2.pointerHandlers.onPointerUp(event);
+	});
+	const onPointerCancel = composeEventHandlers(() => internalProps.onPointerCancel, () => (event) => {
+		if (event.pointerType === "touch") return;
+		swipe$2.pointerHandlers.onPointerCancel(event);
+	});
+	const onTouchStart = composeEventHandlers(() => internalProps.onTouchStart, () => (event) => swipe$2.touchHandlers.onTouchStart(event));
+	const onTouchMove = composeEventHandlers(() => internalProps.onTouchMove, () => (event) => swipe$2.touchHandlers.onTouchMove(event));
+	const onTouchEnd = composeEventHandlers(() => internalProps.onTouchEnd, () => (event) => swipe$2.touchHandlers.onTouchEnd(event));
+	const onTouchCancel = composeEventHandlers(() => internalProps.onTouchCancel, () => (event) => swipe$2.touchHandlers.onTouchCancel(event));
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => setSwipeAreaElement(element)), internalProps.ref],
+		get id() {
+			return id();
+		},
+		role: "presentation",
+		"aria-hidden": "true",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onPointerDown,
+		onPointerMove,
+		onPointerUp,
+		onPointerCancel,
+		onTouchStart,
+		onTouchMove,
+		onTouchEnd,
+		onTouchCancel
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/drawer/virtual-keyboard-provider/DrawerVirtualKeyboardContext.ts
+var MISSING_CONTEXT = Symbol("DrawerVirtualKeyboardContext");
+var DrawerVirtualKeyboardContext = createContext(MISSING_CONTEXT);
+function useDrawerVirtualKeyboardContext() {
+	const context = useContext(DrawerVirtualKeyboardContext);
+	return context === MISSING_CONTEXT ? void 0 : context;
+}
+//#endregion
+//#region src/drawer/viewport/DrawerViewport.tsx
+var MIN_SWIPE_THRESHOLD = 10;
+var FAST_SWIPE_VELOCITY = .5;
+var SNAP_VELOCITY_THRESHOLD = .5;
+var SNAP_VELOCITY_MULTIPLIER = 300;
+var MAX_SNAP_VELOCITY = 4;
+var MIN_SWIPE_RELEASE_VELOCITY = .2;
+var MAX_SWIPE_RELEASE_VELOCITY = 4;
+var MIN_SWIPE_RELEASE_DURATION_MS = 80;
+var MAX_SWIPE_RELEASE_DURATION_MS = 360;
+var MIN_SWIPE_RELEASE_SCALAR = .1;
+var AXIS_LOCK_SLOP = 6;
+var AXIS_LOCK_BIAS = 2;
+var DRAWER_CONTENT_SELECTOR = `[${DRAWER_CONTENT_ATTRIBUTE}]`;
+/** A positioning container for the drawer popup that can be made scrollable. */
+function DrawerViewport(props) {
+	const context = useDialogRootContext();
+	const store = context.store;
+	const drawer = useDrawerRootContext();
+	const provider = useDrawerProviderContext();
+	const snap = createDrawerSnapPoints();
+	const virtualKeyboard = useDrawerVirtualKeyboardContext();
+	const internalProps = props;
+	const others = omit(props, "children", "onPointerCancel", "onPointerDown", "onPointerMove", "onPointerUp", "onTouchCancel", "onTouchEnd", "onTouchStart");
+	const open = () => store.open();
+	const mounted = () => context.presence.mounted();
+	const nestedDrawerOpen = () => context.nestedOpenDrawerCount() > 0;
+	const swipeDirection = () => drawer.swipeDirection();
+	const scrollAxis = () => swipeDirection() === "left" || swipeDirection() === "right" ? "horizontal" : "vertical";
+	const crossScrollAxis = () => scrollAxis() === "vertical" ? "horizontal" : "vertical";
+	const [swipeRelease, setSwipeRelease] = createSignal(null, { ownedWrite: true });
+	let pendingSwipeCloseSnapPoint;
+	let controlledDismissFrame;
+	let swipingNow = false;
+	let nestedSwipeActive = false;
+	let lastPointerType = "";
+	let ignoreNextTouchStartFromPen = false;
+	let ignoreTouchSwipe = false;
+	let touchScrollState = null;
+	const snapPointRange = createMemo(() => {
+		const points = drawer.snapPoints();
+		const resolved = snap.resolvedSnapPoints();
+		const direction = swipeDirection();
+		if (!points || points.length < 2 || resolved.length < 2 || direction !== "down" && direction !== "up") return null;
+		const offsets = resolved.map((point) => point.offset).sort((a, b) => a - b);
+		return {
+			minOffset: offsets[0],
+			range: offsets[1] - offsets[0]
+		};
+	});
+	const snapPointProgress = createMemo(() => {
+		const range = snapPointRange();
+		const offset = snap.activeSnapPointOffset();
+		if (!range || offset === null) return null;
+		return clamp((offset - range.minOffset) / range.range, 0, 1);
+	});
+	const swipeDirections = createMemo(() => {
+		const points = drawer.snapPoints();
+		const direction = swipeDirection();
+		if (points && points.length > 0 && (direction === "down" || direction === "up")) return direction === "down" ? ["down", "up"] : ["up", "down"];
+		return [direction];
+	});
+	function setSwipeDismissed(dismissed) {
+		store.state.popupElement?.toggleAttribute(DrawerPopupDataAttributes.swipeDismiss, dismissed);
+		context.backdropElement()?.toggleAttribute(DrawerPopupDataAttributes.swipeDismiss, dismissed);
+	}
+	function clearSwipeRelease() {
+		setSwipeDismissed(false);
+		store.state.popupElement?.removeAttribute(TransitionStatusDataAttributes.endingStyle);
+		setSwipeRelease(null);
+	}
+	function finishNestedSwipe() {
+		if (!nestedSwipeActive) return;
+		nestedSwipeActive = false;
+		drawer.notifyParentSwipingChange?.(false);
+	}
+	function applySwipeProgress(resolvedProgress, shouldTrackProgress, notifyParent) {
+		const isActive = open() && !context.nested && shouldTrackProgress;
+		const progress = isActive ? resolvedProgress : 0;
+		const nestedSwipeProgress = open() && shouldTrackProgress ? resolvedProgress : 0;
+		const frontmostHeight = drawer.frontmostHeight();
+		if (notifyParent && drawer.notifyParentSwipeProgressChange) {
+			drawer.notifyParentSwipeProgressChange(nestedSwipeProgress);
+			if (nestedSwipeProgress <= 0) finishNestedSwipe();
+		}
+		provider?.visualStateStore.set({
+			swipeProgress: progress,
+			frontmostHeight: progress > 0 ? frontmostHeight : 0
+		});
+		const backdropElement = context.backdropElement();
+		if (!backdropElement) return;
+		const showProgress = isActive && progress > 0;
+		backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, showProgress ? `${progress}` : "0");
+		if (showProgress && frontmostHeight > 0) backdropElement.style.setProperty(DrawerPopupCssVars.height, `${frontmostHeight}px`);
+		else backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+	}
+	function resolveSwipeRelease(popupElement, direction, deltaX, deltaY, velocityX, velocityY, releaseVelocityX, releaseVelocityY) {
+		const size = getBaseSwipeSize(popupElement, direction);
+		if (size <= 0) return null;
+		const points = drawer.snapPoints();
+		const translationAlongDirection = ((direction === "down" || direction === "up") && points && points.length > 0 ? snap.activeSnapPointOffset() ?? 0 : 0) + getDisplacement(direction, deltaX, deltaY);
+		const remainingDistance = Math.max(0, size - translationAlongDirection);
+		if (remainingDistance <= 0) return null;
+		const releaseVelocity = getDisplacement(direction, releaseVelocityX, releaseVelocityY);
+		const directionalVelocity = Math.abs(releaseVelocity) > 0 ? releaseVelocity : getDisplacement(direction, velocityX, velocityY);
+		if (directionalVelocity <= MIN_SWIPE_RELEASE_VELOCITY) return null;
+		const clampedVelocity = clamp(directionalVelocity, MIN_SWIPE_RELEASE_VELOCITY, MAX_SWIPE_RELEASE_VELOCITY);
+		return MIN_SWIPE_RELEASE_SCALAR + (clamp(remainingDistance / clampedVelocity, MIN_SWIPE_RELEASE_DURATION_MS, MAX_SWIPE_RELEASE_DURATION_MS) - MIN_SWIPE_RELEASE_DURATION_MS) / 280 * .9;
+	}
+	function updateNestedSwipeActive(details) {
+		if (nestedSwipeActive || !details) return;
+		const direction = details.direction ?? swipeDirection();
+		if (Math.abs(getDisplacement(direction, details.deltaX, details.deltaY)) < MIN_SWIPE_THRESHOLD) return;
+		nestedSwipeActive = true;
+		drawer.notifyParentSwipingChange?.(true);
+	}
+	const swipe$1 = createSwipeDismiss({
+		enabled: () => mounted() && !nestedDrawerOpen(),
+		directions: swipeDirections,
+		element: () => store.track().popupElement,
+		ignoreSelectorWhenTouch: false,
+		ignoreScrollableAncestors: true,
+		movementCssVars: {
+			x: DrawerPopupCssVars.swipeMovementX,
+			y: DrawerPopupCssVars.swipeMovementY
+		},
+		swipeThreshold: ({ element, direction }) => getBaseSwipeThreshold(element, direction),
+		onSwipeStart(event) {
+			if ("touches" in event || event.pointerType === "touch") return;
+			const popupElement = store.state.popupElement;
+			const selection = ownerDocument(popupElement).getSelection?.();
+			if (!selection || selection.isCollapsed) return;
+			const anchorElement = isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+			const focusElement = isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+			if (!contains(popupElement, anchorElement) && !contains(popupElement, focusElement)) return;
+			selection.removeAllRanges();
+		},
+		onSwipingChange(swiping) {
+			swipingNow = swiping;
+			setBackdropSwipingAttribute(context.backdropElement(), swiping);
+			if (!swiping && !drawer.notifyParentSwipeProgressChange) finishNestedSwipe();
+		},
+		canStart(position, details) {
+			const popupElement = store.state.popupElement;
+			if (!popupElement) return false;
+			const elementAtPoint = getElementAtPoint(popupElement.getRootNode(), position.x, position.y);
+			if (!elementAtPoint || !contains(popupElement, elementAtPoint)) return false;
+			const nativeEvent = details.nativeEvent;
+			if (("touches" in nativeEvent || nativeEvent.pointerType === "touch") && shouldIgnoreSwipeForTextSelection(popupElement.ownerDocument, popupElement)) return false;
+			return true;
+		},
+		onProgress(progress, details) {
+			updateNestedSwipeActive(details);
+			const points = drawer.snapPoints();
+			const hasSnapPoints = Boolean(points && points.length > 0);
+			if (swipingNow && swipeDirection() === "down" && hasSnapPoints && details) {
+				const popupElement = store.state.popupElement;
+				if (popupElement) {
+					popupElement.style.removeProperty("transform");
+					popupElement.style.setProperty(DrawerPopupCssVars.swipeMovementY, `${getSnapPointSwipeMovement(snap.activeSnapPointOffset() ?? 0, details.deltaY)}px`);
+				}
+			}
+			let resolvedProgress = progress;
+			const range = snapPointRange();
+			const popupHeight = snap.popupHeight();
+			if (range && popupHeight > 0) {
+				const baseOffset = snap.activeSnapPointOffset() ?? range.minOffset;
+				const offsetToProgress = (nextOffset) => clamp((nextOffset - range.minOffset) / range.range, 0, 1);
+				if (details && Number.isFinite(details.deltaY)) resolvedProgress = offsetToProgress(clamp(baseOffset + details.deltaY, 0, popupHeight));
+				else {
+					const progressFromSnapPoint = snapPointProgress();
+					if (progressFromSnapPoint !== null) resolvedProgress = progressFromSnapPoint;
+				}
+			}
+			applySwipeProgress(resolvedProgress, true, true);
+		},
+		onRelease({ event, deltaX, deltaY, direction, velocityX, velocityY, releaseVelocityX, releaseVelocityY }) {
+			const popupElement = store.state.popupElement;
+			if (!popupElement) {
+				clearSwipeRelease();
+				return;
+			}
+			function startSwipeRelease(resolvedDirection) {
+				finishNestedSwipe();
+				setSwipeDismissed(true);
+				popupElement.style.removeProperty("transition");
+				popupElement.setAttribute(TransitionStatusDataAttributes.endingStyle, "");
+				setSwipeRelease(resolveSwipeRelease(popupElement, resolvedDirection, deltaX, deltaY, velocityX, velocityY, releaseVelocityX, releaseVelocityY));
+				flush();
+			}
+			const points = drawer.snapPoints();
+			const currentSwipeDirection = swipeDirection();
+			if (!points || points.length === 0) {
+				if (!direction) {
+					clearSwipeRelease();
+					return;
+				}
+				const directionalDelta = getDisplacement(direction, deltaX, deltaY);
+				if (directionalDelta <= 0) {
+					clearSwipeRelease();
+					return false;
+				}
+				if (getDisplacement(direction, velocityX, velocityY) >= FAST_SWIPE_VELOCITY) {
+					startSwipeRelease(direction);
+					return true;
+				}
+				const shouldClose = directionalDelta > getBaseSwipeThreshold(popupElement, direction);
+				if (shouldClose) startSwipeRelease(direction);
+				else clearSwipeRelease();
+				return shouldClose;
+			}
+			if (currentSwipeDirection !== "down" && currentSwipeDirection !== "up") {
+				clearSwipeRelease();
+				return;
+			}
+			const popupHeight = snap.popupHeight();
+			if (!popupHeight) {
+				clearSwipeRelease();
+				return false;
+			}
+			const resolvedSnapPoints = snap.resolvedSnapPoints();
+			if (resolvedSnapPoints.length === 0) {
+				clearSwipeRelease();
+				return;
+			}
+			const dragDelta = currentSwipeDirection === "down" ? deltaY : -deltaY;
+			const dragDirection = Math.sign(dragDelta);
+			const releaseDirectionalVelocity = currentSwipeDirection === "down" ? releaseVelocityY : -releaseVelocityY;
+			const fallbackDirectionalVelocity = currentSwipeDirection === "down" ? velocityY : -velocityY;
+			let resolvedDirectionalVelocity = releaseDirectionalVelocity;
+			if (dragDirection !== 0 && Math.abs(dragDelta) >= MIN_SWIPE_THRESHOLD) {
+				const velocityDirection = Math.sign(resolvedDirectionalVelocity);
+				if (velocityDirection !== 0 && velocityDirection !== dragDirection) resolvedDirectionalVelocity = fallbackDirectionalVelocity;
+			}
+			const currentOffset = snap.activeSnapPointOffset() ?? 0;
+			const dragTargetOffset = clamp(currentOffset + dragDelta, 0, popupHeight);
+			const velocityOffset = Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? clamp(resolvedDirectionalVelocity, -4, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
+			const targetOffset = drawer.snapToSequentialPoints() ? dragTargetOffset : clamp(dragTargetOffset + velocityOffset, 0, popupHeight);
+			const snapPointEventDetails = createChangeEventDetails(swipe, event);
+			const closeFromSnapPoints = () => {
+				pendingSwipeCloseSnapPoint = snap.activeSnapPoint();
+				drawer.setActiveSnapPoint(null, snapPointEventDetails);
+				startSwipeRelease(currentSwipeDirection);
+				return true;
+			};
+			if (drawer.snapToSequentialPoints()) {
+				const orderedSnapPoints = [...resolvedSnapPoints].sort((first, second) => first.offset - second.offset);
+				const orderedOffsets = orderedSnapPoints.map((point) => point.offset);
+				const currentIndex = closestSnapPointIndex(orderedOffsets, currentOffset);
+				let targetSnapPoint = orderedSnapPoints[closestSnapPointIndex(orderedOffsets, targetOffset)];
+				const velocityDirection = Math.sign(resolvedDirectionalVelocity);
+				const shouldAdvance = dragDirection !== 0 && velocityDirection !== 0 && velocityDirection === dragDirection && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD;
+				let effectiveTargetOffset = targetOffset;
+				if (shouldAdvance) {
+					const adjacentIndex = clamp(currentIndex + dragDirection, 0, orderedSnapPoints.length - 1);
+					if (adjacentIndex !== currentIndex) {
+						const adjacentPoint = orderedSnapPoints[adjacentIndex];
+						if (dragDirection > 0 ? targetOffset < adjacentPoint.offset : targetOffset > adjacentPoint.offset) {
+							targetSnapPoint = adjacentPoint;
+							effectiveTargetOffset = adjacentPoint.offset;
+						}
+					} else if (dragDirection > 0) return closeFromSnapPoints();
+				}
+				if (Math.abs(effectiveTargetOffset - popupHeight) < Math.abs(effectiveTargetOffset - targetSnapPoint.offset)) return closeFromSnapPoints();
+				drawer.setActiveSnapPoint(targetSnapPoint.value, snapPointEventDetails);
+				clearSwipeRelease();
+				return false;
+			}
+			if (resolvedDirectionalVelocity >= FAST_SWIPE_VELOCITY && dragDelta > 0) return closeFromSnapPoints();
+			const closestSnapPoint = resolvedSnapPoints[closestSnapPointIndex(resolvedSnapPoints.map((point) => point.offset), targetOffset)];
+			if (Math.abs(targetOffset - popupHeight) < Math.abs(targetOffset - closestSnapPoint.offset)) return closeFromSnapPoints();
+			drawer.setActiveSnapPoint(closestSnapPoint.value, snapPointEventDetails);
+			clearSwipeRelease();
+			return false;
+		},
+		onDismiss(event) {
+			provider?.visualStateStore.set({
+				swipeProgress: 0,
+				frontmostHeight: 0
+			});
+			const backdropElement = context.backdropElement();
+			if (backdropElement) {
+				backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, "0");
+				backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+			}
+			const dismissEventDetails = createChangeEventDetails(swipe, event);
+			store.setOpen(false, dismissEventDetails);
+			if (dismissEventDetails.isCanceled) {
+				if (pendingSwipeCloseSnapPoint !== void 0) drawer.setActiveSnapPoint(pendingSwipeCloseSnapPoint, createChangeEventDetails(swipe, event));
+				pendingSwipeCloseSnapPoint = void 0;
+				swipe$1.reset();
+				clearSwipeRelease();
+				return;
+			}
+			if (store.open()) {
+				const savedEvent = event;
+				controlledDismissFrame = requestAnimationFrame(() => {
+					controlledDismissFrame = void 0;
+					if (store.open()) {
+						if (pendingSwipeCloseSnapPoint !== void 0) drawer.setActiveSnapPoint(pendingSwipeCloseSnapPoint, createChangeEventDetails(swipe, savedEvent));
+						pendingSwipeCloseSnapPoint = void 0;
+						clearSwipeRelease();
+						swipe$1.reset();
+					} else pendingSwipeCloseSnapPoint = void 0;
+				});
+				return;
+			}
+			pendingSwipeCloseSnapPoint = void 0;
+			setSwipeDismissed(true);
+		}
+	});
+	createEffect(() => ({
+		mounted: mounted(),
+		nestedDrawerOpen: nestedDrawerOpen(),
+		open: open(),
+		rootElement: context.viewportElement() ?? store.track().popupElement,
+		axis: scrollAxis(),
+		direction: swipeDirection()
+	}), (state) => {
+		const rootElement = state.rootElement;
+		if (!rootElement) return;
+		const isVerticalScrollAxis = state.axis === "vertical";
+		const doc = ownerDocument(rootElement);
+		function processTouchMove(event, touchState, touch) {
+			const drawerAxisDelta = isVerticalScrollAxis ? touch.clientY - touchState.lastY : touch.clientX - touchState.lastX;
+			if (event.touches.length === 2) return;
+			if (shouldIgnoreSwipeForTextSelection(doc, rootElement)) return;
+			if (!state.open || !state.mounted || state.nestedDrawerOpen) return;
+			if (shouldYieldTouchMove(touchState, event, touch, isVerticalScrollAxis)) return;
+			const scrollTarget = touchState.scrollTarget;
+			if (!scrollTarget || scrollTarget === doc.documentElement || scrollTarget === doc.body) {
+				if (event.cancelable) event.preventDefault();
+				event.stopPropagation();
+				swipe$1.moveNative(event, rootElement);
+				return;
+			}
+			if (!hasScrollableContentOnAxis(scrollTarget, state.axis)) {
+				if (event.cancelable) event.preventDefault();
+				event.stopPropagation();
+				return;
+			}
+			if (drawerAxisDelta !== 0) {
+				const canSwipeFromScrollEdge = canSwipeFromScrollEdgeOnMove(scrollTarget, state.axis, state.direction, drawerAxisDelta);
+				if (!touchState.allowSwipe) {
+					if (event.cancelable && canSwipeFromScrollEdge) {
+						touchState.allowSwipe = true;
+						event.preventDefault();
+					} else touchState.allowSwipe = false;
+				} else if (event.cancelable) event.preventDefault();
+			}
+			if (touchState.allowSwipe === true) {
+				event.stopPropagation();
+				swipe$1.moveNative(event, rootElement);
+			}
+		}
+		function handleNativeTouchMove(event) {
+			virtualKeyboard?.onTouchMove(event);
+			if (ignoreTouchSwipe) return;
+			const touch = event.touches[0];
+			if (!touch || !touchScrollState) return;
+			processTouchMove(event, touchScrollState, touch);
+			touchScrollState.lastX = touch.clientX;
+			touchScrollState.lastY = touch.clientY;
+		}
+		doc.addEventListener("touchmove", handleNativeTouchMove, {
+			passive: false,
+			capture: true
+		});
+		return () => doc.removeEventListener("touchmove", handleNativeTouchMove, { capture: true });
+	});
+	createEffect(() => ({
+		range: snapPointRange(),
+		swiping: swipe$1.swiping(),
+		open: open(),
+		nested: context.nested,
+		progress: snapPointProgress(),
+		frontmostHeight: drawer.frontmostHeight()
+	}), (state) => {
+		if (!state.range || state.swiping) return;
+		untrack(() => applySwipeProgress(!state.open || state.nested ? 0 : state.progress ?? 0, true, false));
+	});
+	createEffect(() => open(), (isOpen) => {
+		if (!drawer.notifyParentSwipeProgressChange) return;
+		if (!isOpen) drawer.notifyParentSwipeProgressChange(0);
+		return () => drawer.notifyParentSwipeProgressChange?.(0);
+	});
+	createEffect(() => open(), (isOpen) => {
+		if (!isOpen) return;
+		untrack(() => {
+			if (!drawer.swipeAreaActive.current) swipe$1.reset();
+			clearSwipeRelease();
+		});
+	});
+	onCleanup(() => {
+		if (controlledDismissFrame !== void 0) cancelAnimationFrame(controlledDismissFrame);
+		provider?.visualStateStore.set({
+			swipeProgress: 0,
+			frontmostHeight: 0
+		});
+		setBackdropSwipingAttribute(context.backdropElement(), false);
+		finishNestedSwipe();
+	});
+	const viewportContext = {
+		swiping: swipe$1.swiping,
+		getDragStyles: swipe$1.getDragStyles,
+		swipeStrength: swipeRelease,
+		setSwipeDismissed
+	};
+	function resetTouchSwipeState(ignoreSwipe) {
+		ignoreTouchSwipe = ignoreSwipe;
+		touchScrollState = null;
+	}
+	function resetTouchTrackingState() {
+		resetTouchSwipeState(false);
+		lastPointerType = "";
+		ignoreNextTouchStartFromPen = false;
+	}
+	function handlePointerEnd(event) {
+		lastPointerType = "";
+		return event.pointerType !== "touch";
+	}
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => (event) => {
+		lastPointerType = event.pointerType;
+		ignoreNextTouchStartFromPen = event.pointerType === "pen";
+		if (!open() || !mounted() || nestedDrawerOpen()) return;
+		const currentTarget = event.currentTarget;
+		const elementAtPoint = getElementAtPoint(currentTarget.getRootNode(), event.clientX, event.clientY);
+		if (isSwipeIgnoredTarget(elementAtPoint) || isDrawerContentTarget(elementAtPoint)) return;
+		if (event.pointerType === "touch") return;
+		swipe$1.pointerHandlers.onPointerDown(event);
+	});
+	const onPointerMove = composeEventHandlers(() => internalProps.onPointerMove, () => (event) => {
+		if (event.pointerType === "touch") return;
+		swipe$1.pointerHandlers.onPointerMove(event);
+	});
+	const onPointerUp = composeEventHandlers(() => internalProps.onPointerUp, () => (event) => {
+		if (handlePointerEnd(event)) swipe$1.pointerHandlers.onPointerUp(event);
+	});
+	const onPointerCancel = composeEventHandlers(() => internalProps.onPointerCancel, () => (event) => {
+		if (handlePointerEnd(event)) swipe$1.pointerHandlers.onPointerCancel(event);
+	});
+	const onTouchStart = composeEventHandlers(() => internalProps.onTouchStart, () => (event) => {
+		if (lastPointerType === "pen" && ignoreNextTouchStartFromPen) {
+			ignoreNextTouchStartFromPen = false;
+			resetTouchSwipeState(false);
+			return;
+		}
+		if (!open() || !mounted() || nestedDrawerOpen()) {
+			resetTouchSwipeState(false);
+			return;
+		}
+		const touch = event.touches[0];
+		if (!touch) return;
+		const rootElement = event.currentTarget;
+		if (isEventOnRangeInput(event, ownerWindow(rootElement))) {
+			resetTouchSwipeState(false);
+			return;
+		}
+		const elementAtPoint = getElementAtPoint(rootElement.getRootNode(), touch.clientX, touch.clientY);
+		const eventTarget = getEventTarget(event);
+		const target = isElement(eventTarget) ? eventTarget : rootElement;
+		if (!contains(rootElement, target)) {
+			resetTouchSwipeState(true);
+			return;
+		}
+		virtualKeyboard?.onTouchStart(event);
+		if (isSwipeIgnoredTarget(elementAtPoint)) {
+			resetTouchSwipeState(true);
+			return;
+		}
+		ignoreTouchSwipe = false;
+		const axis = scrollAxis();
+		const scrollTarget = findScrollableTouchTarget(target, rootElement, axis);
+		const hasCrossAxisScrollableContent = findScrollableTouchTarget(target, rootElement, crossScrollAxis()) != null;
+		let allowSwipe = null;
+		if (scrollTarget) allowSwipe = isAtSwipeStartEdge(scrollTarget, axis, swipeDirection()) ? null : false;
+		touchScrollState = {
+			startX: touch.clientX,
+			startY: touch.clientY,
+			lastX: touch.clientX,
+			lastY: touch.clientY,
+			scrollTarget,
+			hasCrossAxisScrollableContent,
+			allowSwipe,
+			preserveNativeCrossAxisScroll: false,
+			drawerAxisAttributed: false
+		};
+		swipe$1.touchHandlers.onTouchStart(event);
+	});
+	const onTouchEnd = composeEventHandlers(() => internalProps.onTouchEnd, () => (event) => {
+		virtualKeyboard?.onTouchEnd(event);
+		resetTouchTrackingState();
+		swipe$1.touchHandlers.onTouchEnd(event);
+	});
+	const onTouchCancel = composeEventHandlers(() => internalProps.onTouchCancel, () => (event) => {
+		virtualKeyboard?.onTouchCancel();
+		resetTouchTrackingState();
+		swipe$1.touchHandlers.onTouchCancel(event);
+	});
+	return DialogViewport(mergeProps(others, {
+		onPointerDown,
+		onPointerMove,
+		onPointerUp,
+		onPointerCancel,
+		onTouchStart,
+		onTouchEnd,
+		onTouchCancel,
+		"data-nested-dialog-open": void 0,
+		get children() {
+			return DrawerViewportContext({
+				value: viewportContext,
+				get children() {
+					return props.children;
+				}
+			});
+		}
+	}));
+}
+function setBackdropSwipingAttribute(backdropElement, swiping) {
+	backdropElement?.toggleAttribute(DrawerPopupDataAttributes.swiping, swiping);
+}
+function isSwipeIgnoredTarget(target) {
+	return Boolean(target?.closest(BASE_UI_SWIPE_IGNORE_SELECTOR));
+}
+function isDrawerContentTarget(target) {
+	return Boolean(target?.closest(DRAWER_CONTENT_SELECTOR));
+}
+function getBaseSwipeSize(element, direction) {
+	return direction === "left" || direction === "right" ? element.offsetWidth : element.offsetHeight;
+}
+function getBaseSwipeThreshold(element, direction) {
+	return Math.max(getBaseSwipeSize(element, direction) * .5, MIN_SWIPE_THRESHOLD);
+}
+function isRangeInput(target, win) {
+	return target instanceof win.HTMLInputElement && target.type === "range";
+}
+function isTextSelectionControl(target) {
+	return target.tagName === "INPUT" || target.tagName === "TEXTAREA";
+}
+function hasExpandedSelectionWithinTarget(selection, target) {
+	const anchorElement = isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+	const focusElement = isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+	return selection.containsNode(target, true) || contains(target, anchorElement) || contains(target, focusElement);
+}
+function shouldIgnoreSwipeForTextSelection(doc, rootElement) {
+	const active = activeElement(doc);
+	if (active && contains(rootElement, active) && isTextSelectionControl(active)) {
+		const { selectionStart, selectionEnd } = active;
+		if (selectionStart != null && selectionEnd != null && selectionStart < selectionEnd) return true;
+	}
+	const selection = doc.getSelection?.();
+	if (!selection || selection.isCollapsed) return false;
+	return hasExpandedSelectionWithinTarget(selection, rootElement);
+}
+function isEventOnRangeInput(event, win) {
+	return event.composedPath().some((pathTarget) => isRangeInput(pathTarget, win));
+}
+/**
+* Arbitrates a touchmove between the drawer swipe and a native cross-axis scroll. Returns `true`
+* when the move must be left alone — either because the cross axis already won the gesture, or
+* because neither axis has passed the slop yet and the gesture cannot be attributed.
+*/
+function shouldYieldTouchMove(touchState, event, touch, isVerticalScrollAxis) {
+	if (touchState.preserveNativeCrossAxisScroll) return true;
+	if (touchState.drawerAxisAttributed || touchState.allowSwipe === true || !touchState.hasCrossAxisScrollableContent) return false;
+	if (!event.cancelable) {
+		touchState.preserveNativeCrossAxisScroll = true;
+		return true;
+	}
+	const drawerAxisGestureDelta = isVerticalScrollAxis ? touch.clientY - touchState.startY : touch.clientX - touchState.startX;
+	const crossAxisGestureDelta = isVerticalScrollAxis ? touch.clientX - touchState.startX : touch.clientY - touchState.startY;
+	const absDrawerAxisGestureDelta = Math.abs(drawerAxisGestureDelta);
+	const absCrossAxisGestureDelta = Math.abs(crossAxisGestureDelta);
+	if (absCrossAxisGestureDelta >= AXIS_LOCK_SLOP && absCrossAxisGestureDelta > absDrawerAxisGestureDelta + AXIS_LOCK_BIAS) {
+		touchState.preserveNativeCrossAxisScroll = true;
+		return true;
+	}
+	if (absDrawerAxisGestureDelta >= AXIS_LOCK_SLOP) {
+		touchState.drawerAxisAttributed = true;
+		return false;
+	}
+	return true;
+}
+function hasScrollableContentOnAxis(scrollTarget, axis) {
+	return getScrollMetrics(scrollTarget, axis).max > 0;
+}
+function getScrollMetrics(scrollTarget, axis) {
+	if (axis === "vertical") return {
+		offset: scrollTarget.scrollTop,
+		max: Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight)
+	};
+	return {
+		offset: scrollTarget.scrollLeft,
+		max: Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth)
+	};
+}
+function isAtSwipeStartEdge(scrollTarget, axis, direction) {
+	const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+	const { offset, max } = getScrollMetrics(scrollTarget, axis);
+	return dismissFromStartEdge ? offset <= 0 : offset >= max;
+}
+function canSwipeFromScrollEdgeOnMove(scrollTarget, axis, direction, delta) {
+	if (!(shouldDismissFromStartEdge(direction, axis) ? delta > 0 : delta < 0)) return false;
+	return isAtSwipeStartEdge(scrollTarget, axis, direction);
+}
+function shouldDismissFromStartEdge(direction, axis) {
+	return axis === "vertical" ? direction === "down" : direction === "right";
+}
+//#endregion
+//#region src/drawer/viewport/DrawerViewportCssVars.ts
+var DrawerViewportCssVars = /* @__PURE__ */ function(DrawerViewportCssVars) {
+	/**
+	* The software keyboard inset, measured from the bottom edge of the layout viewport.
+	* Present only when the drawer is wrapped in `Drawer.VirtualKeyboardProvider`.
+	* @type {CSS length}
+	*/
+	DrawerViewportCssVars["keyboardInset"] = "--drawer-keyboard-inset";
+	return DrawerViewportCssVars;
+}({});
+//#endregion
+//#region src/drawer/virtual-keyboard-provider/DrawerVirtualKeyboardProvider.tsx
+var KEYBOARD_RESIZE_THRESHOLD = 60;
+var KEYBOARD_VISIBILITY_MARGIN = 16;
+var KEYBOARD_SCROLL_SLACK = 48;
+var KEYBOARD_REALIGN_INTERVAL = 150;
+var KEYBOARD_REALIGN_MAX_PASSES = 4;
+var KEYBOARD_SETTLE_FRAME_LIMIT = 60;
+var INPUT_TAP_MOVE_THRESHOLD = 10;
+var INPUT_TAP_HIT_SLOP = 16;
+var KEYBOARD_INPUT_TYPES = /* @__PURE__ */ new Set([
+	"email",
+	"number",
+	"password",
+	"search",
+	"tel",
+	"text",
+	"url"
+]);
+/**
+* Returned by the point-based resolver when the lift point lands on another interactive/label
+* element. It signals that the tap was intentionally rejected, so the caller must NOT fall back to
+* the touchstart target (`touchend.target` stays at the touchstart node on mobile) — doing so
+* would steal a tap meant for that element.
+*/
+var KEYBOARD_TAP_BLOCKED = Symbol("KeyboardTapBlocked");
+/**
+* Provides keyboard-aware focus and scroll handling for bottom-sheet drawers with form fields.
+*/
+function DrawerVirtualKeyboardProvider(props) {
+	const context = useDialogRootContext();
+	const store = context.store;
+	let pendingKeyboardFocusMoved = false;
+	let keyboardTouchStart = null;
+	let focusedKeyboardTarget = null;
+	let keyboardScrollAdjustment = null;
+	let programmaticKeyboardFocus = false;
+	let keyboardFocusFrame;
+	let keyboardRealignTimeout;
+	function cancelKeyboardFocusFrame() {
+		if (keyboardFocusFrame !== void 0) {
+			cancelAnimationFrame(keyboardFocusFrame);
+			keyboardFocusFrame = void 0;
+		}
+	}
+	function clearKeyboardRealignTimeout() {
+		if (keyboardRealignTimeout !== void 0) {
+			clearTimeout(keyboardRealignTimeout);
+			keyboardRealignTimeout = void 0;
+		}
+	}
+	function restoreKeyboardScrollAdjustment() {
+		const adjustment = keyboardScrollAdjustment;
+		if (!adjustment) return;
+		adjustment.element.style.overflowAnchor = adjustment.overflowAnchor;
+		adjustment.element.style.paddingBottom = adjustment.paddingBottom;
+		adjustment.element.style.scrollPaddingBottom = adjustment.scrollPaddingBottom;
+		keyboardScrollAdjustment = null;
+	}
+	function setKeyboardScrollSlack(element, slack) {
+		const roundedSlack = Math.max(0, Math.ceil(slack));
+		let adjustment = keyboardScrollAdjustment;
+		if (adjustment && !adjustment.element.isConnected) {
+			restoreKeyboardScrollAdjustment();
+			adjustment = null;
+		}
+		if (roundedSlack === 0) {
+			restoreKeyboardScrollAdjustment();
+			return;
+		}
+		if (adjustment && adjustment.element !== element) {
+			restoreKeyboardScrollAdjustment();
+			adjustment = null;
+		}
+		if (!adjustment) {
+			const styles = ownerWindow(element).getComputedStyle(element);
+			adjustment = {
+				element,
+				overflowAnchor: element.style.overflowAnchor,
+				paddingBottom: element.style.paddingBottom,
+				scrollPaddingBottom: element.style.scrollPaddingBottom,
+				computedPaddingBottom: Number.parseFloat(styles.paddingBottom) || 0,
+				computedScrollPaddingBottom: Number.parseFloat(styles.scrollPaddingBottom) || 0
+			};
+			keyboardScrollAdjustment = adjustment;
+		}
+		element.style.overflowAnchor = "none";
+		element.style.paddingBottom = `${adjustment.computedPaddingBottom + roundedSlack}px`;
+		element.style.scrollPaddingBottom = `${adjustment.computedScrollPaddingBottom + KEYBOARD_VISIBILITY_MARGIN}px`;
+	}
+	function animateKeyboardScroll(element, scrollTop) {
+		const behavior = ownerWindow(element).matchMedia?.("(prefers-reduced-motion: reduce)")?.matches ? "auto" : "smooth";
+		element.scrollTo({
+			top: scrollTop,
+			behavior
+		});
+	}
+	function resetTouchTrackingState() {
+		pendingKeyboardFocusMoved = false;
+		keyboardTouchStart = null;
+	}
+	createEffect(() => ({
+		mounted: context.presence.mounted(),
+		open: store.open(),
+		modal: context.modal(),
+		nestedDrawerOpen: context.nestedOpenDialogCount() > 0,
+		rootElement: context.viewportElement()
+	}), (state) => {
+		if (!state.mounted || !state.open) {
+			focusedKeyboardTarget = null;
+			restoreKeyboardScrollAdjustment();
+			cancelKeyboardFocusFrame();
+			return;
+		}
+		const rootElement = state.rootElement;
+		if (!rootElement) {
+			restoreKeyboardScrollAdjustment();
+			return;
+		}
+		const doc = ownerDocument(rootElement);
+		const win = ownerWindow(rootElement);
+		const visualViewport = win.visualViewport;
+		const nestedDrawerOpen = state.nestedDrawerOpen;
+		let keyboardScrollElement = null;
+		let keyboardScrollDestination = 0;
+		let keyboardScrollChecks = 0;
+		let keyboardScrollObserved = -1;
+		function setDrawerKeyboardInset(inset) {
+			rootElement.style.setProperty(DrawerViewportCssVars.keyboardInset, `${Math.max(0, Math.ceil(inset))}px`);
+		}
+		function clearFocusedKeyboardTarget() {
+			focusedKeyboardTarget = null;
+			keyboardScrollElement = null;
+			setDrawerKeyboardInset(0);
+			restoreKeyboardScrollAdjustment();
+			cancelKeyboardFocusFrame();
+			clearKeyboardRealignTimeout();
+		}
+		const baseScrollX = win.scrollX;
+		const baseScrollY = win.scrollY;
+		function restoreWindowScroll() {
+			if (state.modal !== true || nestedDrawerOpen || !focusedKeyboardTarget || getKeyboardVisualViewport(win) == null) return false;
+			if (win.scrollX !== baseScrollX || win.scrollY !== baseScrollY) {
+				win.scrollTo({
+					left: baseScrollX,
+					top: baseScrollY,
+					behavior: "instant"
+				});
+				return true;
+			}
+			return false;
+		}
+		let restorePreemptedFocus = null;
+		function consumePreemptedFocus() {
+			restorePreemptedFocus?.();
+			restorePreemptedFocus = null;
+		}
+		function preemptFocusReveal(target, keyboardViewport) {
+			consumePreemptedFocus();
+			const rect = target.getBoundingClientRect();
+			restorePreemptedFocus = overrideGeometryDuringFocus(target, (keyboardViewport.top + keyboardViewport.bottom - rect.top - rect.bottom) / 2);
+		}
+		function alignFocusedKeyboardTarget() {
+			keyboardFocusFrame = void 0;
+			consumePreemptedFocus();
+			const target = focusedKeyboardTarget;
+			if (nestedDrawerOpen || !target || !contains(rootElement, target)) {
+				setDrawerKeyboardInset(0);
+				restoreKeyboardScrollAdjustment();
+				return;
+			}
+			restoreWindowScroll();
+			const keyboardViewport = getKeyboardVisualViewport(win);
+			if (!keyboardViewport) {
+				setDrawerKeyboardInset(0);
+				restoreKeyboardScrollAdjustment();
+				return;
+			}
+			setDrawerKeyboardInset(Math.max(0, win.innerHeight - keyboardViewport.bottom));
+			const scrollTarget = findKeyboardScrollTarget(target, rootElement);
+			if (!scrollTarget) {
+				restoreKeyboardScrollAdjustment();
+				return;
+			}
+			const scrollTargetRect = scrollTarget.getBoundingClientRect();
+			const clippedBottom = Math.min(scrollTargetRect.bottom, keyboardViewport.bottom);
+			const overlap = Math.max(0, scrollTargetRect.bottom - keyboardViewport.bottom);
+			setKeyboardScrollSlack(scrollTarget, overlap > 0 ? overlap + KEYBOARD_SCROLL_SLACK : 0);
+			const maxScrollTop = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+			if (maxScrollTop <= 0) return;
+			const visibleTop = Math.max(scrollTargetRect.top, keyboardViewport.top) + KEYBOARD_VISIBILITY_MARGIN;
+			const visibleBottom = clippedBottom - KEYBOARD_VISIBILITY_MARGIN;
+			if (visibleBottom <= visibleTop) return;
+			const targetRect = target.getBoundingClientRect();
+			const nextScrollTop = scrollTarget.scrollTop + (targetRect.top + targetRect.bottom - visibleTop - visibleBottom) / 2;
+			const destination = Math.round(clamp(nextScrollTop, 0, maxScrollTop));
+			if (!(keyboardScrollElement === scrollTarget && Math.abs(keyboardScrollDestination - destination) <= 1)) {
+				const checks = keyboardScrollElement === scrollTarget ? keyboardScrollChecks + 1 : 1;
+				keyboardScrollElement = scrollTarget;
+				keyboardScrollDestination = destination;
+				keyboardScrollChecks = checks;
+				keyboardScrollObserved = -1;
+				if (checks <= KEYBOARD_SETTLE_FRAME_LIMIT) {
+					scheduleKeyboardFocusAlignment();
+					return;
+				}
+			} else if (keyboardScrollObserved >= 0) {
+				const current = scrollTarget.scrollTop;
+				if (Math.abs(current - destination) <= 1) return;
+				if (current !== keyboardScrollObserved) {
+					keyboardScrollObserved = current;
+					return;
+				}
+			}
+			keyboardScrollElement = scrollTarget;
+			keyboardScrollDestination = destination;
+			keyboardScrollChecks = 0;
+			keyboardScrollObserved = scrollTarget.scrollTop;
+			animateKeyboardScroll(scrollTarget, destination);
+		}
+		function scheduleKeyboardFocusAlignment() {
+			cancelKeyboardFocusFrame();
+			keyboardFocusFrame = requestAnimationFrame(alignFocusedKeyboardTarget);
+		}
+		function scheduleDelayedKeyboardRealign() {
+			let remainingPasses = KEYBOARD_REALIGN_MAX_PASSES;
+			const realign = () => {
+				keyboardRealignTimeout = void 0;
+				alignFocusedKeyboardTarget();
+				remainingPasses -= 1;
+				if (remainingPasses > 0) keyboardRealignTimeout = setTimeout(realign, KEYBOARD_REALIGN_INTERVAL);
+			};
+			clearKeyboardRealignTimeout();
+			keyboardRealignTimeout = setTimeout(realign, KEYBOARD_REALIGN_INTERVAL);
+		}
+		function captureFocusedKeyboardTarget(eventTarget) {
+			if (nestedDrawerOpen) return false;
+			const target = resolveKeyboardInputTarget(eventTarget);
+			if (!target || !contains(rootElement, target)) return false;
+			if (focusedKeyboardTarget !== target) keyboardScrollElement = null;
+			focusedKeyboardTarget = target;
+			return true;
+		}
+		function handleFocusIn(event) {
+			programmaticKeyboardFocus = false;
+			consumePreemptedFocus();
+			if (!captureFocusedKeyboardTarget(getEventTarget(event))) {
+				clearFocusedKeyboardTarget();
+				return;
+			}
+			if (getKeyboardVisualViewport(win) != null) scheduleDelayedKeyboardRealign();
+			scheduleKeyboardFocusAlignment();
+		}
+		function handleFocusOut(event) {
+			if (programmaticKeyboardFocus) return;
+			if (captureFocusedKeyboardTarget(event.relatedTarget)) {
+				const target = focusedKeyboardTarget;
+				const keyboardViewport = getKeyboardVisualViewport(win);
+				if (target && keyboardViewport) preemptFocusReveal(target, keyboardViewport);
+				scheduleKeyboardFocusAlignment();
+				return;
+			}
+			clearFocusedKeyboardTarget();
+		}
+		function handleViewportUpdate() {
+			if (focusedKeyboardTarget || captureFocusedKeyboardTarget(activeElement(doc))) scheduleKeyboardFocusAlignment();
+		}
+		function handleWindowScroll() {
+			if (restoreWindowScroll()) scheduleKeyboardFocusAlignment();
+		}
+		function cancelKeyboardRealignOnPointerDown() {
+			cancelKeyboardFocusFrame();
+			clearKeyboardRealignTimeout();
+			keyboardScrollElement = null;
+		}
+		visualViewport?.addEventListener("resize", handleViewportUpdate);
+		visualViewport?.addEventListener("scroll", handleViewportUpdate);
+		doc.addEventListener("focusin", handleFocusIn, true);
+		doc.addEventListener("focusout", handleFocusOut, true);
+		win.addEventListener("scroll", handleWindowScroll);
+		doc.addEventListener("pointerdown", cancelKeyboardRealignOnPointerDown, true);
+		if (captureFocusedKeyboardTarget(activeElement(doc))) scheduleKeyboardFocusAlignment();
+		return () => {
+			visualViewport?.removeEventListener("resize", handleViewportUpdate);
+			visualViewport?.removeEventListener("scroll", handleViewportUpdate);
+			doc.removeEventListener("focusin", handleFocusIn, true);
+			doc.removeEventListener("focusout", handleFocusOut, true);
+			win.removeEventListener("scroll", handleWindowScroll);
+			doc.removeEventListener("pointerdown", cancelKeyboardRealignOnPointerDown, true);
+			consumePreemptedFocus();
+			clearFocusedKeyboardTarget();
+			rootElement.style.removeProperty(DrawerViewportCssVars.keyboardInset);
+		};
+	});
+	function onTouchStart(event) {
+		const touch = event.touches[0];
+		pendingKeyboardFocusMoved = false;
+		keyboardTouchStart = touch ? {
+			x: touch.clientX,
+			y: touch.clientY
+		} : null;
+	}
+	function onTouchMove(event) {
+		const touch = event.touches[0];
+		if (!touch || !keyboardTouchStart || pendingKeyboardFocusMoved) return;
+		if (Math.abs(touch.clientX - keyboardTouchStart.x) > INPUT_TAP_MOVE_THRESHOLD || Math.abs(touch.clientY - keyboardTouchStart.y) > INPUT_TAP_MOVE_THRESHOLD) pendingKeyboardFocusMoved = true;
+	}
+	function onTouchEnd(event) {
+		const rootElement = context.viewportElement();
+		if (!store.open() || !context.presence.mounted() || context.nestedOpenDialogCount() > 0 || !rootElement || !keyboardTouchStart || pendingKeyboardFocusMoved) {
+			resetTouchTrackingState();
+			return;
+		}
+		const touch = event.changedTouches[0] ?? event.touches[0];
+		const root = rootElement.getRootNode();
+		const pointTarget = touch ? resolveKeyboardTouchTargetFromPoint(root, touch.clientX, touch.clientY) : null;
+		if (pointTarget === KEYBOARD_TAP_BLOCKED) {
+			resetTouchTrackingState();
+			return;
+		}
+		const keyboardTarget = touch && (pointTarget ?? resolveKeyboardTouchTarget(getEventTarget(event)));
+		if (keyboardTarget && (!contains(rootElement, keyboardTarget.focusTarget) || !contains(rootElement, keyboardTarget.clickTarget))) {
+			resetTouchTrackingState();
+			return;
+		}
+		if (keyboardTarget) {
+			const { clickTarget, focusTarget } = keyboardTarget;
+			const win = ownerWindow(focusTarget);
+			if (win.visualViewport && win.visualViewport.scale !== 1) {
+				resetTouchTrackingState();
+				return;
+			}
+			if (activeElement(ownerDocument(focusTarget)) === focusTarget && (!win.visualViewport || getKeyboardVisualViewport(win) != null)) {
+				resetTouchTrackingState();
+				return;
+			}
+			event.preventDefault();
+			programmaticKeyboardFocus = true;
+			try {
+				focusKeyboardInputWithoutPageScroll(focusTarget);
+			} finally {
+				programmaticKeyboardFocus = false;
+			}
+			dispatchKeyboardClick(clickTarget, touch);
+			resetTouchTrackingState();
+			return;
+		}
+		resetTouchTrackingState();
+	}
+	return DrawerVirtualKeyboardContext({
+		value: {
+			onTouchStart,
+			onTouchMove,
+			onTouchEnd,
+			onTouchCancel: resetTouchTrackingState
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+function isKeyboardInputElement(element) {
+	if (element.isContentEditable) return true;
+	const win = ownerWindow(element);
+	if (element instanceof win.HTMLTextAreaElement || element instanceof win.HTMLInputElement && KEYBOARD_INPUT_TYPES.has(element.type)) return !element.matches(":disabled");
+	return false;
+}
+function resolveKeyboardInputTarget(target) {
+	if (!isHTMLElement(target)) return null;
+	if (isKeyboardInputElement(target)) return target.isContentEditable ? getContentEditableHost(target) : target;
+	const control = target.closest("label")?.control ?? null;
+	return isHTMLElement(control) && isKeyboardInputElement(control) ? control : null;
+}
+function resolveKeyboardTouchTarget(target) {
+	if (!isHTMLElement(target)) return null;
+	const focusTarget = resolveKeyboardInputTarget(target);
+	if (!focusTarget) return null;
+	return {
+		focusTarget,
+		clickTarget: target
+	};
+}
+/**
+* Inherited-editable descendants (no `contenteditable` attribute of their own) are not focusable,
+* so focusing them is a no-op; resolve taps on them to the editing host.
+*/
+function getContentEditableHost(element) {
+	let host = element;
+	while (host.parentElement?.isContentEditable) host = host.parentElement;
+	return host;
+}
+function resolveKeyboardTouchTargetFromPoint(root, clientX, clientY) {
+	const exactTarget = getElementAtPoint(root, clientX, clientY);
+	if (isHTMLElement(exactTarget)) {
+		const exactKeyboardTarget = resolveKeyboardInputTarget(exactTarget);
+		if (exactKeyboardTarget) return {
+			focusTarget: exactKeyboardTarget,
+			clickTarget: exactTarget
+		};
+	}
+	if (isInteractiveElement(exactTarget) || exactTarget?.closest("label") != null) return KEYBOARD_TAP_BLOCKED;
+	for (const [offsetX, offsetY] of [
+		[0, INPUT_TAP_HIT_SLOP],
+		[0, -16],
+		[INPUT_TAP_HIT_SLOP, 0],
+		[-16, 0]
+	]) {
+		const keyboardTarget = resolveKeyboardInputTarget(getElementAtPoint(root, clientX + offsetX, clientY + offsetY));
+		if (keyboardTarget) return {
+			focusTarget: keyboardTarget,
+			clickTarget: keyboardTarget
+		};
+	}
+	return null;
+}
+function dispatchKeyboardClick(target, touch) {
+	const win = ownerWindow(target);
+	const ClickEvent = win.PointerEvent ?? win.MouseEvent;
+	const init = {
+		bubbles: true,
+		cancelable: true,
+		clientX: touch.clientX,
+		clientY: touch.clientY,
+		detail: 1
+	};
+	let event;
+	try {
+		event = new ClickEvent("click", {
+			...init,
+			view: win
+		});
+	} catch {
+		event = new ClickEvent("click", init);
+	}
+	target.dispatchEvent(event);
+}
+function focusKeyboardInputWithoutPageScroll(target) {
+	const wasFocused = activeElement(ownerDocument(target)) === target;
+	const restoreStyles = overrideGeometryDuringFocus(target, -2e3);
+	try {
+		if (wasFocused) target.blur();
+		target.focus({ preventScroll: true });
+	} finally {
+		restoreStyles();
+	}
+}
+/**
+* Overrides the painted geometry WebKit samples when an element gains focus. The rect is hidden
+* (opacity) rather than detached so layout is unaffected; the caller must restore synchronously
+* before the next paint.
+*/
+function overrideGeometryDuringFocus(target, translateY) {
+	const previousOpacity = target.style.opacity;
+	const previousTransform = target.style.transform;
+	const previousTransition = target.style.transition;
+	target.style.transition = "none";
+	target.style.opacity = "0";
+	target.style.transform = `translateY(${translateY}px)`;
+	return () => {
+		target.style.opacity = previousOpacity;
+		target.style.transform = previousTransform;
+		target.style.transition = previousTransition;
+	};
+}
+function findKeyboardScrollTarget(target, root) {
+	const scrollStart = getComposedParentNode(target);
+	return findScrollableTouchTarget(scrollStart, root, "vertical") ?? findScrollableTouchTarget(scrollStart, root, "vertical", true);
+}
+function getKeyboardVisualViewport(win) {
+	const visualViewport = win.visualViewport;
+	if (!visualViewport || visualViewport.scale !== 1) return null;
+	if (win.innerHeight - visualViewport.height <= KEYBOARD_RESIZE_THRESHOLD) return null;
+	const top = Math.max(0, visualViewport.offsetTop);
+	return {
+		top,
+		bottom: Math.min(win.innerHeight, top + visualViewport.height)
+	};
+}
+//#endregion
+//#region src/drawer/handle.ts
+/**
+* Imperatively controls a Drawer and associates detached `Drawer.Trigger` components with a
+* `Drawer.Root`. Create one with `Drawer.createHandle()` and pass it to the `handle` prop of the
+* root and of any triggers rendered outside of it.
+*
+* The imperative methods take effect only while a root using this handle is mounted; calls made
+* before a root attaches (or after it unmounts) are ignored.
+*/
+var DrawerHandle = class extends DialogHandle {};
+/** Creates a new handle to connect a Drawer.Root with detached Drawer.Trigger components. */
+function createDrawerHandle() {
+	return new DrawerHandle();
+}
+//#endregion
+//#region src/drawer/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Backdrop: () => DrawerBackdrop,
+	Close: () => DialogClose,
+	Content: () => DrawerContent,
+	Description: () => DialogDescription,
+	Handle: () => DrawerHandle,
+	Indent: () => DrawerIndent,
+	IndentBackground: () => DrawerIndentBackground,
+	Popup: () => DrawerPopup,
+	Portal: () => DialogPortal,
+	Provider: () => DrawerProvider,
+	Root: () => DrawerRoot,
+	SwipeArea: () => DrawerSwipeArea,
+	Title: () => DialogTitle,
+	Trigger: () => DialogTrigger,
+	Viewport: () => DrawerViewport,
+	VirtualKeyboardProvider: () => DrawerVirtualKeyboardProvider,
+	createHandle: () => createDrawerHandle
+});
+//#endregion
+export { index_parts_exports as Drawer };