@wix/site-ui 1.29.0 → 1.31.0

package/dist/Drawer/index.js

@@ -1,72 +1,2849 @@
-import { jsx } from "react/jsx-runtime";
-import { Drawer } from "@base-ui/react/drawer";
+import { jsx, jsxs } from "react/jsx-runtime";
 import clsx from "clsx";
+import { BASE_UI_SWIPE_IGNORE_SELECTOR, popupStateMapping, popupStateMapping_CommonPopupDataAttributes } from "../4388.js";
+import { transitionStatusMapping, stateAttributesMapping_TransitionStatusDataAttributes, useOpenChangeComplete } from "../880.js";
+import { IsDrawerContext, DialogClose_DialogClose, useDialogPortalContext, useDialogRootContext, DialogTitle_DialogTitle, DialogTrigger_DialogTrigger, DialogDescription_DialogDescription, DialogHandle, createDialogHandle, DialogViewport_DialogViewport, DialogPortal_DialogPortal } from "../6270.js";
+import { EMPTY_OBJECT, mergeProps, useRenderElement, esm_formatErrorMessage } from "../8272.js";
+import { useIsoLayoutEffect, SafeReact } from "../6499.js";
+import { clamp } from "../3296.js";
+import { useStableCallback } from "../7541.js";
+import { ownerDocument } from "../9829.js";
+import { error as error_error } from "../4026.js";
+import { FOCUSABLE_POPUP_PROPS, useTriggerRegistration } from "../8106.js";
+import { COMPOSITE_KEYS } from "../1500.js";
+import { FloatingFocusManager } from "../3485.js";
+import { getWindow, getComputedStyle as floating_ui_utils_dom_getComputedStyle, isElement, isHTMLElement } from "../3829.js";
+import { getTarget, contains, activeElement } from "../4549.js";
+import { useTimeout } from "../42.js";
+import { useBaseUiId, useId } from "../6046.js";
+import { createChangeEventDetails } from "../4768.js";
+import { useAnimationFrame } from "../8996.js";
+import { addEventListener } from "../4723.js";
+import { useControlled } from "../8527.js";
+import { DialogRoot } from "../3020.js";
+import { isAndroid } from "../8971.js";
+import { closeWatcher as reason_parts_closeWatcher } from "../2418.js";
 import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+let DrawerPopupCssVars_DrawerPopupCssVars = /*#__PURE__*/ function(DrawerPopupCssVars) {
+    DrawerPopupCssVars["nestedDrawers"] = "--nested-drawers";
+    DrawerPopupCssVars["height"] = "--drawer-height";
+    DrawerPopupCssVars["frontmostHeight"] = "--drawer-frontmost-height";
+    DrawerPopupCssVars["swipeMovementX"] = "--drawer-swipe-movement-x";
+    DrawerPopupCssVars["swipeMovementY"] = "--drawer-swipe-movement-y";
+    DrawerPopupCssVars["snapPointOffset"] = "--drawer-snap-point-offset";
+    DrawerPopupCssVars["swipeStrength"] = "--drawer-swipe-strength";
+    return DrawerPopupCssVars;
+}({});
+let DrawerBackdropCssVars_DrawerBackdropCssVars = /*#__PURE__*/ function(DrawerBackdropCssVars) {
+    DrawerBackdropCssVars["swipeProgress"] = "--drawer-swipe-progress";
+    return DrawerBackdropCssVars;
+}({});
+const stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const DrawerBackdrop_DrawerBackdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, forceRender = false, ...elementProps } = componentProps;
+    const { store } = useDialogRootContext();
+    const open = store.useState('open');
+    const nested = store.useState('nested');
+    const mounted = store.useState('mounted');
+    const transitionStatus = store.useState('transitionStatus');
+    const state = {
+        open,
+        transitionStatus
+    };
+    return useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            store.context.backdropRef,
+            forwardedRef
+        ],
+        stateAttributesMapping: stateAttributesMapping,
+        props: [
+            {
+                role: 'presentation',
+                hidden: !mounted,
+                style: {
+                    pointerEvents: open ? void 0 : 'none',
+                    userSelect: 'none',
+                    WebkitUserSelect: 'none',
+                    [DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress]: '0',
+                    [DrawerPopupCssVars_DrawerPopupCssVars.swipeStrength]: '1'
+                }
+            },
+            elementProps
+        ],
+        enabled: forceRender || !nested
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerBackdrop_DrawerBackdrop.displayName = "DrawerBackdrop";
+const DRAWER_CONTENT_ATTRIBUTE = 'data-drawer-content';
+const DrawerContent_DrawerContent = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    useDialogRootContext();
+    return useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                [DRAWER_CONTENT_ATTRIBUTE]: ''
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerContent_DrawerContent.displayName = "DrawerContent";
+const DrawerProviderContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) DrawerProviderContext.displayName = "DrawerProviderContext";
+function useDrawerProviderContext(optional) {
+    const context = __rspack_external_react.useContext(DrawerProviderContext);
+    if (false === optional && void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: DrawerProviderContext is missing. Use <Drawer.Provider>.' : esm_formatErrorMessage(91));
+    return context;
+}
+const DrawerIndent_stateAttributesMapping = {
+    active (value) {
+        if (value) return {
+            'data-active': ''
+        };
+        return {
+            'data-inactive': ''
+        };
+    }
+};
+const DrawerIndent_DrawerIndent = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const providerContext = useDrawerProviderContext(true);
+    const active = providerContext?.active ?? false;
+    const visualStateStore = providerContext?.visualStateStore;
+    const indentRef = __rspack_external_react.useRef(null);
+    useIsoLayoutEffect(()=>{
+        const element = indentRef.current;
+        if (!element || !visualStateStore) return;
+        const syncVisualState = ()=>{
+            const { swipeProgress, frontmostHeight } = visualStateStore.getSnapshot();
+            if (swipeProgress <= 0) element.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+            else element.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, `${swipeProgress}`);
+            if (frontmostHeight <= 0) element.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+            else element.style.setProperty(DrawerPopupCssVars_DrawerPopupCssVars.height, `${frontmostHeight}px`);
+        };
+        syncVisualState();
+        const unsubscribe = visualStateStore.subscribe(syncVisualState);
+        return ()=>{
+            unsubscribe();
+            element.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+            element.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+        };
+    }, [
+        visualStateStore
+    ]);
+    const state = {
+        active
+    };
+    return useRenderElement('div', componentProps, {
+        ref: [
+            forwardedRef,
+            indentRef
+        ],
+        state,
+        props: [
+            {
+                style: {
+                    [DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress]: '0'
+                }
+            },
+            elementProps
+        ],
+        stateAttributesMapping: DrawerIndent_stateAttributesMapping
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerIndent_DrawerIndent.displayName = "DrawerIndent";
+const DrawerIndentBackground_stateAttributesMapping = {
+    active (value) {
+        if (value) return {
+            'data-active': ''
+        };
+        return {
+            'data-inactive': ''
+        };
+    }
+};
+const DrawerIndentBackground_DrawerIndentBackground = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const providerContext = useDrawerProviderContext(true);
+    const active = providerContext?.active ?? false;
+    const state = {
+        active
+    };
+    return useRenderElement('div', componentProps, {
+        ref: forwardedRef,
+        state,
+        props: elementProps,
+        stateAttributesMapping: DrawerIndentBackground_stateAttributesMapping
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerIndentBackground_DrawerIndentBackground.displayName = "DrawerIndentBackground";
+let DrawerPopupDataAttributes_DrawerPopupDataAttributes = function(DrawerPopupDataAttributes) {
+    DrawerPopupDataAttributes[DrawerPopupDataAttributes["open"] = popupStateMapping_CommonPopupDataAttributes.open] = "open";
+    DrawerPopupDataAttributes[DrawerPopupDataAttributes["closed"] = popupStateMapping_CommonPopupDataAttributes.closed] = "closed";
+    DrawerPopupDataAttributes[DrawerPopupDataAttributes["startingStyle"] = popupStateMapping_CommonPopupDataAttributes.startingStyle] = "startingStyle";
+    DrawerPopupDataAttributes[DrawerPopupDataAttributes["endingStyle"] = popupStateMapping_CommonPopupDataAttributes.endingStyle] = "endingStyle";
+    DrawerPopupDataAttributes["expanded"] = "data-expanded";
+    DrawerPopupDataAttributes["nestedDrawerOpen"] = "data-nested-drawer-open";
+    DrawerPopupDataAttributes["nestedDrawerSwiping"] = "data-nested-drawer-swiping";
+    DrawerPopupDataAttributes["swipeDismiss"] = "data-swipe-dismiss";
+    DrawerPopupDataAttributes["swipeDirection"] = "data-swipe-direction";
+    DrawerPopupDataAttributes["swiping"] = "data-swiping";
+    return DrawerPopupDataAttributes;
+}({});
+const DrawerRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) DrawerRootContext.displayName = "DrawerRootContext";
+function useDrawerRootContext(optional) {
+    const drawerRootContext = __rspack_external_react.useContext(DrawerRootContext);
+    if (false === optional && void 0 === drawerRootContext) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: DrawerRootContext is missing. Drawer parts must be placed within <Drawer.Root>.' : esm_formatErrorMessage(90));
+    return drawerRootContext;
+}
+function resolveSnapPointValue(snapPoint, viewportHeight, rootFontSize) {
+    if (!Number.isFinite(viewportHeight) || viewportHeight <= 0) return null;
+    if ('number' == typeof snapPoint) {
+        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;
+}
+function findClosestSnapPoint(height, points) {
+    let closest = null;
+    let closestDistance = 1 / 0;
+    for (const point of points){
+        const distance = Math.abs(point.height - height);
+        if (distance < closestDistance) {
+            closestDistance = distance;
+            closest = point;
+        }
+    }
+    return closest;
+}
+function useDrawerSnapPoints() {
+    const { store } = useDialogRootContext();
+    const { snapPoints, activeSnapPoint, setActiveSnapPoint, popupHeight } = useDrawerRootContext();
+    const viewportElement = store.useState('viewportElement');
+    const [viewportHeight, setViewportHeight] = __rspack_external_react.useState(0);
+    const [rootFontSize, setRootFontSize] = __rspack_external_react.useState(16);
+    const measureViewportHeight = useStableCallback(()=>{
+        const doc = ownerDocument(viewportElement);
+        const html = doc.documentElement;
+        if (viewportElement) setViewportHeight(viewportElement.offsetHeight);
+        if (!viewportElement) setViewportHeight(html.clientHeight);
+        const fontSize = parseFloat(getComputedStyle(html).fontSize);
+        if (Number.isFinite(fontSize)) setRootFontSize(fontSize);
+    });
+    useIsoLayoutEffect(()=>{
+        measureViewportHeight();
+        if (!viewportElement || 'function' != typeof ResizeObserver) return;
+        const resizeObserver = new ResizeObserver(measureViewportHeight);
+        resizeObserver.observe(viewportElement);
+        return ()=>{
+            resizeObserver.disconnect();
+        };
+    }, [
+        measureViewportHeight,
+        viewportElement
+    ]);
+    const resolvedSnapPoints = __rspack_external_react.useMemo(()=>{
+        if (!snapPoints || 0 === snapPoints.length || viewportHeight <= 0 || popupHeight <= 0) return [];
+        const maxHeight = Math.min(popupHeight, viewportHeight);
+        if (!Number.isFinite(maxHeight) || maxHeight <= 0) return [];
+        const resolved = snapPoints.map((value)=>{
+            const resolvedHeight = resolveSnapPointValue(value, viewportHeight, rootFontSize);
+            if (null === resolvedHeight || !Number.isFinite(resolvedHeight)) return null;
+            const clampedHeight = clamp(resolvedHeight, 0, maxHeight);
+            return {
+                value,
+                height: clampedHeight,
+                offset: Math.max(0, popupHeight - 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];
+            const isDuplicate = seenHeights.some((height)=>Math.abs(height - point.height) <= 1);
+            if (!isDuplicate) {
+                seenHeights.push(point.height);
+                deduped.push(point);
+            }
+        }
+        deduped.reverse();
+        return deduped;
+    }, [
+        popupHeight,
+        rootFontSize,
+        snapPoints,
+        viewportHeight
+    ]);
+    const resolvedActiveSnapPoint = __rspack_external_react.useMemo(()=>{
+        if (void 0 === activeSnapPoint) return resolvedSnapPoints[0];
+        if (null === activeSnapPoint) return;
+        const exactMatch = resolvedSnapPoints.find((point)=>Object.is(point.value, activeSnapPoint));
+        if (exactMatch) return exactMatch;
+        const maxHeight = Math.min(popupHeight, viewportHeight);
+        const resolvedHeight = resolveSnapPointValue(activeSnapPoint, viewportHeight, rootFontSize);
+        if (null === resolvedHeight || !Number.isFinite(resolvedHeight)) return;
+        const clampedHeight = clamp(resolvedHeight, 0, maxHeight);
+        return findClosestSnapPoint(clampedHeight, resolvedSnapPoints) ?? void 0;
+    }, [
+        activeSnapPoint,
+        popupHeight,
+        resolvedSnapPoints,
+        rootFontSize,
+        viewportHeight
+    ]);
+    return {
+        snapPoints,
+        activeSnapPoint,
+        setActiveSnapPoint,
+        popupHeight,
+        viewportHeight,
+        resolvedSnapPoints,
+        activeSnapPointOffset: resolvedActiveSnapPoint?.offset ?? null
+    };
+}
+const DrawerViewportContext = /*#__PURE__*/ __rspack_external_react.createContext(null);
+if ("production" !== process.env.NODE_ENV) DrawerViewportContext.displayName = "DrawerViewportContext";
+function useDrawerViewportContext(optional) {
+    const context = __rspack_external_react.useContext(DrawerViewportContext);
+    if (false === optional && null === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: DrawerViewportContext is missing. Drawer parts must be placed within <Drawer.Viewport>.' : esm_formatErrorMessage(92));
+    return context;
+}
+let drawerSwipeVarsRegistered = false;
+function removeCSSVariableInheritance() {
+    if (drawerSwipeVarsRegistered) return;
+    if ("u" > typeof CSS && 'registerProperty' in CSS) {
+        [
+            DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementX,
+            DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY,
+            DrawerPopupCssVars_DrawerPopupCssVars.snapPointOffset
+        ].forEach((name)=>{
+            try {
+                CSS.registerProperty({
+                    name,
+                    syntax: '<length>',
+                    inherits: false,
+                    initialValue: '0px'
+                });
+            } catch  {}
+        });
+        [
+            {
+                name: DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress,
+                initialValue: '0'
+            },
+            {
+                name: DrawerPopupCssVars_DrawerPopupCssVars.swipeStrength,
+                initialValue: '1'
+            }
+        ].forEach(({ name, initialValue })=>{
+            try {
+                CSS.registerProperty({
+                    name,
+                    syntax: '<number>',
+                    inherits: false,
+                    initialValue
+                });
+            } catch  {}
+        });
+    }
+    drawerSwipeVarsRegistered = true;
+}
+const DrawerPopup_stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping,
+    expanded (value) {
+        return value ? {
+            [DrawerPopupDataAttributes_DrawerPopupDataAttributes.expanded]: ''
+        } : null;
+    },
+    nestedDrawerOpen (value) {
+        return value ? {
+            [DrawerPopupDataAttributes_DrawerPopupDataAttributes.nestedDrawerOpen]: ''
+        } : null;
+    },
+    nestedDrawerSwiping (value) {
+        return value ? {
+            [DrawerPopupDataAttributes_DrawerPopupDataAttributes.nestedDrawerSwiping]: ''
+        } : null;
+    },
+    swipeDirection (value) {
+        return value ? {
+            [DrawerPopupDataAttributes_DrawerPopupDataAttributes.swipeDirection]: value
+        } : null;
+    },
+    swiping (value) {
+        return value ? {
+            [DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping]: ''
+        } : null;
+    }
+};
+const DrawerPopup_DrawerPopup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, finalFocus, initialFocus, ...elementProps } = componentProps;
+    const { store } = useDialogRootContext();
+    const { swipeDirection, frontmostHeight, hasNestedDrawer, nestedSwiping, nestedSwipeProgressStore, onPopupHeightChange, notifyParentFrontmostHeight, notifyParentHasNestedDrawer } = useDrawerRootContext();
+    const descriptionElementId = store.useState("descriptionElementId");
+    const disablePointerDismissal = store.useState('disablePointerDismissal');
+    const floatingRootContext = store.useState('floatingRootContext');
+    const rootPopupProps = store.useState('popupProps');
+    const modal = store.useState('modal');
+    const mounted = store.useState('mounted');
+    const nested = store.useState('nested');
+    const nestedOpenDrawerCount = store.useState('nestedOpenDrawerCount');
+    const transitionStatus = store.useState('transitionStatus');
+    const open = store.useState('open');
+    const openMethod = store.useState('openMethod');
+    const titleElementId = store.useState('titleElementId');
+    const role = store.useState('role');
+    const floatingId = floatingRootContext.useState('floatingId');
+    const popupId = elementProps.id ?? floatingId;
+    const swipe = useDrawerViewportContext(true);
+    useDialogPortalContext();
+    const { snapPoints, activeSnapPoint, activeSnapPointOffset } = useDrawerSnapPoints();
+    const nestedDrawerOpen = nestedOpenDrawerCount > 0;
+    const swiping = swipe?.swiping ?? false;
+    const swipeStrength = swipe?.swipeStrength ?? null;
+    const [popupHeight, setPopupHeight] = __rspack_external_react.useState(0);
+    const popupHeightRef = __rspack_external_react.useRef(0);
+    if ('production' !== process.env.NODE_ENV) __rspack_external_react.useEffect(()=>{
+        if (swipe) return;
+        const ownerStackMessage = SafeReact.captureOwnerStack?.() || '';
+        const message = "<Drawer.Popup> expected to be rendered within <Drawer.Viewport>. Omitting the viewport disables drawer swipe handling and touch scroll locking. Wrap <Drawer.Popup> in <Drawer.Viewport>.";
+        error_error(`${message}${ownerStackMessage}`);
+    }, [
+        swipe
+    ]);
+    const measureHeight = useStableCallback(()=>{
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) return;
+        const offsetHeight = popupElement.offsetHeight;
+        if (popupHeightRef.current > 0 && frontmostHeight > popupHeightRef.current && offsetHeight > popupHeightRef.current) return;
+        const keepHeightWhileNested = popupHeightRef.current > 0 && hasNestedDrawer;
+        if (keepHeightWhileNested) {
+            const oldHeight = popupHeightRef.current;
+            setPopupHeight(oldHeight);
+            onPopupHeightChange(oldHeight);
+            return;
+        }
+        const nextHeight = offsetHeight;
+        if (nextHeight === popupHeightRef.current) return;
+        popupHeightRef.current = nextHeight;
+        setPopupHeight(nextHeight);
+        onPopupHeightChange(nextHeight);
+    });
+    useIsoLayoutEffect(()=>{
+        if (!mounted) {
+            popupHeightRef.current = 0;
+            setPopupHeight(0);
+            onPopupHeightChange(0);
+            return;
+        }
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) return;
+        removeCSSVariableInheritance();
+        measureHeight();
+        if ('function' != typeof ResizeObserver) return;
+        const resizeObserver = new ResizeObserver(measureHeight);
+        resizeObserver.observe(popupElement);
+        return ()=>{
+            resizeObserver.disconnect();
+        };
+    }, [
+        measureHeight,
+        mounted,
+        nestedDrawerOpen,
+        onPopupHeightChange,
+        store.context.popupRef
+    ]);
+    useIsoLayoutEffect(()=>{
+        const popupRef = store.context.popupRef;
+        const syncNestedSwipeProgress = ()=>{
+            const popupElement = popupRef.current;
+            if (!popupElement) return;
+            const progress = nestedSwipeProgressStore.getSnapshot();
+            if (progress > 0) popupElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, `${progress}`);
+            else popupElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+        };
+        syncNestedSwipeProgress();
+        const unsubscribe = nestedSwipeProgressStore.subscribe(syncNestedSwipeProgress);
+        return ()=>{
+            unsubscribe();
+            const popupElement = popupRef.current;
+            if (popupElement) popupElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+        };
+    }, [
+        nestedSwipeProgressStore,
+        store.context.popupRef
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!open) return;
+        notifyParentFrontmostHeight?.(frontmostHeight);
+        return ()=>{
+            notifyParentFrontmostHeight?.(0);
+        };
+    }, [
+        frontmostHeight,
+        open,
+        notifyParentFrontmostHeight
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!notifyParentHasNestedDrawer) return;
+        const present = open || 'ending' === transitionStatus;
+        notifyParentHasNestedDrawer(present);
+        return ()=>{
+            notifyParentHasNestedDrawer(false);
+        };
+    }, [
+        notifyParentHasNestedDrawer,
+        open,
+        transitionStatus
+    ]);
+    useOpenChangeComplete({
+        open,
+        ref: store.context.popupRef,
+        onComplete () {
+            if (open) store.context.onOpenChangeComplete?.(true);
+        }
+    });
+    const resolvedInitialFocus = void 0 === initialFocus ? store.context.popupRef : initialFocus;
+    const setPopupElement = store.useStateSetter('popupElement');
+    const state = {
+        open,
+        nested,
+        transitionStatus,
+        expanded: 1 === activeSnapPoint,
+        nestedDrawerOpen,
+        nestedDrawerSwiping: nestedSwiping,
+        swipeDirection,
+        swiping
+    };
+    let popupHeightCssVarValue;
+    const shouldUseAutoHeight = !hasNestedDrawer && 'ending' !== transitionStatus;
+    if (popupHeight && !shouldUseAutoHeight) popupHeightCssVarValue = `${popupHeight}px`;
+    const shouldApplySnapPoints = snapPoints && snapPoints.length > 0 && ('down' === swipeDirection || 'up' === swipeDirection);
+    let snapPointOffsetValue = null;
+    if (shouldApplySnapPoints && null !== activeSnapPointOffset) snapPointOffsetValue = 'up' === swipeDirection ? -activeSnapPointOffset : activeSnapPointOffset;
+    let dragStyles = swipe ? swipe.getDragStyles() : EMPTY_OBJECT;
+    if (shouldApplySnapPoints && 'down' === swipeDirection) {
+        const baseOffset = activeSnapPointOffset ?? 0;
+        const movementValue = Number.parseFloat(String(dragStyles[DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY] ?? 0));
+        const nextOffset = Number.isFinite(movementValue) ? baseOffset + movementValue : baseOffset;
+        const shouldDamp = nextOffset < 0;
+        if (swiping && shouldDamp && Number.isFinite(movementValue)) {
+            const overshoot = Math.abs(nextOffset);
+            const dampedOffset = -Math.sqrt(overshoot);
+            const dampedMovement = dampedOffset - baseOffset;
+            dragStyles = {
+                ...dragStyles,
+                transform: void 0,
+                [DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY]: `${dampedMovement}px`
+            };
+        } else dragStyles = {
+            ...dragStyles,
+            transform: void 0
+        };
+    }
+    const element = useRenderElement('div', componentProps, {
+        state,
+        props: [
+            rootPopupProps,
+            {
+                id: popupId,
+                'aria-labelledby': titleElementId,
+                'aria-describedby': descriptionElementId,
+                role,
+                ...FOCUSABLE_POPUP_PROPS,
+                hidden: !mounted,
+                onKeyDown (event) {
+                    if (COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+                },
+                style: {
+                    ...dragStyles,
+                    [DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress]: '0',
+                    [DrawerPopupCssVars_DrawerPopupCssVars.nestedDrawers]: nestedOpenDrawerCount,
+                    [DrawerPopupCssVars_DrawerPopupCssVars.height]: popupHeightCssVarValue,
+                    [DrawerPopupCssVars_DrawerPopupCssVars.snapPointOffset]: 'number' == typeof snapPointOffsetValue ? `${snapPointOffsetValue}px` : '0px',
+                    [DrawerPopupCssVars_DrawerPopupCssVars.frontmostHeight]: frontmostHeight ? `${frontmostHeight}px` : void 0,
+                    [DrawerPopupCssVars_DrawerPopupCssVars.swipeStrength]: 'number' == typeof swipeStrength && Number.isFinite(swipeStrength) && swipeStrength > 0 ? `${swipeStrength}` : '1'
+                }
+            },
+            elementProps
+        ],
+        ref: [
+            forwardedRef,
+            store.context.popupRef,
+            setPopupElement
+        ],
+        stateAttributesMapping: DrawerPopup_stateAttributesMapping
+    });
+    return /*#__PURE__*/ jsx(FloatingFocusManager, {
+        context: floatingRootContext,
+        openInteractionType: openMethod,
+        disabled: !mounted,
+        closeOnFocusOut: !disablePointerDismissal,
+        initialFocus: resolvedInitialFocus,
+        returnFocus: finalFocus,
+        modal: false !== modal,
+        restoreFocus: "popup",
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerPopup_DrawerPopup.displayName = "DrawerPopup";
+function isScrollable(element, axis) {
+    const style = floating_ui_utils_dom_getComputedStyle(element);
+    if ('vertical' === axis) {
+        const overflowY = style.overflowY;
+        return ('auto' === overflowY || 'scroll' === overflowY) && element.scrollHeight > element.clientHeight;
+    }
+    const overflowX = style.overflowX;
+    return ('auto' === overflowX || 'scroll' === overflowX) && element.scrollWidth > element.clientWidth;
+}
+function hasScrollableAncestor(target, root, axes) {
+    let node = target;
+    while(node && node !== root){
+        for (const axis of axes)if (isScrollable(node, axis)) return true;
+        node = node.parentElement;
+    }
+    return false;
+}
+function findScrollableTouchTarget(target, root, axis = 'vertical') {
+    let node = isHTMLElement(target) ? target : null;
+    while(node && node !== root){
+        if (isScrollable(node, axis)) return node;
+        node = node.parentElement;
+    }
+    return isScrollable(root, axis) ? root : null;
+}
+function getElementAtPoint(doc, x, y) {
+    return 'function' == typeof doc?.elementFromPoint ? doc.elementFromPoint(x, y) : null;
+}
+const DEFAULT_SWIPE_THRESHOLD = 40;
+const REVERSE_CANCEL_THRESHOLD = 10;
+const MIN_DRAG_THRESHOLD = 1;
+const MIN_VELOCITY_DURATION_MS = 50;
+const MIN_RELEASE_VELOCITY_DURATION_MS = 16;
+const MAX_RELEASE_VELOCITY_AGE_MS = 80;
+const DEFAULT_IGNORE_SELECTOR = 'button,a,input,select,textarea,label,[role="button"]';
+function getDisplacement(direction, deltaX, deltaY) {
+    switch(direction){
+        case 'up':
+            return -deltaY;
+        case 'down':
+            return deltaY;
+        case 'left':
+            return -deltaX;
+        case 'right':
+            return deltaX;
+        default:
+            return 0;
+    }
+}
+function getElementTransform(element) {
+    const computedStyle = getWindow(element).getComputedStyle(element);
+    const transform = computedStyle.transform;
+    let translateX = 0;
+    let translateY = 0;
+    let scale = 1;
+    if (transform && 'none' !== transform) {
+        const matrix = transform.match(/matrix(?:3d)?\(([^)]+)\)/);
+        if (matrix) {
+            const values = matrix[1].split(', ').map(parseFloat);
+            if (6 === values.length) {
+                translateX = values[4];
+                translateY = values[5];
+                scale = Math.sqrt(values[0] * values[0] + values[1] * values[1]);
+            } else if (16 === values.length) {
+                translateX = values[12];
+                translateY = values[13];
+                scale = values[0];
+            }
+        }
+    }
+    return {
+        x: translateX,
+        y: translateY,
+        scale
+    };
+}
+function getValidTimeStamp(timeStamp) {
+    return Number.isFinite(timeStamp) && timeStamp > 0 ? timeStamp : null;
+}
+function hasPrimaryMouseButton(buttons) {
+    return buttons % 2 === 1;
+}
+function safelyChangePointerCapture(element, pointerId, method) {
+    const pointerCaptureMethod = element[method];
+    if ('function' != typeof pointerCaptureMethod) return;
+    try {
+        pointerCaptureMethod.call(element, pointerId);
+    } catch (error) {
+        if (error && 'object' == typeof error && 'name' in error && 'NotFoundError' === error.name) return;
+        throw error;
+    }
+}
+function useSwipeDismiss(options) {
+    const { enabled, directions, elementRef, movementCssVars, canStart, ignoreSelectorWhenTouch = true, ignoreScrollableAncestors = false, swipeThreshold: swipeThresholdProp, onDismiss, onProgress, onCancel, onSwipeStart, onRelease, onSwipingChange, trackDrag = true } = options;
+    const ignoreSelector = DEFAULT_IGNORE_SELECTOR;
+    const primaryDirection = 1 === directions.length ? directions[0] : void 0;
+    const swipeThresholdDefault = Math.max(0, 'number' == typeof swipeThresholdProp ? swipeThresholdProp : DEFAULT_SWIPE_THRESHOLD);
+    const allowLeft = directions.includes('left');
+    const allowRight = directions.includes('right');
+    const allowUp = directions.includes('up');
+    const allowDown = directions.includes('down');
+    const hasHorizontal = allowLeft || allowRight;
+    const hasVertical = allowUp || allowDown;
+    const scrollAxes = __rspack_external_react.useMemo(()=>{
+        const axes = [];
+        if (hasVertical) axes.push('vertical');
+        if (hasHorizontal) axes.push('horizontal');
+        return axes;
+    }, [
+        hasHorizontal,
+        hasVertical
+    ]);
+    const [currentSwipeDirection, setCurrentSwipeDirection] = __rspack_external_react.useState(void 0);
+    const [isSwiping, setIsSwiping] = __rspack_external_react.useState(false);
+    const [isRealSwipe, setIsRealSwipe] = __rspack_external_react.useState(false);
+    const [dragDismissed, setDragDismissed] = __rspack_external_react.useState(false);
+    const [dragOffset, setDragOffset] = __rspack_external_react.useState({
+        x: 0,
+        y: 0
+    });
+    const [initialTransform, setInitialTransform] = __rspack_external_react.useState({
+        x: 0,
+        y: 0,
+        scale: 1
+    });
+    const [lockedDirection, setLockedDirection] = __rspack_external_react.useState(null);
+    const dragStartPosRef = __rspack_external_react.useRef({
+        x: 0,
+        y: 0
+    });
+    const dragOffsetRef = __rspack_external_react.useRef({
+        x: 0,
+        y: 0
+    });
+    const lastMovePosRef = __rspack_external_react.useRef(null);
+    const initialTransformRef = __rspack_external_react.useRef({
+        x: 0,
+        y: 0,
+        scale: 1
+    });
+    const intendedSwipeDirectionRef = __rspack_external_react.useRef(void 0);
+    const maxSwipeDisplacementRef = __rspack_external_react.useRef(0);
+    const cancelledSwipeRef = __rspack_external_react.useRef(false);
+    const swipeCancelBaselineRef = __rspack_external_react.useRef({
+        x: 0,
+        y: 0
+    });
+    const isFirstPointerMoveRef = __rspack_external_react.useRef(false);
+    const pendingSwipeRef = __rspack_external_react.useRef(false);
+    const pendingSwipeStartPosRef = __rspack_external_react.useRef(null);
+    const swipeFromScrollableRef = __rspack_external_react.useRef(false);
+    const sawPrimaryButtonsOnMoveRef = __rspack_external_react.useRef(false);
+    const elementSizeRef = __rspack_external_react.useRef({
+        width: 0,
+        height: 0
+    });
+    const swipeProgressRef = __rspack_external_react.useRef(0);
+    const swipeThresholdRef = __rspack_external_react.useRef(swipeThresholdDefault);
+    const swipeStartTimeRef = __rspack_external_react.useRef(null);
+    const lastDragSampleRef = __rspack_external_react.useRef(null);
+    const lastDragVelocityRef = __rspack_external_react.useRef({
+        x: 0,
+        y: 0
+    });
+    const lastProgressDetailsRef = __rspack_external_react.useRef(null);
+    const isSwipingRef = __rspack_external_react.useRef(false);
+    const setSwiping = useStableCallback((nextSwiping)=>{
+        if (isSwipingRef.current === nextSwiping) return;
+        isSwipingRef.current = nextSwiping;
+        setIsSwiping(nextSwiping);
+        onSwipingChange?.(nextSwiping);
+    });
+    function resolveSwipeThreshold(direction) {
+        if (!direction) return;
+        if ('function' != typeof swipeThresholdProp) {
+            swipeThresholdRef.current = swipeThresholdDefault;
+            return;
+        }
+        const element = elementRef.current;
+        if (!element) return;
+        const value = swipeThresholdProp({
+            element,
+            direction
+        });
+        swipeThresholdRef.current = Math.max(0, value);
+    }
+    const updateSwipeProgress = useStableCallback((progress, details)=>{
+        const nextProgress = Number.isFinite(progress) ? clamp(progress, 0, 1) : 0;
+        const progressChanged = nextProgress !== swipeProgressRef.current;
+        let detailsChanged = false;
+        if (details) {
+            const lastDetails = lastProgressDetailsRef.current;
+            detailsChanged = !lastDetails || lastDetails.deltaX !== details.deltaX || lastDetails.deltaY !== details.deltaY || lastDetails.direction !== details.direction;
+        }
+        if (!progressChanged && !detailsChanged) return;
+        swipeProgressRef.current = nextProgress;
+        if (details) lastProgressDetailsRef.current = details;
+        else if (progressChanged) lastProgressDetailsRef.current = null;
+        onProgress?.(nextProgress, details);
+    });
+    function recordDragSample(offset, timeStamp) {
+        if (null === timeStamp) return;
+        const lastSample = lastDragSampleRef.current;
+        if (lastSample && timeStamp > lastSample.time) {
+            const durationMs = Math.max(timeStamp - lastSample.time, MIN_RELEASE_VELOCITY_DURATION_MS);
+            lastDragVelocityRef.current = {
+                x: (offset.x - lastSample.x) / durationMs,
+                y: (offset.y - lastSample.y) / durationMs
+            };
+        }
+        lastDragSampleRef.current = {
+            x: offset.x,
+            y: offset.y,
+            time: timeStamp
+        };
+    }
+    const reset = __rspack_external_react.useCallback(()=>{
+        setCurrentSwipeDirection(void 0);
+        setSwiping(false);
+        setIsRealSwipe(false);
+        setDragDismissed(false);
+        setDragOffset({
+            x: 0,
+            y: 0
+        });
+        setInitialTransform({
+            x: 0,
+            y: 0,
+            scale: 1
+        });
+        setLockedDirection(null);
+        updateSwipeProgress(0);
+        swipeThresholdRef.current = swipeThresholdDefault;
+        dragStartPosRef.current = {
+            x: 0,
+            y: 0
+        };
+        dragOffsetRef.current = {
+            x: 0,
+            y: 0
+        };
+        initialTransformRef.current = {
+            x: 0,
+            y: 0,
+            scale: 1
+        };
+        intendedSwipeDirectionRef.current = void 0;
+        maxSwipeDisplacementRef.current = 0;
+        cancelledSwipeRef.current = false;
+        swipeCancelBaselineRef.current = {
+            x: 0,
+            y: 0
+        };
+        isFirstPointerMoveRef.current = false;
+        lastMovePosRef.current = null;
+        pendingSwipeRef.current = false;
+        pendingSwipeStartPosRef.current = null;
+        swipeFromScrollableRef.current = false;
+        sawPrimaryButtonsOnMoveRef.current = false;
+        elementSizeRef.current = {
+            width: 0,
+            height: 0
+        };
+        swipeStartTimeRef.current = null;
+        lastDragSampleRef.current = null;
+        lastDragVelocityRef.current = {
+            x: 0,
+            y: 0
+        };
+        lastProgressDetailsRef.current = null;
+    }, [
+        setSwiping,
+        swipeThresholdDefault,
+        updateSwipeProgress
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if ('function' != typeof swipeThresholdProp) swipeThresholdRef.current = swipeThresholdDefault;
+    }, [
+        swipeThresholdDefault,
+        swipeThresholdProp
+    ]);
+    function getPrimaryPointerPosition(event) {
+        if ('touches' in event) {
+            const touch = event.touches[0];
+            return touch ? {
+                x: touch.clientX,
+                y: touch.clientY
+            } : null;
+        }
+        return {
+            x: event.clientX,
+            y: event.clientY
+        };
+    }
+    function isTouchLikeEvent(event) {
+        if ('touches' in event) return true;
+        return 'touch' === event.pointerType;
+    }
+    function getTargetAtPoint(position, nativeEvent) {
+        const doc = ownerDocument(elementRef.current);
+        const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
+        const target = elementAtPoint ?? getTarget(nativeEvent);
+        return target;
+    }
+    function findGestureScrollableTouchTarget(target, root) {
+        if (hasHorizontal && !hasVertical) return findScrollableTouchTarget(target, root, 'horizontal');
+        if (hasVertical && !hasHorizontal) return findScrollableTouchTarget(target, root, 'vertical');
+        return findScrollableTouchTarget(target, root, 'vertical') ?? findScrollableTouchTarget(target, root, 'horizontal');
+    }
+    function startSwipeAtPosition(event, position, startOptions) {
+        swipeFromScrollableRef.current = false;
+        const touchLike = isTouchLikeEvent(event);
+        const target = getTargetAtPoint(position, event.nativeEvent);
+        const doc = ownerDocument(elementRef.current);
+        const body = doc.body;
+        const scrollableTarget = touchLike && body ? findGestureScrollableTouchTarget(target, body) : null;
+        const ignoreScrollableTarget = startOptions?.ignoreScrollableTarget ?? false;
+        if (scrollableTarget && !ignoreScrollableTarget) return false;
+        swipeFromScrollableRef.current = Boolean(scrollableTarget && ignoreScrollableTarget);
+        const isInteractiveElement = target ? target.closest(ignoreSelector) : false;
+        if (isInteractiveElement && (!touchLike || ignoreSelectorWhenTouch)) return false;
+        const element = elementRef.current;
+        if (ignoreScrollableAncestors && element && target && scrollAxes.length > 0) {
+            const ignoreAncestors = startOptions?.ignoreScrollableAncestors ?? false;
+            if (!ignoreAncestors && hasScrollableAncestor(target, element, scrollAxes)) return false;
+        }
+        cancelledSwipeRef.current = false;
+        intendedSwipeDirectionRef.current = void 0;
+        maxSwipeDisplacementRef.current = 0;
+        dragStartPosRef.current = position;
+        swipeStartTimeRef.current = getValidTimeStamp(event.timeStamp);
+        swipeCancelBaselineRef.current = position;
+        lastMovePosRef.current = position;
+        if (element) {
+            elementSizeRef.current = {
+                width: element.offsetWidth,
+                height: element.offsetHeight
+            };
+            resolveSwipeThreshold(primaryDirection);
+            const transform = getElementTransform(element);
+            initialTransformRef.current = transform;
+            dragOffsetRef.current = {
+                x: transform.x,
+                y: transform.y
+            };
+            setInitialTransform(transform);
+            setDragOffset({
+                x: transform.x,
+                y: transform.y
+            });
+            recordDragSample({
+                x: transform.x,
+                y: transform.y
+            }, swipeStartTimeRef.current);
+            if (!('touches' in event)) safelyChangePointerCapture(element, event.pointerId, 'setPointerCapture');
+        }
+        onSwipeStart?.(event.nativeEvent);
+        setSwiping(true);
+        setIsRealSwipe(false);
+        setLockedDirection(null);
+        isFirstPointerMoveRef.current = true;
+        updateSwipeProgress(0);
+        return true;
+    }
+    function resetPendingSwipeState() {
+        clearPendingSwipeStartState();
+        swipeFromScrollableRef.current = false;
+        lastMovePosRef.current = null;
+    }
+    function clearPendingSwipeStartState() {
+        pendingSwipeRef.current = false;
+        pendingSwipeStartPosRef.current = null;
+    }
+    function cancelSwipeInteraction(event) {
+        resetPendingSwipeState();
+        if (!isSwipingRef.current) return;
+        setSwiping(false);
+        setIsRealSwipe(false);
+        setLockedDirection(null);
+        const resolvedInitialTransform = trackDrag ? initialTransform : initialTransformRef.current;
+        dragOffsetRef.current = {
+            x: resolvedInitialTransform.x,
+            y: resolvedInitialTransform.y
+        };
+        setDragOffset({
+            x: resolvedInitialTransform.x,
+            y: resolvedInitialTransform.y
+        });
+        setCurrentSwipeDirection(void 0);
+        sawPrimaryButtonsOnMoveRef.current = false;
+        const element = elementRef.current;
+        if (element) safelyChangePointerCapture(element, event.pointerId, 'releasePointerCapture');
+        updateSwipeProgress(0, {
+            deltaX: 0,
+            deltaY: 0,
+            direction: void 0
+        });
+        onCancel?.(event.nativeEvent);
+    }
+    function applyDirectionalDamping(deltaX, deltaY) {
+        const exponent = (value)=>value >= 0 ? value ** 0.5 : -(Math.abs(value) ** 0.5);
+        const dampAxis = (delta, allowNegative, allowPositive)=>{
+            if (!allowNegative && delta < 0) return exponent(delta);
+            if (!allowPositive && delta > 0) return exponent(delta);
+            return delta;
+        };
+        const newDeltaX = hasHorizontal ? dampAxis(deltaX, allowLeft, allowRight) : exponent(deltaX);
+        const newDeltaY = hasVertical ? dampAxis(deltaY, allowUp, allowDown) : exponent(deltaY);
+        return {
+            x: newDeltaX,
+            y: newDeltaY
+        };
+    }
+    function canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY) {
+        const absDeltaX = Math.abs(deltaX);
+        const absDeltaY = Math.abs(deltaY);
+        const useVerticalAxis = hasVertical && 0 !== deltaY && (!hasHorizontal || absDeltaY >= absDeltaX);
+        if (useVerticalAxis) {
+            const maxScrollTop = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+            const atTop = scrollTarget.scrollTop <= 0;
+            const atBottom = scrollTarget.scrollTop >= maxScrollTop;
+            const movingDown = deltaY > 0;
+            const movingUp = deltaY < 0;
+            const canSwipeDown = movingDown && atTop && allowDown;
+            const canSwipeUp = movingUp && atBottom && allowUp;
+            return canSwipeDown || canSwipeUp;
+        }
+        const useHorizontalAxis = hasHorizontal && 0 !== deltaX && (!hasVertical || absDeltaX > absDeltaY);
+        if (useHorizontalAxis) {
+            const maxScrollLeft = Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth);
+            const atLeft = scrollTarget.scrollLeft <= 0;
+            const atRight = scrollTarget.scrollLeft >= maxScrollLeft;
+            const movingRight = deltaX > 0;
+            const movingLeft = deltaX < 0;
+            const canSwipeRight = movingRight && atLeft && allowRight;
+            const canSwipeLeft = movingLeft && atRight && allowLeft;
+            return canSwipeRight || canSwipeLeft;
+        }
+        return null;
+    }
+    const handleStart = useStableCallback((event)=>{
+        if (!enabled) return;
+        if (event.defaultPrevented || event.nativeEvent.defaultPrevented) return;
+        if (!('touches' in event) && 0 !== event.button) return;
+        const startPos = getPrimaryPointerPosition(event);
+        if (!startPos) return;
+        pendingSwipeRef.current = true;
+        pendingSwipeStartPosRef.current = startPos;
+        swipeFromScrollableRef.current = false;
+        sawPrimaryButtonsOnMoveRef.current = false;
+        const allowedToStart = canStart ? canStart(startPos, {
+            nativeEvent: event.nativeEvent,
+            direction: primaryDirection
+        }) : true;
+        if (!allowedToStart) return;
+        if (startSwipeAtPosition(event, startPos)) clearPendingSwipeStartState();
+    });
+    function handleMoveCore(event, position, movement) {
+        if (!enabled || !isSwipingRef.current) return;
+        const target = getTarget(event.nativeEvent);
+        if (isTouchLikeEvent(event) && !swipeFromScrollableRef.current) {
+            const boundaryElement = event.currentTarget;
+            if (findGestureScrollableTouchTarget(target, boundaryElement)) return;
+        }
+        if (!('touches' in event)) event.preventDefault();
+        if (isFirstPointerMoveRef.current) {
+            dragStartPosRef.current = position;
+            const moveTime = getValidTimeStamp(event.timeStamp);
+            if (null !== moveTime) swipeStartTimeRef.current = moveTime;
+            isFirstPointerMoveRef.current = false;
+        }
+        const clientX = position.x;
+        const clientY = position.y;
+        const movementX = movement.x;
+        const movementY = movement.y;
+        if (movementY < 0 && clientY > swipeCancelBaselineRef.current.y || movementY > 0 && clientY < swipeCancelBaselineRef.current.y) swipeCancelBaselineRef.current = {
+            x: swipeCancelBaselineRef.current.x,
+            y: clientY
+        };
+        if (movementX < 0 && clientX > swipeCancelBaselineRef.current.x || movementX > 0 && clientX < swipeCancelBaselineRef.current.x) swipeCancelBaselineRef.current = {
+            x: clientX,
+            y: swipeCancelBaselineRef.current.y
+        };
+        const deltaX = clientX - dragStartPosRef.current.x;
+        const deltaY = clientY - dragStartPosRef.current.y;
+        const cancelDeltaY = clientY - swipeCancelBaselineRef.current.y;
+        const cancelDeltaX = clientX - swipeCancelBaselineRef.current.x;
+        if (!isRealSwipe) {
+            const movementDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+            if (movementDistance >= MIN_DRAG_THRESHOLD) {
+                setIsRealSwipe(true);
+                if (null === lockedDirection) {
+                    if (hasHorizontal && hasVertical) {
+                        const absX = Math.abs(deltaX);
+                        const absY = Math.abs(deltaY);
+                        setLockedDirection(absX > absY ? 'horizontal' : 'vertical');
+                    }
+                }
+            }
+        }
+        let candidate;
+        if (intendedSwipeDirectionRef.current) {
+            const direction = intendedSwipeDirectionRef.current;
+            const currentDisplacement = getDisplacement(direction, cancelDeltaX, cancelDeltaY);
+            if (currentDisplacement > swipeThresholdRef.current) {
+                cancelledSwipeRef.current = false;
+                setCurrentSwipeDirection(direction);
+            } else if (!(allowLeft && allowRight) && !(allowUp && allowDown) && maxSwipeDisplacementRef.current - currentDisplacement >= REVERSE_CANCEL_THRESHOLD) cancelledSwipeRef.current = true;
+        } else {
+            if ('vertical' === lockedDirection) {
+                if (deltaY > 0) candidate = 'down';
+                else if (deltaY < 0) candidate = 'up';
+            } else if ('horizontal' === lockedDirection) {
+                if (deltaX > 0) candidate = 'right';
+                else if (deltaX < 0) candidate = 'left';
+            } else candidate = Math.abs(deltaX) >= Math.abs(deltaY) ? deltaX > 0 ? 'right' : 'left' : deltaY > 0 ? 'down' : 'up';
+            if (candidate) {
+                const isAllowed = 'left' === candidate && allowLeft || 'right' === candidate && allowRight || 'up' === candidate && allowUp || 'down' === candidate && allowDown;
+                if (isAllowed) {
+                    intendedSwipeDirectionRef.current = candidate;
+                    maxSwipeDisplacementRef.current = getDisplacement(candidate, deltaX, deltaY);
+                    setCurrentSwipeDirection(candidate);
+                    resolveSwipeThreshold(candidate);
+                }
+            }
+        }
+        const dampedDelta = applyDirectionalDamping(deltaX, deltaY);
+        let newOffsetX = initialTransformRef.current.x;
+        let newOffsetY = initialTransformRef.current.y;
+        if ('horizontal' === lockedDirection) {
+            if (hasHorizontal) newOffsetX += dampedDelta.x;
+        } else if ('vertical' === lockedDirection) {
+            if (hasVertical) newOffsetY += dampedDelta.y;
+        } else {
+            if (hasHorizontal) newOffsetX += dampedDelta.x;
+            if (hasVertical) newOffsetY += dampedDelta.y;
+        }
+        dragOffsetRef.current = {
+            x: newOffsetX,
+            y: newOffsetY
+        };
+        if (trackDrag) setDragOffset({
+            x: newOffsetX,
+            y: newOffsetY
+        });
+        recordDragSample({
+            x: newOffsetX,
+            y: newOffsetY
+        }, getValidTimeStamp(event.timeStamp));
+        const dragDeltaX = newOffsetX - initialTransformRef.current.x;
+        const dragDeltaY = newOffsetY - initialTransformRef.current.y;
+        const swipeDirectionDetails = intendedSwipeDirectionRef.current;
+        const progressDirection = primaryDirection ?? intendedSwipeDirectionRef.current;
+        if (!progressDirection) return void updateSwipeProgress(0, {
+            deltaX: dragDeltaX,
+            deltaY: dragDeltaY,
+            direction: swipeDirectionDetails
+        });
+        const size = 'left' === progressDirection || 'right' === progressDirection ? elementSizeRef.current.width : elementSizeRef.current.height;
+        const scale = initialTransformRef.current.scale || 1;
+        if (size <= 0 || scale <= 0) return void updateSwipeProgress(0, {
+            deltaX: dragDeltaX,
+            deltaY: dragDeltaY,
+            direction: swipeDirectionDetails
+        });
+        const progressDisplacement = getDisplacement(progressDirection, newOffsetX - initialTransformRef.current.x, newOffsetY - initialTransformRef.current.y);
+        if (progressDisplacement <= 0) return void updateSwipeProgress(0, {
+            deltaX: dragDeltaX,
+            deltaY: dragDeltaY,
+            direction: swipeDirectionDetails
+        });
+        updateSwipeProgress(progressDisplacement / (size * scale), {
+            deltaX: dragDeltaX,
+            deltaY: dragDeltaY,
+            direction: swipeDirectionDetails
+        });
+    }
+    const handleMove = useStableCallback((event)=>{
+        const currentPos = getPrimaryPointerPosition(event);
+        if (!currentPos) return;
+        if (!('touches' in event)) {
+            const hasPrimaryButton = hasPrimaryMouseButton(event.buttons);
+            if (hasPrimaryButton) sawPrimaryButtonsOnMoveRef.current = true;
+            const lostPrimaryButtonDuringSwipe = 0 === event.buttons && sawPrimaryButtonsOnMoveRef.current;
+            if (0 !== event.buttons && !hasPrimaryButton || lostPrimaryButtonDuringSwipe) return void cancelSwipeInteraction(event);
+        }
+        if (!isSwiping && pendingSwipeRef.current) {
+            if (!isTouchLikeEvent(event) && (event.defaultPrevented || event.nativeEvent.defaultPrevented)) return void resetPendingSwipeState();
+            const allowedToStart = canStart ? canStart(currentPos, {
+                nativeEvent: event.nativeEvent,
+                direction: primaryDirection
+            }) : true;
+            if (allowedToStart) {
+                const pendingStartPos = pendingSwipeStartPosRef.current;
+                let ignoreScrollableOnStart = false;
+                if (isTouchLikeEvent(event)) {
+                    const element = elementRef.current;
+                    if (pendingStartPos && element) {
+                        const target = getTargetAtPoint(currentPos, event.nativeEvent);
+                        const doc = ownerDocument(element);
+                        const body = doc.body;
+                        const scrollTarget = body ? findGestureScrollableTouchTarget(target, body) : null;
+                        if (scrollTarget && (contains(element, scrollTarget) || contains(scrollTarget, element))) {
+                            const deltaX = currentPos.x - pendingStartPos.x;
+                            const deltaY = currentPos.y - pendingStartPos.y;
+                            const canSwipeFromEdge = canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY);
+                            if (false === canSwipeFromEdge) return;
+                            if (true === canSwipeFromEdge) ignoreScrollableOnStart = true;
+                        }
+                    }
+                }
+                const started = startSwipeAtPosition(event, currentPos, {
+                    ignoreScrollableTarget: ignoreScrollableOnStart,
+                    ignoreScrollableAncestors: ignoreScrollableOnStart
+                });
+                if (started) if (pendingStartPos && ignoreScrollableOnStart) {
+                    clearPendingSwipeStartState();
+                    dragStartPosRef.current = pendingStartPos;
+                    swipeCancelBaselineRef.current = pendingStartPos;
+                    lastMovePosRef.current = pendingStartPos;
+                    isFirstPointerMoveRef.current = false;
+                } else {
+                    clearPendingSwipeStartState();
+                    swipeFromScrollableRef.current = false;
+                }
+            }
+        }
+        const previousPos = lastMovePosRef.current;
+        const movement = null === previousPos ? {
+            x: 0,
+            y: 0
+        } : {
+            x: currentPos.x - previousPos.x,
+            y: currentPos.y - previousPos.y
+        };
+        lastMovePosRef.current = currentPos;
+        handleMoveCore(event, currentPos, movement);
+    });
+    const handleEnd = useStableCallback((event)=>{
+        if (!enabled) return;
+        const resolvedDragOffset = dragOffsetRef.current;
+        const resolvedInitialTransform = initialTransformRef.current;
+        const releaseDeltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
+        const releaseDeltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
+        const progressDetails = {
+            deltaX: releaseDeltaX,
+            deltaY: releaseDeltaY,
+            direction: currentSwipeDirection ?? intendedSwipeDirectionRef.current
+        };
+        if (!isSwipingRef.current) {
+            resetPendingSwipeState();
+            updateSwipeProgress(0, progressDetails);
+            return;
+        }
+        setSwiping(false);
+        setIsRealSwipe(false);
+        setLockedDirection(null);
+        resetPendingSwipeState();
+        sawPrimaryButtonsOnMoveRef.current = false;
+        const element = elementRef.current;
+        if (element) {
+            if (!('touches' in event)) safelyChangePointerCapture(element, event.pointerId, 'releasePointerCapture');
+        }
+        const deltaX = releaseDeltaX;
+        const deltaY = releaseDeltaY;
+        const startTime = swipeStartTimeRef.current;
+        const endTime = getValidTimeStamp(event.timeStamp);
+        const durationMs = null !== startTime && null !== endTime && endTime > startTime ? endTime - startTime : 0;
+        const velocityDurationMs = durationMs > 0 ? Math.max(durationMs, MIN_VELOCITY_DURATION_MS) : 0;
+        const velocityX = velocityDurationMs > 0 ? deltaX / velocityDurationMs : 0;
+        const velocityY = velocityDurationMs > 0 ? deltaY / velocityDurationMs : 0;
+        let releaseVelocityX = lastDragVelocityRef.current.x;
+        let releaseVelocityY = lastDragVelocityRef.current.y;
+        const lastSample = lastDragSampleRef.current;
+        if (lastSample && null !== endTime && endTime >= lastSample.time) {
+            const ageMs = endTime - lastSample.time;
+            if (ageMs <= MAX_RELEASE_VELOCITY_AGE_MS) {
+                const sampleDurationMs = Math.max(ageMs, MIN_RELEASE_VELOCITY_DURATION_MS);
+                const deltaFromLastSampleX = resolvedDragOffset.x - lastSample.x;
+                const deltaFromLastSampleY = resolvedDragOffset.y - lastSample.y;
+                const sampleVelocityX = deltaFromLastSampleX / sampleDurationMs;
+                const sampleVelocityY = deltaFromLastSampleY / sampleDurationMs;
+                if (0 !== sampleVelocityX) releaseVelocityX = sampleVelocityX;
+                if (0 !== sampleVelocityY) releaseVelocityY = sampleVelocityY;
+            } else {
+                releaseVelocityX = 0;
+                releaseVelocityY = 0;
+            }
+        }
+        const releaseDecision = onRelease?.({
+            event: event.nativeEvent,
+            direction: currentSwipeDirection ?? intendedSwipeDirectionRef.current,
+            deltaX,
+            deltaY,
+            velocityX,
+            velocityY,
+            releaseVelocityX,
+            releaseVelocityY
+        });
+        const hasReleaseDecision = 'boolean' == typeof releaseDecision;
+        if (cancelledSwipeRef.current && !hasReleaseDecision) {
+            dragOffsetRef.current = {
+                x: resolvedInitialTransform.x,
+                y: resolvedInitialTransform.y
+            };
+            setDragOffset({
+                x: resolvedInitialTransform.x,
+                y: resolvedInitialTransform.y
+            });
+            setCurrentSwipeDirection(void 0);
+            updateSwipeProgress(0, progressDetails);
+            return;
+        }
+        let shouldClose = false;
+        let dismissDirection;
+        if (hasReleaseDecision) {
+            shouldClose = releaseDecision;
+            dismissDirection = currentSwipeDirection ?? intendedSwipeDirectionRef.current ?? primaryDirection;
+        } else for (const direction of directions){
+            switch(direction){
+                case 'right':
+                    if (deltaX > swipeThresholdRef.current) {
+                        shouldClose = true;
+                        dismissDirection = 'right';
+                    }
+                    break;
+                case 'left':
+                    if (deltaX < -swipeThresholdRef.current) {
+                        shouldClose = true;
+                        dismissDirection = 'left';
+                    }
+                    break;
+                case 'down':
+                    if (deltaY > swipeThresholdRef.current) {
+                        shouldClose = true;
+                        dismissDirection = 'down';
+                    }
+                    break;
+                case 'up':
+                    if (deltaY < -swipeThresholdRef.current) {
+                        shouldClose = true;
+                        dismissDirection = 'up';
+                    }
+                    break;
+                default:
+                    break;
+            }
+            if (shouldClose) break;
+        }
+        if (shouldClose && dismissDirection) {
+            setCurrentSwipeDirection(dismissDirection);
+            setDragDismissed(true);
+            onDismiss?.(event.nativeEvent, {
+                direction: dismissDirection
+            });
+        } else {
+            dragOffsetRef.current = {
+                x: resolvedInitialTransform.x,
+                y: resolvedInitialTransform.y
+            };
+            setDragOffset({
+                x: resolvedInitialTransform.x,
+                y: resolvedInitialTransform.y
+            });
+            setCurrentSwipeDirection(void 0);
+            updateSwipeProgress(0, progressDetails);
+        }
+    });
+    const getDragStyles = __rspack_external_react.useCallback(()=>{
+        const resolvedDragOffset = trackDrag ? dragOffset : dragOffsetRef.current;
+        const resolvedInitialTransform = trackDrag ? initialTransform : initialTransformRef.current;
+        if (!isSwiping && resolvedDragOffset.x === resolvedInitialTransform.x && resolvedDragOffset.y === resolvedInitialTransform.y && !dragDismissed) return {
+            [movementCssVars.x]: '0px',
+            [movementCssVars.y]: '0px'
+        };
+        const deltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
+        const deltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
+        return {
+            transition: isSwiping ? 'none' : void 0,
+            transform: isSwiping ? `translateX(${resolvedDragOffset.x}px) translateY(${resolvedDragOffset.y}px) scale(${resolvedInitialTransform.scale})` : void 0,
+            [movementCssVars.x]: `${deltaX}px`,
+            [movementCssVars.y]: `${deltaY}px`
+        };
+    }, [
+        dragDismissed,
+        dragOffset,
+        initialTransform,
+        isSwiping,
+        movementCssVars,
+        trackDrag
+    ]);
+    const getPointerProps = __rspack_external_react.useCallback(()=>{
+        if (!enabled) return {};
+        return {
+            onPointerDown: handleStart,
+            onPointerMove: handleMove,
+            onPointerUp: handleEnd,
+            onPointerCancel: handleEnd
+        };
+    }, [
+        enabled,
+        handleEnd,
+        handleMove,
+        handleStart
+    ]);
+    const getTouchProps = __rspack_external_react.useCallback(()=>{
+        if (!enabled) return {};
+        return {
+            onTouchStart: handleStart,
+            onTouchMove: handleMove,
+            onTouchEnd: handleEnd,
+            onTouchCancel: handleEnd
+        };
+    }, [
+        enabled,
+        handleEnd,
+        handleMove,
+        handleStart
+    ]);
+    return {
+        swiping: isSwiping,
+        swipeDirection: currentSwipeDirection,
+        dragDismissed,
+        getPointerProps,
+        getTouchProps,
+        getDragStyles,
+        reset
+    };
+}
+let DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes = function(DrawerSwipeAreaDataAttributes) {
+    DrawerSwipeAreaDataAttributes[DrawerSwipeAreaDataAttributes["open"] = popupStateMapping_CommonPopupDataAttributes.open] = "open";
+    DrawerSwipeAreaDataAttributes[DrawerSwipeAreaDataAttributes["closed"] = popupStateMapping_CommonPopupDataAttributes.closed] = "closed";
+    DrawerSwipeAreaDataAttributes["disabled"] = "data-disabled";
+    DrawerSwipeAreaDataAttributes["swipeDirection"] = "data-swipe-direction";
+    DrawerSwipeAreaDataAttributes["swiping"] = "data-swiping";
+    return DrawerSwipeAreaDataAttributes;
+}({});
+const DEFAULT_SWIPE_OPEN_RATIO = 0.5;
+const MIN_SWIPE_START_DISTANCE = 1;
+const VELOCITY_THRESHOLD = 0.1;
+const FALLBACK_SWIPE_OPEN_THRESHOLD = 40;
+const SWIPE_AREA_OPEN_HOOK = {
+    [DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes.open]: ''
+};
+const SWIPE_AREA_CLOSED_HOOK = {
+    [DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes.closed]: ''
+};
+const SWIPE_AREA_SWIPING_HOOK = {
+    [DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes.swiping]: ''
+};
+const SWIPE_AREA_DISABLED_HOOK = {
+    [DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes.disabled]: ''
+};
+const DrawerSwipeArea_stateAttributesMapping = {
+    open (value) {
+        return value ? SWIPE_AREA_OPEN_HOOK : SWIPE_AREA_CLOSED_HOOK;
+    },
+    swiping (value) {
+        return value ? SWIPE_AREA_SWIPING_HOOK : null;
+    },
+    swipeDirection (value) {
+        return value ? {
+            [DrawerSwipeAreaDataAttributes_DrawerSwipeAreaDataAttributes.swipeDirection]: value
+        } : null;
+    },
+    disabled (value) {
+        return value ? SWIPE_AREA_DISABLED_HOOK : null;
+    }
+};
+const oppositeSwipeDirection = {
+    up: 'down',
+    down: 'up',
+    left: 'right',
+    right: 'left'
+};
+function resolveTouchAction(direction) {
+    return 'left' === direction || 'right' === direction ? 'pan-y' : 'pan-x';
+}
+const DrawerSwipeArea_DrawerSwipeArea = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, disabled = false, swipeDirection: swipeDirectionProp, ...elementProps } = componentProps;
+    const { store } = useDialogRootContext();
+    const { swipeDirection, frontmostHeight } = useDrawerRootContext();
+    const providerContext = useDrawerProviderContext(true);
+    const [swipeActive, setSwipeActive] = __rspack_external_react.useState(false);
+    const releaseDismissTimeout = useTimeout();
+    const swipeAreaRef = __rspack_external_react.useRef(null);
+    const swipeStartEventRef = __rspack_external_react.useRef(null);
+    const openedBySwipeRef = __rspack_external_react.useRef(false);
+    const dragDeltaRef = __rspack_external_react.useRef({
+        x: 0,
+        y: 0
+    });
+    const closedOffsetRef = __rspack_external_react.useRef(null);
+    const appliedSwipeStylesRef = __rspack_external_react.useRef(false);
+    const popupTransitionRef = __rspack_external_react.useRef(null);
+    const swipeAreaId = useBaseUiId(componentProps.id);
+    const registerTrigger = useTriggerRegistration(swipeAreaId, store);
+    const open = store.useState('open');
+    const resetDragDelta = useStableCallback(()=>{
+        dragDeltaRef.current.x = 0;
+        dragDeltaRef.current.y = 0;
+    });
+    const resolvedSwipeDirection = swipeDirectionProp ?? oppositeSwipeDirection[swipeDirection];
+    const dismissDirection = oppositeSwipeDirection[resolvedSwipeDirection];
+    const enabled = !disabled && (!open || swipeActive);
+    function disableDismissForSwipe() {
+        releaseDismissTimeout.clear();
+        store.context.outsidePressEnabledRef.current = false;
+    }
+    function enableDismissAfterRelease() {
+        releaseDismissTimeout.start(0, ()=>{
+            store.context.outsidePressEnabledRef.current = true;
+        });
+    }
+    function resolvePopupSize() {
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) return null;
+        const isHorizontal = 'left' === dismissDirection || 'right' === dismissDirection;
+        const size = isHorizontal ? popupElement.offsetWidth : popupElement.offsetHeight;
+        if (size <= 0) return null;
+        return size;
+    }
+    function resolveClosedOffset() {
+        const offset = resolvePopupSize();
+        if (null == offset) return null;
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) return offset;
+        const isHorizontal = 'left' === dismissDirection || 'right' === dismissDirection;
+        const transform = getElementTransform(popupElement);
+        const transformOffset = isHorizontal ? transform.x : transform.y;
+        if (Number.isFinite(transformOffset) && Math.abs(transformOffset) > 0.5) return Math.min(offset, Math.abs(transformOffset));
+        return offset;
+    }
+    function resolveSwipeOpenThreshold() {
+        const popupSize = resolvePopupSize();
+        if (null == popupSize) return FALLBACK_SWIPE_OPEN_THRESHOLD;
+        return popupSize * DEFAULT_SWIPE_OPEN_RATIO;
+    }
+    function applySwipeMovement() {
+        if (!swipeActive) return;
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) return;
+        if (!store.select('open') || !store.select('mounted')) return;
+        if (null == closedOffsetRef.current) closedOffsetRef.current = resolveClosedOffset();
+        const closedOffset = closedOffsetRef.current;
+        if (!closedOffset || !Number.isFinite(closedOffset) || closedOffset <= 0) return;
+        const { x, y } = dragDeltaRef.current;
+        const displacement = getDisplacement(resolvedSwipeDirection, x, y);
+        const clampedDisplacement = Math.max(0, displacement);
+        const dampedDisplacement = clampedDisplacement > closedOffset ? closedOffset + Math.sqrt(clampedDisplacement - closedOffset) : clampedDisplacement;
+        const remaining = closedOffset - dampedDisplacement;
+        const directionSign = 'left' === dismissDirection || 'up' === dismissDirection ? -1 : 1;
+        const movement = remaining * directionSign;
+        const isHorizontal = 'left' === dismissDirection || 'right' === dismissDirection;
+        const movementX = isHorizontal ? movement : 0;
+        const movementY = isHorizontal ? 0 : movement;
+        const openProgress = Math.max(0, Math.min(1, clampedDisplacement / closedOffset));
+        const backdropProgress = Math.max(0, Math.min(1, 1 - openProgress));
+        popupElement.style.setProperty(DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementX, `${movementX}px`);
+        popupElement.style.setProperty(DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY, `${movementY}px`);
+        popupElement.setAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping, '');
+        if (null === popupTransitionRef.current) popupTransitionRef.current = popupElement.style.transition;
+        popupElement.style.transition = 'none';
+        const backdropElement = store.context.backdropRef.current;
+        if (backdropElement) {
+            backdropElement.setAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping, '');
+            backdropElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, `${backdropProgress}`);
+            if (openProgress > 0 && frontmostHeight > 0) backdropElement.style.setProperty(DrawerPopupCssVars_DrawerPopupCssVars.height, `${frontmostHeight}px`);
+            else backdropElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+        }
+        providerContext?.visualStateStore.set({
+            swipeProgress: openProgress,
+            frontmostHeight: openProgress > 0 ? frontmostHeight : 0
+        });
+        appliedSwipeStylesRef.current = true;
+    }
+    const clearSwipeStyles = useStableCallback(()=>{
+        const popupElement = store.context.popupRef.current;
+        if (popupElement && appliedSwipeStylesRef.current) {
+            popupElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementX);
+            popupElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY);
+            popupElement.removeAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping);
+        }
+        if (popupElement && null !== popupTransitionRef.current) {
+            popupElement.style.transition = popupTransitionRef.current;
+            popupTransitionRef.current = null;
+        }
+        const backdropElement = store.context.backdropRef.current;
+        if (backdropElement) {
+            backdropElement.removeAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping);
+            backdropElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+            backdropElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+        }
+        providerContext?.visualStateStore.set({
+            swipeProgress: 0,
+            frontmostHeight: 0
+        });
+        appliedSwipeStylesRef.current = false;
+    });
+    function openDrawer(event) {
+        if (store.select('open')) return;
+        openedBySwipeRef.current = true;
+        store.setOpen(true, createChangeEventDetails("swipe", event, swipeAreaRef.current ?? void 0));
+    }
+    function closeDrawer(event) {
+        if (!store.select('open')) return;
+        store.setOpen(false, createChangeEventDetails("swipe", event, swipeAreaRef.current ?? void 0));
+    }
+    function resetSwipeInteractionState() {
+        swipeStartEventRef.current = null;
+        openedBySwipeRef.current = false;
+        closedOffsetRef.current = null;
+        setSwipeActive(false);
+    }
+    function finishSwipeInteraction() {
+        resetSwipeInteractionState();
+        enableDismissAfterRelease();
+        resetDragDelta();
+        clearSwipeStyles();
+    }
+    const swipe = useSwipeDismiss({
+        enabled,
+        directions: [
+            resolvedSwipeDirection
+        ],
+        elementRef: swipeAreaRef,
+        trackDrag: false,
+        movementCssVars: {
+            x: DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementX,
+            y: DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY
+        },
+        onSwipeStart (event) {
+            disableDismissForSwipe();
+            swipeStartEventRef.current = event;
+            openedBySwipeRef.current = false;
+            setSwipeActive(true);
+            resetDragDelta();
+        },
+        onProgress (_progress, details) {
+            if (!details) return;
+            if (!swipeStartEventRef.current) return;
+            dragDeltaRef.current.x = details.deltaX;
+            dragDeltaRef.current.y = details.deltaY;
+            if (details.direction !== resolvedSwipeDirection) return;
+            const displacement = getDisplacement(resolvedSwipeDirection, details.deltaX, details.deltaY);
+            if (displacement < MIN_SWIPE_START_DISTANCE && !openedBySwipeRef.current) return;
+            if (!openedBySwipeRef.current) openDrawer(swipeStartEventRef.current);
+            applySwipeMovement();
+        },
+        onRelease ({ event, direction, deltaX, deltaY, releaseVelocityX, releaseVelocityY }) {
+            const displacement = getDisplacement(resolvedSwipeDirection, deltaX, deltaY);
+            const releaseVelocity = getDisplacement(resolvedSwipeDirection, releaseVelocityX, releaseVelocityY);
+            const threshold = resolveSwipeOpenThreshold();
+            const hasEnoughDistance = null != threshold && displacement >= threshold;
+            const hasEnoughVelocity = releaseVelocity >= VELOCITY_THRESHOLD;
+            const shouldOpen = null != threshold && direction === resolvedSwipeDirection && (hasEnoughDistance || hasEnoughVelocity) && !disabled;
+            if (shouldOpen) {
+                if (!store.select('open')) openDrawer(event);
+            } else if (openedBySwipeRef.current) closeDrawer(event);
+            finishSwipeInteraction();
+            return false;
+        },
+        onCancel: finishSwipeInteraction
+    });
+    const swipePointerProps = swipe.getPointerProps();
+    const swipeTouchProps = swipe.getTouchProps();
+    const resetSwipe = swipe.reset;
+    __rspack_external_react.useEffect(()=>{
+        if (!enabled) {
+            resetSwipe();
+            resetDragDelta();
+            clearSwipeStyles();
+            resetSwipeInteractionState();
+        }
+    }, [
+        clearSwipeStyles,
+        enabled,
+        resetDragDelta,
+        resetSwipe
+    ]);
+    __rspack_external_react.useEffect(()=>()=>{
+            store.context.outsidePressEnabledRef.current = true;
+        }, [
+        store
+    ]);
+    const state = {
+        open,
+        swiping: swipe.swiping,
+        swipeDirection: resolvedSwipeDirection,
+        disabled
+    };
+    return useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            swipeAreaRef,
+            registerTrigger
+        ],
+        stateAttributesMapping: DrawerSwipeArea_stateAttributesMapping,
+        props: [
+            {
+                role: 'presentation',
+                'aria-hidden': true,
+                style: {
+                    pointerEvents: enabled ? void 0 : 'none',
+                    touchAction: resolveTouchAction(resolvedSwipeDirection)
+                },
+                onPointerDown (event) {
+                    if ('touch' === event.pointerType) return;
+                    swipePointerProps.onPointerDown?.(event);
+                    if (event.cancelable) event.preventDefault();
+                },
+                onPointerMove (event) {
+                    if ('touch' === event.pointerType) return;
+                    swipePointerProps.onPointerMove?.(event);
+                },
+                onPointerUp (event) {
+                    if ('touch' === event.pointerType) return;
+                    swipePointerProps.onPointerUp?.(event);
+                },
+                onPointerCancel (event) {
+                    if ('touch' === event.pointerType) return;
+                    swipePointerProps.onPointerCancel?.(event);
+                }
+            },
+            swipeTouchProps,
+            swipeAreaId ? {
+                id: swipeAreaId
+            } : void 0,
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerSwipeArea_DrawerSwipeArea.displayName = "DrawerSwipeArea";
+const MIN_SWIPE_THRESHOLD = 10;
+const FAST_SWIPE_VELOCITY = 0.5;
+const SNAP_VELOCITY_THRESHOLD = 0.5;
+const SNAP_VELOCITY_MULTIPLIER = 300;
+const MAX_SNAP_VELOCITY = 4;
+const MIN_SWIPE_RELEASE_VELOCITY = 0.2;
+const MAX_SWIPE_RELEASE_VELOCITY = 4;
+const MIN_SWIPE_RELEASE_DURATION_MS = 80;
+const MAX_SWIPE_RELEASE_DURATION_MS = 360;
+const MIN_SWIPE_RELEASE_SCALAR = 0.1;
+const MAX_SWIPE_RELEASE_SCALAR = 1;
+const DRAWER_CONTENT_SELECTOR = `[${DRAWER_CONTENT_ATTRIBUTE}]`;
+const DrawerViewport_DrawerViewport = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const { render, className, style, children, ...elementProps } = props;
+    const { store } = useDialogRootContext();
+    const { swipeDirection, notifyParentSwipingChange, notifyParentSwipeProgressChange, frontmostHeight, snapToSequentialPoints } = useDrawerRootContext();
+    const providerContext = useDrawerProviderContext(true);
+    const { snapPoints, resolvedSnapPoints, activeSnapPoint, activeSnapPointOffset, setActiveSnapPoint, popupHeight } = useDrawerSnapPoints();
+    const open = store.useState('open');
+    const mounted = store.useState('mounted');
+    const nested = store.useState('nested');
+    const nestedOpenDrawerCount = store.useState('nestedOpenDrawerCount');
+    const viewportElement = store.useState('viewportElement');
+    const popupElementState = store.useState('popupElement');
+    const visualStateStore = providerContext?.visualStateStore;
+    const nestedDrawerOpen = nestedOpenDrawerCount > 0;
+    const scrollAxis = 'left' === swipeDirection || 'right' === swipeDirection ? 'horizontal' : 'vertical';
+    const isVerticalScrollAxis = 'vertical' === scrollAxis;
+    const crossScrollAxis = isVerticalScrollAxis ? 'horizontal' : 'vertical';
+    const [swipeRelease, setSwipeRelease] = __rspack_external_react.useState(null);
+    const pendingSwipeCloseSnapPointRef = __rspack_external_react.useRef(void 0);
+    const resetSwipeRef = __rspack_external_react.useRef(null);
+    const controlledDismissFrame = useAnimationFrame();
+    const nestedSwipeActiveRef = __rspack_external_react.useRef(false);
+    const lastPointerTypeRef = __rspack_external_react.useRef('');
+    const ignoreNextTouchStartFromPenRef = __rspack_external_react.useRef(false);
+    const ignoreTouchSwipeRef = __rspack_external_react.useRef(false);
+    const touchScrollStateRef = __rspack_external_react.useRef(null);
+    const snapPointRange = __rspack_external_react.useMemo(()=>{
+        if (!snapPoints || snapPoints.length < 2) return null;
+        if ('down' !== swipeDirection && 'up' !== swipeDirection) return null;
+        if (resolvedSnapPoints.length < 2) return null;
+        const offsets = resolvedSnapPoints.map((point)=>point.offset).filter((offset)=>Number.isFinite(offset)).sort((a, b)=>a - b);
+        if (offsets.length < 2) return null;
+        const minOffset = offsets[0];
+        const nextOffset = offsets[1];
+        const maxOffset = offsets[offsets.length - 1];
+        let range = nextOffset - minOffset;
+        if (!Number.isFinite(range) || range <= 0) {
+            const fallbackRange = maxOffset - minOffset;
+            if (!Number.isFinite(fallbackRange) || fallbackRange <= 0) return null;
+            range = fallbackRange;
+        }
+        return {
+            minOffset,
+            range
+        };
+    }, [
+        resolvedSnapPoints,
+        snapPoints,
+        swipeDirection
+    ]);
+    const snapPointProgress = __rspack_external_react.useMemo(()=>{
+        if (!snapPointRange || null === activeSnapPointOffset) return null;
+        return clamp((activeSnapPointOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+    }, [
+        activeSnapPointOffset,
+        snapPointRange
+    ]);
+    const swipeDirections = __rspack_external_react.useMemo(()=>{
+        if (snapPoints && snapPoints.length > 0 && ('down' === swipeDirection || 'up' === swipeDirection)) return 'down' === swipeDirection ? [
+            'down',
+            'up'
+        ] : [
+            'up',
+            'down'
+        ];
+        return [
+            swipeDirection
+        ];
+    }, [
+        snapPoints,
+        swipeDirection
+    ]);
+    const setSwipeDismissed = useStableCallback((dismissed)=>{
+        setSwipeDismissedElements(store.context.popupRef.current, store.context.backdropRef.current, dismissed);
+    });
+    const clearSwipeRelease = useStableCallback(()=>{
+        setSwipeDismissed(false);
+        store.context.popupRef.current?.removeAttribute(stateAttributesMapping_TransitionStatusDataAttributes.endingStyle);
+        setSwipeRelease(null);
+    });
+    const finishNestedSwipe = useStableCallback(()=>{
+        if (!nestedSwipeActiveRef.current) return;
+        nestedSwipeActiveRef.current = false;
+        notifyParentSwipingChange?.(false);
+    });
+    const applySwipeProgress = useStableCallback(({ resolvedProgress, shouldTrackProgress, notifyParent })=>{
+        const isActive = open && !nested && shouldTrackProgress;
+        const swipeProgress = isActive ? resolvedProgress : 0;
+        const nestedSwipeProgress = open && shouldTrackProgress ? resolvedProgress : 0;
+        if (notifyParent && notifyParentSwipeProgressChange) {
+            notifyParentSwipeProgressChange(nestedSwipeProgress);
+            if (nestedSwipeProgress <= 0) finishNestedSwipe();
+        }
+        visualStateStore?.set({
+            swipeProgress,
+            frontmostHeight: swipeProgress > 0 ? frontmostHeight : 0
+        });
+        const backdropElement = store.context.backdropRef.current;
+        if (!backdropElement) return;
+        if (!isActive || swipeProgress <= 0) {
+            backdropElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+            backdropElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+            return;
+        }
+        backdropElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, `${swipeProgress}`);
+        if (frontmostHeight > 0) backdropElement.style.setProperty(DrawerPopupCssVars_DrawerPopupCssVars.height, `${frontmostHeight}px`);
+        else backdropElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+    });
+    function resolveSwipeRelease({ direction, deltaX, deltaY, velocityX, velocityY, releaseVelocityX, releaseVelocityY }) {
+        if (!direction) return null;
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) return null;
+        const size = 'left' === direction || 'right' === direction ? popupElement.offsetWidth : popupElement.offsetHeight;
+        if (!Number.isFinite(size) || size <= 0) return null;
+        const axisDelta = 'left' === direction || 'right' === direction ? deltaX : deltaY;
+        const snapPointBaseOffset = snapPoints && snapPoints.length > 0 ? activeSnapPointOffset ?? 0 : 0;
+        let baseOffset = 0;
+        if ('down' === direction) baseOffset = snapPointBaseOffset;
+        else if ('up' === direction) baseOffset = -snapPointBaseOffset;
+        const translation = baseOffset + axisDelta;
+        const translationAlongDirection = 'left' === direction || 'up' === direction ? -translation : translation;
+        const remainingDistance = Math.max(0, size - translationAlongDirection);
+        if (!Number.isFinite(remainingDistance) || remainingDistance <= 0) return null;
+        const axisVelocity = 'left' === direction || 'right' === direction ? releaseVelocityX : releaseVelocityY;
+        const fallbackVelocity = 'left' === direction || 'right' === direction ? velocityX : velocityY;
+        const resolvedVelocity = Math.abs(axisVelocity) > 0 && Number.isFinite(axisVelocity) ? axisVelocity : fallbackVelocity;
+        const directionalVelocity = 'left' === direction || 'up' === direction ? -resolvedVelocity : resolvedVelocity;
+        if (!Number.isFinite(directionalVelocity) || directionalVelocity <= MIN_SWIPE_RELEASE_VELOCITY) return null;
+        const clampedVelocity = clamp(directionalVelocity, MIN_SWIPE_RELEASE_VELOCITY, MAX_SWIPE_RELEASE_VELOCITY);
+        const durationMs = clamp(remainingDistance / clampedVelocity, MIN_SWIPE_RELEASE_DURATION_MS, MAX_SWIPE_RELEASE_DURATION_MS);
+        if (!Number.isFinite(durationMs)) return null;
+        const normalizedDuration = (durationMs - MIN_SWIPE_RELEASE_DURATION_MS) / (MAX_SWIPE_RELEASE_DURATION_MS - MIN_SWIPE_RELEASE_DURATION_MS);
+        const durationScalar = clamp(MIN_SWIPE_RELEASE_SCALAR + normalizedDuration * (MAX_SWIPE_RELEASE_SCALAR - MIN_SWIPE_RELEASE_SCALAR), MIN_SWIPE_RELEASE_SCALAR, MAX_SWIPE_RELEASE_SCALAR);
+        if (!Number.isFinite(durationScalar) || durationScalar <= 0) return null;
+        return durationScalar;
+    }
+    function updateNestedSwipeActive(details) {
+        if (nestedSwipeActiveRef.current || !details) return;
+        const direction = details.direction ?? swipeDirection;
+        const delta = 'left' === direction || 'right' === direction ? details.deltaX : details.deltaY;
+        if (!Number.isFinite(delta) || Math.abs(delta) < MIN_SWIPE_THRESHOLD) return;
+        nestedSwipeActiveRef.current = true;
+        notifyParentSwipingChange?.(true);
+    }
+    const swipe = useSwipeDismiss({
+        enabled: mounted && !nestedDrawerOpen,
+        directions: swipeDirections,
+        elementRef: store.context.popupRef,
+        ignoreSelectorWhenTouch: false,
+        ignoreScrollableAncestors: true,
+        movementCssVars: {
+            x: DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementX,
+            y: DrawerPopupCssVars_DrawerPopupCssVars.swipeMovementY
+        },
+        onSwipeStart (event) {
+            if ('touches' in event || 'pointerType' in event && 'touch' === event.pointerType) return;
+            const popupElement = store.context.popupRef.current;
+            if (!popupElement) return;
+            const doc = ownerDocument(popupElement);
+            const selection = doc.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) {
+            setBackdropSwipingAttribute(store.context.backdropRef.current, swiping);
+            if (!swiping && !notifyParentSwipeProgressChange) finishNestedSwipe();
+        },
+        swipeThreshold ({ element, direction }) {
+            return getBaseSwipeThreshold(element, direction);
+        },
+        canStart (position, details) {
+            const popupElement = store.context.popupRef.current;
+            if (!popupElement) return false;
+            const doc = popupElement.ownerDocument;
+            const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
+            if (!elementAtPoint || !contains(popupElement, elementAtPoint)) return false;
+            const nativeEvent = details.nativeEvent;
+            const touchLike = 'touches' in nativeEvent || 'pointerType' in nativeEvent && 'touch' === nativeEvent.pointerType;
+            if (touchLike && shouldIgnoreSwipeForTextSelection(doc, popupElement)) return false;
+            if ('touchstart' === nativeEvent.type && isSwipeIgnoredTarget(elementAtPoint)) return false;
+            return true;
+        },
+        onProgress (progress, details) {
+            updateNestedSwipeActive(details);
+            const currentDirection = details?.direction ?? swipe.swipeDirection;
+            const isDismissSwipe = void 0 === currentDirection || currentDirection === swipeDirection;
+            const hasSnapPoints = Boolean(snapPoints && snapPoints.length > 0);
+            const isVerticalSwipe = 'down' === swipeDirection || 'up' === swipeDirection;
+            const shouldTrackProgress = hasSnapPoints && isVerticalSwipe || !hasSnapPoints || 'left' === swipeDirection || 'right' === swipeDirection || isDismissSwipe;
+            let resolvedProgress = progress;
+            if (snapPointRange && popupHeight > 0) {
+                if (details && Number.isFinite(details.deltaY)) {
+                    const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
+                    const nextOffset = clamp(baseOffset + details.deltaY, 0, popupHeight);
+                    resolvedProgress = clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+                } else if (null !== snapPointProgress) resolvedProgress = snapPointProgress;
+                else if ('down' === currentDirection || 'up' === currentDirection) {
+                    const displacement = progress * popupHeight;
+                    const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
+                    const nextOffset = 'down' === currentDirection ? baseOffset + displacement : baseOffset - displacement;
+                    resolvedProgress = clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
+                }
+            }
+            applySwipeProgress({
+                resolvedProgress,
+                shouldTrackProgress,
+                notifyParent: true
+            });
+        },
+        onRelease ({ event, deltaX, deltaY, direction, velocityX, velocityY, releaseVelocityX, releaseVelocityY }) {
+            const swipeReleasePayload = {
+                deltaX,
+                deltaY,
+                velocityX,
+                velocityY,
+                releaseVelocityX,
+                releaseVelocityY
+            };
+            function startSwipeRelease(resolvedDirection) {
+                const popupElement = store.context.popupRef.current;
+                if (!popupElement) return;
+                finishNestedSwipe();
+                setSwipeDismissed(true);
+                popupElement.style.removeProperty('transition');
+                popupElement.setAttribute(stateAttributesMapping_TransitionStatusDataAttributes.endingStyle, '');
+                __rspack_external_react_dom_7136dc57.flushSync(()=>{
+                    setSwipeRelease(resolveSwipeRelease({
+                        direction: resolvedDirection,
+                        ...swipeReleasePayload
+                    }));
+                });
+            }
+            if (!snapPoints || 0 === snapPoints.length) {
+                if (!direction) return void clearSwipeRelease();
+                const element = store.context.popupRef.current;
+                if (!element) return void clearSwipeRelease();
+                const baseThreshold = getBaseSwipeThreshold(element, direction);
+                const delta = 'left' === direction || 'right' === direction ? deltaX : deltaY;
+                if (!Number.isFinite(delta)) return void clearSwipeRelease();
+                const directionalDelta = 'left' === direction || 'up' === direction ? -delta : delta;
+                if (directionalDelta <= 0) {
+                    clearSwipeRelease();
+                    return false;
+                }
+                const velocity = 'left' === direction || 'right' === direction ? velocityX : velocityY;
+                const directionalVelocity = 'left' === direction || 'up' === direction ? -velocity : velocity;
+                if (directionalVelocity >= FAST_SWIPE_VELOCITY && directionalDelta > 0) {
+                    startSwipeRelease(direction);
+                    return true;
+                }
+                const shouldClose = directionalDelta > baseThreshold;
+                if (shouldClose) startSwipeRelease(direction);
+                else clearSwipeRelease();
+                return shouldClose;
+            }
+            if ('down' !== swipeDirection && 'up' !== swipeDirection) return void clearSwipeRelease();
+            if (!popupHeight || 0 === resolvedSnapPoints.length) return void clearSwipeRelease();
+            const dragDelta = 'down' === swipeDirection ? deltaY : -deltaY;
+            if (!Number.isFinite(dragDelta)) return void clearSwipeRelease();
+            const dragDirection = Math.sign(dragDelta);
+            const releaseDirectionalVelocity = 'down' === swipeDirection ? releaseVelocityY : -releaseVelocityY;
+            const fallbackDirectionalVelocity = 'down' === swipeDirection ? velocityY : -velocityY;
+            let resolvedDirectionalVelocity = Number.isFinite(releaseDirectionalVelocity) ? releaseDirectionalVelocity : fallbackDirectionalVelocity;
+            if (0 !== dragDirection && Math.abs(dragDelta) >= MIN_SWIPE_THRESHOLD && Number.isFinite(resolvedDirectionalVelocity)) {
+                const velocityDirection = Math.sign(resolvedDirectionalVelocity);
+                if (0 !== velocityDirection && velocityDirection !== dragDirection) resolvedDirectionalVelocity = fallbackDirectionalVelocity;
+            }
+            const currentOffset = activeSnapPointOffset ?? 0;
+            const dragTargetOffset = clamp(currentOffset + dragDelta, 0, popupHeight);
+            const velocityOffset = Number.isFinite(resolvedDirectionalVelocity) && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? clamp(resolvedDirectionalVelocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
+            const targetOffset = snapToSequentialPoints ? dragTargetOffset : clamp(dragTargetOffset + velocityOffset, 0, popupHeight);
+            const snapPointEventDetails = createChangeEventDetails("swipe", event);
+            const closeFromSnapPoints = ()=>{
+                pendingSwipeCloseSnapPointRef.current = activeSnapPoint;
+                setActiveSnapPoint?.(null, snapPointEventDetails);
+                startSwipeRelease(swipeDirection);
+                return true;
+            };
+            if (snapToSequentialPoints) {
+                const orderedSnapPoints = [
+                    ...resolvedSnapPoints
+                ].sort((first, second)=>first.offset - second.offset);
+                if (0 === orderedSnapPoints.length) {
+                    clearSwipeRelease();
+                    return false;
+                }
+                let currentIndex = 0;
+                let closestDistance = Math.abs(currentOffset - orderedSnapPoints[0].offset);
+                for(let index = 1; index < orderedSnapPoints.length; index += 1){
+                    const distance = Math.abs(currentOffset - orderedSnapPoints[index].offset);
+                    if (distance < closestDistance) {
+                        closestDistance = distance;
+                        currentIndex = index;
+                    }
+                }
+                let targetSnapPoint = orderedSnapPoints[0];
+                closestDistance = Math.abs(targetOffset - targetSnapPoint.offset);
+                for (const snapPoint of orderedSnapPoints){
+                    const distance = Math.abs(targetOffset - snapPoint.offset);
+                    if (distance < closestDistance) {
+                        closestDistance = distance;
+                        targetSnapPoint = snapPoint;
+                    }
+                }
+                const velocityDirection = Math.sign(resolvedDirectionalVelocity);
+                const shouldAdvance = 0 !== dragDirection && 0 !== velocityDirection && 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];
+                        const shouldForceAdjacent = dragDirection > 0 ? targetOffset < adjacentPoint.offset : targetOffset > adjacentPoint.offset;
+                        if (shouldForceAdjacent) {
+                            targetSnapPoint = adjacentPoint;
+                            effectiveTargetOffset = adjacentPoint.offset;
+                        }
+                    } else if (dragDirection > 0) return closeFromSnapPoints();
+                }
+                const closeOffset = popupHeight;
+                const closeDistance = Math.abs(effectiveTargetOffset - closeOffset);
+                const snapDistance = Math.abs(effectiveTargetOffset - targetSnapPoint.offset);
+                if (closeDistance < snapDistance) return closeFromSnapPoints();
+                setActiveSnapPoint?.(targetSnapPoint.value, snapPointEventDetails);
+                clearSwipeRelease();
+                return false;
+            }
+            if (resolvedDirectionalVelocity >= FAST_SWIPE_VELOCITY && dragDelta > 0) return closeFromSnapPoints();
+            let closestSnapPoint = resolvedSnapPoints[0];
+            let closestDistance = Math.abs(targetOffset - closestSnapPoint.offset);
+            for (const snapPoint of resolvedSnapPoints){
+                const distance = Math.abs(targetOffset - snapPoint.offset);
+                if (distance < closestDistance) {
+                    closestDistance = distance;
+                    closestSnapPoint = snapPoint;
+                }
+            }
+            const closeOffset = popupHeight;
+            const closeDistance = Math.abs(targetOffset - closeOffset);
+            if (closeDistance < closestDistance) return closeFromSnapPoints();
+            setActiveSnapPoint?.(closestSnapPoint.value, snapPointEventDetails);
+            clearSwipeRelease();
+            return false;
+        },
+        onDismiss (event) {
+            visualStateStore?.set({
+                swipeProgress: 0,
+                frontmostHeight: 0
+            });
+            const backdropElement = store.context.backdropRef.current;
+            if (backdropElement) {
+                backdropElement.style.setProperty(DrawerBackdropCssVars_DrawerBackdropCssVars.swipeProgress, '0');
+                backdropElement.style.removeProperty(DrawerPopupCssVars_DrawerPopupCssVars.height);
+            }
+            const dismissEventDetails = createChangeEventDetails("swipe", event);
+            store.setOpen(false, dismissEventDetails);
+            if (dismissEventDetails.isCanceled) {
+                const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
+                if (void 0 !== pendingSnapPoint) setActiveSnapPoint?.(pendingSnapPoint, createChangeEventDetails("swipe", event));
+                pendingSwipeCloseSnapPointRef.current = void 0;
+                resetSwipeRef.current?.();
+                clearSwipeRelease();
+                return;
+            }
+            if (store.select('open')) {
+                const savedEvent = event;
+                controlledDismissFrame.request(()=>{
+                    if (store.select('open')) {
+                        const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
+                        if (void 0 !== pendingSnapPoint) setActiveSnapPoint?.(pendingSnapPoint, createChangeEventDetails("swipe", savedEvent));
+                        pendingSwipeCloseSnapPointRef.current = void 0;
+                        clearSwipeRelease();
+                        resetSwipeRef.current?.();
+                    } else pendingSwipeCloseSnapPointRef.current = void 0;
+                });
+                return;
+            }
+            pendingSwipeCloseSnapPointRef.current = void 0;
+            setSwipeDismissed(true);
+        }
+    });
+    const swipePointerProps = swipe.getPointerProps();
+    const swipeTouchProps = swipe.getTouchProps();
+    const resetSwipe = swipe.reset;
+    resetSwipeRef.current = resetSwipe;
+    __rspack_external_react.useEffect(()=>{
+        const rootElement = viewportElement ?? popupElementState;
+        if (!rootElement) return;
+        const resolvedRootElement = rootElement;
+        const doc = ownerDocument(resolvedRootElement);
+        const win = getWindow(doc);
+        function handleNativeTouchMove(event) {
+            if (ignoreTouchSwipeRef.current) return;
+            const touchState = touchScrollStateRef.current;
+            const touch = event.touches[0];
+            if (!touch || !touchState) return;
+            const drawerAxisDelta = isVerticalScrollAxis ? touch.clientY - touchState.lastY : touch.clientX - touchState.lastX;
+            if (isEventOnRangeInput(event, win)) {
+                touchState.allowSwipe = false;
+                updateTouchScrollPosition(touchState, touch);
+                return;
+            }
+            if (2 === event.touches.length) return void updateTouchScrollPosition(touchState, touch);
+            const allowTouchMove = shouldIgnoreSwipeForTextSelection(doc, resolvedRootElement);
+            if (allowTouchMove || !open || !mounted || nestedDrawerOpen) return void updateTouchScrollPosition(touchState, touch);
+            if (preserveNativeCrossAxisScrollOnMove(touchState, touch, isVerticalScrollAxis)) return void updateTouchScrollPosition(touchState, touch);
+            const scrollTarget = touchState.scrollTarget;
+            if (!scrollTarget || scrollTarget === doc.documentElement || scrollTarget === doc.body) {
+                if (event.cancelable) event.preventDefault();
+                updateTouchScrollPosition(touchState, touch);
+                return;
+            }
+            const hasScrollableContent = hasScrollableContentOnAxis(scrollTarget, scrollAxis);
+            if (!hasScrollableContent) {
+                if (event.cancelable) event.preventDefault();
+                updateTouchScrollPosition(touchState, touch);
+                return;
+            }
+            const delta = drawerAxisDelta;
+            if (0 !== delta) {
+                const canSwipeFromScrollEdge = canSwipeFromScrollEdgeOnMove(scrollTarget, scrollAxis, swipeDirection, delta);
+                if (touchState.allowSwipe) {
+                    if (event.cancelable) event.preventDefault();
+                } else if (event.cancelable) if (canSwipeFromScrollEdge) {
+                    touchState.allowSwipe = true;
+                    event.preventDefault();
+                } else touchState.allowSwipe = false;
+                else touchState.allowSwipe = false;
+            }
+            updateTouchScrollPosition(touchState, touch);
+        }
+        return addEventListener(doc, 'touchmove', handleNativeTouchMove, {
+            passive: false,
+            capture: true
+        });
+    }, [
+        mounted,
+        nestedDrawerOpen,
+        open,
+        popupElementState,
+        isVerticalScrollAxis,
+        scrollAxis,
+        swipeDirection,
+        viewportElement
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!snapPointRange || swipe.swiping) return;
+        const resolvedProgress = !open || nested ? 0 : snapPointProgress ?? 0;
+        applySwipeProgress({
+            resolvedProgress,
+            shouldTrackProgress: true,
+            notifyParent: false
+        });
+    }, [
+        applySwipeProgress,
+        frontmostHeight,
+        nested,
+        notifyParentSwipeProgressChange,
+        open,
+        snapPointProgress,
+        snapPointRange,
+        swipe.swiping,
+        store,
+        visualStateStore
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!notifyParentSwipeProgressChange) return;
+        if (!open) notifyParentSwipeProgressChange(0);
+        return ()=>{
+            notifyParentSwipeProgressChange(0);
+        };
+    }, [
+        notifyParentSwipeProgressChange,
+        open
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (open) {
+            resetSwipe();
+            clearSwipeRelease();
+        }
+    }, [
+        clearSwipeRelease,
+        open,
+        resetSwipe
+    ]);
+    __rspack_external_react.useEffect(()=>()=>{
+            visualStateStore?.set({
+                swipeProgress: 0,
+                frontmostHeight: 0
+            });
+            setBackdropSwipingAttribute(store.context.backdropRef.current, false);
+            finishNestedSwipe();
+        }, [
+        finishNestedSwipe,
+        store,
+        visualStateStore
+    ]);
+    const swipeProviderValue = __rspack_external_react.useMemo(()=>({
+            swiping: swipe.swiping,
+            getDragStyles: swipe.getDragStyles,
+            swipeStrength: swipeRelease ?? null,
+            setSwipeDismissed
+        }), [
+        setSwipeDismissed,
+        swipe.getDragStyles,
+        swipe.swiping,
+        swipeRelease
+    ]);
+    function resetTouchTrackingState() {
+        ignoreTouchSwipeRef.current = false;
+        touchScrollStateRef.current = null;
+        lastPointerTypeRef.current = '';
+        ignoreNextTouchStartFromPenRef.current = false;
+    }
+    return /*#__PURE__*/ jsx(DialogViewport_DialogViewport, {
+        ref: forwardedRef,
+        className: className,
+        style: style,
+        render: render,
+        ...mergeProps(elementProps, {
+            onPointerDown (event) {
+                lastPointerTypeRef.current = event.pointerType;
+                ignoreNextTouchStartFromPenRef.current = 'pen' === event.pointerType;
+                if (!open || !mounted || nestedDrawerOpen) return;
+                const doc = ownerDocument(event.currentTarget);
+                const elementAtPoint = getElementAtPoint(doc, event.clientX, event.clientY);
+                if (isSwipeIgnoredTarget(elementAtPoint) || isDrawerContentTarget(elementAtPoint)) return;
+                if ('touch' === event.pointerType) return;
+                swipePointerProps.onPointerDown?.(event);
+            },
+            onPointerMove (event) {
+                if ('touch' === event.pointerType) return;
+                swipePointerProps.onPointerMove?.(event);
+            },
+            onPointerUp (event) {
+                if (lastPointerTypeRef.current === event.pointerType) lastPointerTypeRef.current = '';
+                if ('touch' === event.pointerType) return;
+                swipePointerProps.onPointerUp?.(event);
+            },
+            onPointerCancel (event) {
+                if (lastPointerTypeRef.current === event.pointerType) lastPointerTypeRef.current = '';
+                if ('touch' === event.pointerType) return;
+                swipePointerProps.onPointerCancel?.(event);
+            },
+            onTouchStart (event) {
+                const startedFromPenPointerDown = 'pen' === lastPointerTypeRef.current && ignoreNextTouchStartFromPenRef.current;
+                if (startedFromPenPointerDown) {
+                    ignoreNextTouchStartFromPenRef.current = false;
+                    ignoreTouchSwipeRef.current = false;
+                    touchScrollStateRef.current = null;
+                    return;
+                }
+                if (!open || !mounted || nestedDrawerOpen) {
+                    ignoreTouchSwipeRef.current = false;
+                    touchScrollStateRef.current = null;
+                    return;
+                }
+                const touch = event.touches[0];
+                if (!touch) return;
+                if (isReactTouchEventOnRangeInput(event)) {
+                    ignoreTouchSwipeRef.current = false;
+                    touchScrollStateRef.current = null;
+                    return;
+                }
+                const doc = ownerDocument(event.currentTarget);
+                const elementAtPoint = getElementAtPoint(doc, touch.clientX, touch.clientY);
+                ignoreTouchSwipeRef.current = isSwipeIgnoredTarget(elementAtPoint);
+                if (ignoreTouchSwipeRef.current) {
+                    touchScrollStateRef.current = null;
+                    return;
+                }
+                const rootElement = viewportElement ?? popupElementState;
+                const eventTarget = getTarget(event.nativeEvent);
+                const target = isElement(eventTarget) ? eventTarget : null;
+                if (rootElement && target && !contains(rootElement, target)) {
+                    ignoreTouchSwipeRef.current = true;
+                    touchScrollStateRef.current = null;
+                    return;
+                }
+                let scrollTarget = null;
+                let hasCrossAxisScrollableContent = false;
+                if (rootElement && target) {
+                    scrollTarget = findScrollableTouchTarget(target, rootElement, scrollAxis);
+                    hasCrossAxisScrollableContent = null != findScrollableTouchTarget(target, rootElement, crossScrollAxis);
+                }
+                let allowSwipe = null;
+                if (scrollTarget) {
+                    const canSwipeFromEdge = isAtSwipeStartEdge(scrollTarget, scrollAxis, swipeDirection);
+                    allowSwipe = canSwipeFromEdge ? null : false;
+                }
+                touchScrollStateRef.current = {
+                    startX: touch.clientX,
+                    startY: touch.clientY,
+                    lastX: touch.clientX,
+                    lastY: touch.clientY,
+                    scrollTarget,
+                    hasCrossAxisScrollableContent,
+                    allowSwipe,
+                    preserveNativeCrossAxisScroll: false
+                };
+                swipeTouchProps.onTouchStart?.(event);
+            },
+            onTouchMove (event) {
+                if (ignoreTouchSwipeRef.current) return;
+                if (isReactTouchEventOnRangeInput(event)) return;
+                const touchState = touchScrollStateRef.current;
+                if (touchState?.preserveNativeCrossAxisScroll) return;
+                if (touchState?.allowSwipe === false || touchState?.scrollTarget != null && !touchState.allowSwipe) return;
+                swipeTouchProps.onTouchMove?.(event);
+            },
+            onTouchEnd (event) {
+                resetTouchTrackingState();
+                swipeTouchProps.onTouchEnd?.(event);
+            },
+            onTouchCancel (event) {
+                resetTouchTrackingState();
+                swipeTouchProps.onTouchCancel?.(event);
+            },
+            ['data-nested-dialog-open']: void 0
+        }),
+        children: /*#__PURE__*/ jsx(DrawerViewportContext.Provider, {
+            value: swipeProviderValue,
+            children: children
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) DrawerViewport_DrawerViewport.displayName = "DrawerViewport";
+function setSwipeDismissedElements(popupElement, backdropElement, dismissed) {
+    if (dismissed) {
+        popupElement?.setAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swipeDismiss, '');
+        backdropElement?.setAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swipeDismiss, '');
+        return;
+    }
+    popupElement?.removeAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swipeDismiss);
+    backdropElement?.removeAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swipeDismiss);
+}
+function setBackdropSwipingAttribute(backdropElement, swiping) {
+    if (!backdropElement) return;
+    if (swiping) return void backdropElement.setAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping, '');
+    backdropElement.removeAttribute(DrawerPopupDataAttributes_DrawerPopupDataAttributes.swiping);
+}
+function isSwipeIgnoredTarget(target) {
+    return Boolean(target?.closest(BASE_UI_SWIPE_IGNORE_SELECTOR));
+}
+function isDrawerContentTarget(target) {
+    return Boolean(target?.closest(DRAWER_CONTENT_SELECTOR));
+}
+function getBaseSwipeThreshold(element, direction) {
+    const size = 'left' === direction || 'right' === direction ? element.offsetWidth : element.offsetHeight;
+    return Math.max(0.5 * size, MIN_SWIPE_THRESHOLD);
+}
+function isRangeInput(target, win) {
+    return target instanceof win.HTMLInputElement && 'range' === target.type;
+}
+function isTextSelectionControl(target) {
+    if (!isElement(target)) return false;
+    return 'INPUT' === target.tagName || 'TEXTAREA' === target.tagName;
+}
+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 activeEl = activeElement(doc);
+    const activeElementWithinRoot = Boolean(activeEl && contains(rootElement, activeEl));
+    if (activeElementWithinRoot && isTextSelectionControl(activeEl)) {
+        const { selectionStart, selectionEnd } = activeEl;
+        if (null != selectionStart && null != selectionEnd && selectionStart < selectionEnd) return true;
+    }
+    const selection = doc.getSelection?.();
+    if (!selection || selection.isCollapsed) return false;
+    return hasExpandedSelectionWithinTarget(selection, rootElement);
+}
+function isEventOnRangeInput(event, win) {
+    const composedPath = event.composedPath();
+    if (composedPath) return composedPath.some((pathTarget)=>isRangeInput(pathTarget, win));
+    return isRangeInput(getTarget(event), win);
+}
+function isReactTouchEventOnRangeInput(event) {
+    return isEventOnRangeInput(event.nativeEvent, getWindow(event.currentTarget));
+}
+function updateTouchScrollPosition(touchState, touch) {
+    touchState.lastX = touch.clientX;
+    touchState.lastY = touch.clientY;
+}
+function preserveNativeCrossAxisScrollOnMove(touchState, touch, isVerticalScrollAxis) {
+    if (touchState.preserveNativeCrossAxisScroll) return true;
+    if (true === touchState.allowSwipe || !touchState.hasCrossAxisScrollableContent) return false;
+    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 < 6 || absCrossAxisGestureDelta <= absDrawerAxisGestureDelta + 2) return false;
+    touchState.preserveNativeCrossAxisScroll = true;
+    return true;
+}
+function hasScrollableContentOnAxis(scrollTarget, axis) {
+    return 'vertical' === axis ? scrollTarget.scrollHeight > scrollTarget.clientHeight : scrollTarget.scrollWidth > scrollTarget.clientWidth;
+}
+function getScrollMetrics(scrollTarget, axis) {
+    if ('vertical' === axis) {
+        const max = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+        return {
+            offset: scrollTarget.scrollTop,
+            max
+        };
+    }
+    const max = Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth);
+    return {
+        offset: scrollTarget.scrollLeft,
+        max
+    };
+}
+function isAtSwipeStartEdge(scrollTarget, axis, direction) {
+    const { offset, max } = getScrollMetrics(scrollTarget, axis);
+    const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+    if (null === dismissFromStartEdge) return false;
+    return dismissFromStartEdge ? offset <= 0 : offset >= max;
+}
+function canSwipeFromScrollEdgeOnMove(scrollTarget, axis, direction, delta) {
+    const { offset, max } = getScrollMetrics(scrollTarget, axis);
+    const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+    if (null === dismissFromStartEdge) return false;
+    const movingTowardDismiss = dismissFromStartEdge ? delta > 0 : delta < 0;
+    if (!movingTowardDismiss) return false;
+    return dismissFromStartEdge ? offset <= 0 : offset >= max;
+}
+function shouldDismissFromStartEdge(direction, axis) {
+    if ('vertical' === axis) {
+        if ('down' === direction) return true;
+        if ('up' === direction) return false;
+        return null;
+    }
+    if ('right' === direction) return true;
+    if ('left' === direction) return false;
+    return null;
+}
+const DrawerTrigger = DialogTrigger_DialogTrigger;
+const DrawerClose = DialogClose_DialogClose;
+const DrawerTitle = DialogTitle_DialogTitle;
+const DrawerDescription = DialogDescription_DialogDescription;
+var _DrawerProviderReport, _DrawerProviderReport2;
+function DrawerRoot(props) {
+    const { children, open: openProp, defaultOpen = false, onOpenChange, onOpenChangeComplete, disablePointerDismissal = false, modal = true, actionsRef, handle, triggerId: triggerIdProp, defaultTriggerId: defaultTriggerIdProp = null, swipeDirection = 'down', snapToSequentialPoints = false, snapPoints, snapPoint: snapPointProp, defaultSnapPoint, onSnapPointChange } = props;
+    const parentDrawerRootContext = useDrawerRootContext(true);
+    const notifyParentSwipeProgressChange = parentDrawerRootContext?.onNestedSwipeProgressChange;
+    const notifyParentFrontmostHeight = parentDrawerRootContext?.onNestedFrontmostHeightChange;
+    const notifyParentSwipingChange = parentDrawerRootContext?.onNestedSwipingChange;
+    const notifyParentHasNestedDrawer = parentDrawerRootContext?.onNestedDrawerPresenceChange;
+    const [popupHeight, setPopupHeight] = __rspack_external_react.useState(0);
+    const [frontmostHeight, setFrontmostHeight] = __rspack_external_react.useState(0);
+    const [hasNestedDrawer, setHasNestedDrawer] = __rspack_external_react.useState(false);
+    const [nestedSwiping, setNestedSwiping] = __rspack_external_react.useState(false);
+    const [nestedSwipeProgressStore] = __rspack_external_react.useState(createNestedSwipeProgressStore);
+    const resolvedDefaultSnapPoint = void 0 !== defaultSnapPoint ? defaultSnapPoint : snapPoints?.[0] ?? null;
+    const isSnapPointControlled = void 0 !== snapPointProp;
+    const [activeSnapPoint, setActiveSnapPointUnwrapped] = useControlled({
+        controlled: snapPointProp,
+        default: resolvedDefaultSnapPoint,
+        name: 'Drawer',
+        state: 'snapPoint'
+    });
+    const isNestedDrawerOpenRef = __rspack_external_react.useRef(false);
+    const setActiveSnapPoint = useStableCallback((nextSnapPoint, eventDetails)=>{
+        const resolvedEventDetails = eventDetails ?? createChangeEventDetails("none");
+        onSnapPointChange?.(nextSnapPoint, resolvedEventDetails);
+        if (resolvedEventDetails.isCanceled) return;
+        setActiveSnapPointUnwrapped(nextSnapPoint);
+    });
+    const resolvedActiveSnapPoint = __rspack_external_react.useMemo(()=>{
+        if (isSnapPointControlled) return activeSnapPoint;
+        if (!snapPoints || 0 === snapPoints.length) return activeSnapPoint;
+        if (null === activeSnapPoint || !snapPoints.some((snapPoint)=>Object.is(snapPoint, activeSnapPoint))) return resolvedDefaultSnapPoint;
+        return activeSnapPoint;
+    }, [
+        activeSnapPoint,
+        isSnapPointControlled,
+        resolvedDefaultSnapPoint,
+        snapPoints
+    ]);
+    const onPopupHeightChange = useStableCallback((height)=>{
+        setPopupHeight(height);
+        if (!isNestedDrawerOpenRef.current && height > 0) setFrontmostHeight(height);
+    });
+    const onNestedFrontmostHeightChange = useStableCallback((height)=>{
+        if (height > 0) {
+            isNestedDrawerOpenRef.current = true;
+            setFrontmostHeight(height);
+            return;
+        }
+        isNestedDrawerOpenRef.current = false;
+        if (popupHeight > 0) setFrontmostHeight(popupHeight);
+    });
+    const onNestedDrawerPresenceChange = useStableCallback((present)=>{
+        setHasNestedDrawer(present);
+    });
+    const onNestedSwipeProgressChange = useStableCallback((progress)=>{
+        nestedSwipeProgressStore.set(progress);
+        notifyParentSwipeProgressChange?.(progress);
+    });
+    const onNestedSwipingChange = useStableCallback((swiping)=>{
+        setNestedSwiping(swiping);
+        notifyParentSwipingChange?.(swiping);
+    });
+    const handleOpenChange = useStableCallback((nextOpen, eventDetails)=>{
+        onOpenChange?.(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        if (!nextOpen && snapPoints && snapPoints.length > 0) setActiveSnapPoint(resolvedDefaultSnapPoint, createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            swipeDirection,
+            snapToSequentialPoints,
+            snapPoints,
+            activeSnapPoint: resolvedActiveSnapPoint,
+            setActiveSnapPoint,
+            frontmostHeight,
+            popupHeight,
+            hasNestedDrawer,
+            nestedSwiping,
+            nestedSwipeProgressStore,
+            onNestedDrawerPresenceChange,
+            onPopupHeightChange,
+            onNestedFrontmostHeightChange,
+            onNestedSwipingChange,
+            onNestedSwipeProgressChange,
+            notifyParentFrontmostHeight,
+            notifyParentSwipingChange,
+            notifyParentSwipeProgressChange,
+            notifyParentHasNestedDrawer
+        }), [
+        resolvedActiveSnapPoint,
+        frontmostHeight,
+        hasNestedDrawer,
+        nestedSwiping,
+        nestedSwipeProgressStore,
+        notifyParentHasNestedDrawer,
+        notifyParentSwipeProgressChange,
+        notifyParentSwipingChange,
+        notifyParentFrontmostHeight,
+        onNestedDrawerPresenceChange,
+        onNestedFrontmostHeightChange,
+        onNestedSwipeProgressChange,
+        onNestedSwipingChange,
+        onPopupHeightChange,
+        popupHeight,
+        setActiveSnapPoint,
+        snapPoints,
+        snapToSequentialPoints,
+        swipeDirection
+    ]);
+    const resolvedChildren = 'function' == typeof children ? (payload)=>/*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+            children: [
+                _DrawerProviderReport || (_DrawerProviderReport = /*#__PURE__*/ jsx(DrawerProviderReporter, {})),
+                children(payload)
+            ]
+        }) : /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+        children: [
+            _DrawerProviderReport2 || (_DrawerProviderReport2 = /*#__PURE__*/ jsx(DrawerProviderReporter, {})),
+            children
+        ]
+    });
+    return /*#__PURE__*/ jsx(DrawerRootContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(IsDrawerContext.Provider, {
+            value: true,
+            children: /*#__PURE__*/ jsx(DialogRoot, {
+                open: openProp,
+                defaultOpen: defaultOpen,
+                onOpenChange: handleOpenChange,
+                onOpenChangeComplete: onOpenChangeComplete,
+                disablePointerDismissal: disablePointerDismissal,
+                modal: modal,
+                actionsRef: actionsRef,
+                handle: handle,
+                triggerId: triggerIdProp,
+                defaultTriggerId: defaultTriggerIdProp,
+                children: resolvedChildren
+            })
+        })
+    });
+}
+function createNestedSwipeProgressStore() {
+    let progress = 0;
+    const listeners = 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);
+            };
+        }
+    };
+}
+function DrawerProviderReporter() {
+    const drawerId = useId();
+    const providerContext = useDrawerProviderContext(true);
+    const { store } = useDialogRootContext(false);
+    const open = store.useState('open');
+    const nestedOpenDialogCount = store.useState('nestedOpenDialogCount');
+    const popupElement = store.useState('popupElement');
+    const isTopmost = 0 === nestedOpenDialogCount;
+    __rspack_external_react.useEffect(()=>{
+        if (!providerContext || null == drawerId) return;
+        return ()=>{
+            providerContext.removeDrawer(drawerId);
+        };
+    }, [
+        drawerId,
+        providerContext
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (null == drawerId) return;
+        providerContext?.setDrawerOpen(drawerId, open);
+    }, [
+        drawerId,
+        open,
+        providerContext
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!open || !isTopmost || !isAndroid) return;
+        const win = getWindow(popupElement);
+        const CloseWatcherCtor = win.CloseWatcher;
+        if (!CloseWatcherCtor) return;
+        function handleCloseWatcher(event) {
+            if (!store.select('open')) return;
+            store.setOpen(false, createChangeEventDetails(reason_parts_closeWatcher, event));
+        }
+        const closeWatcher = new CloseWatcherCtor();
+        const unsubscribe = addEventListener(closeWatcher, 'close', handleCloseWatcher);
+        return ()=>{
+            unsubscribe();
+            closeWatcher.destroy();
+        };
+    }, [
+        store,
+        isTopmost,
+        open,
+        popupElement
+    ]);
+    return null;
+}
+const DrawerPortal = DialogPortal_DialogPortal;
+function DrawerProvider(props) {
+    const { children } = props;
+    const [openById, setOpenById] = __rspack_external_react.useState(()=>new Map());
+    const [visualStateStore] = __rspack_external_react.useState(createVisualStateStore);
+    const setDrawerOpen = useStableCallback((drawerId, open)=>{
+        setOpenById((prev)=>{
+            const prevOpen = prev.get(drawerId);
+            if (prevOpen === open) return prev;
+            const next = new Map(prev);
+            next.set(drawerId, open);
+            return next;
+        });
+    });
+    const removeDrawer = useStableCallback((drawerId)=>{
+        setOpenById((prev)=>{
+            if (!prev.has(drawerId)) return prev;
+            const next = new Map(prev);
+            next.delete(drawerId);
+            return next;
+        });
+    });
+    const active = __rspack_external_react.useMemo(()=>{
+        for (const open of openById.values())if (open) return true;
+        return false;
+    }, [
+        openById
+    ]);
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            setDrawerOpen,
+            removeDrawer,
+            active,
+            visualStateStore
+        }), [
+        active,
+        removeDrawer,
+        setDrawerOpen,
+        visualStateStore
+    ]);
+    return /*#__PURE__*/ jsx(DrawerProviderContext.Provider, {
+        value: contextValue,
+        children: children
+    });
+}
+function createVisualStateStore() {
+    let state = {
+        swipeProgress: 0,
+        frontmostHeight: 0
+    };
+    const listeners = new Set();
+    return {
+        getSnapshot: ()=>state,
+        set (nextState) {
+            let nextSwipeProgress = state.swipeProgress;
+            if (void 0 !== nextState.swipeProgress) nextSwipeProgress = Number.isFinite(nextState.swipeProgress) ? nextState.swipeProgress : 0;
+            let nextFrontmostHeight = state.frontmostHeight;
+            if (void 0 !== nextState.frontmostHeight) 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);
+            };
+        }
+    };
+}
 const Drawer_module = {
     description: "description-hsuUfX",
     title: "title-A0LbRg",
     popup: "popup-FjIEpg"
 };
-const Backdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.Backdrop, {
+const Backdrop = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerBackdrop_DrawerBackdrop, {
         ref: ref,
         className: clsx(Drawer_module.backdrop, className),
         ...props
     }));
-const Content = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.Content, {
+const Content = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerContent_DrawerContent, {
         ref: ref,
         className: clsx(Drawer_module.content, className),
         ...props
     }));
-const Indent = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.Indent, {
+const Indent = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerIndent_DrawerIndent, {
         ref: ref,
         className: clsx(Drawer_module.indent, className),
         ...props
     }));
-const IndentBackground = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.IndentBackground, {
+const IndentBackground = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerIndentBackground_DrawerIndentBackground, {
         ref: ref,
         className: clsx(Drawer_module.indentBackground, className),
         ...props
     }));
-const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.Popup, {
+const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerPopup_DrawerPopup, {
         ref: ref,
         className: clsx(Drawer_module.popup, className),
         ...props
     }));
-const SwipeArea = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.SwipeArea, {
+const SwipeArea = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerSwipeArea_DrawerSwipeArea, {
         ref: ref,
         className: clsx(Drawer_module.swipeArea, className),
         ...props
     }));
-const Viewport = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Drawer.Viewport, {
+const Viewport = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(DrawerViewport_DrawerViewport, {
         ref: ref,
         className: clsx(Drawer_module.viewport, className),
         ...props
     }));
 function Trigger({ className, ...props }) {
-    return /*#__PURE__*/ jsx(Drawer.Trigger, {
+    return /*#__PURE__*/ jsx(DrawerTrigger, {
         ...props,
         className: clsx(Drawer_module.trigger, className)
     });
 }
 function Close({ className, ...props }) {
-    return /*#__PURE__*/ jsx(Drawer.Close, {
+    return /*#__PURE__*/ jsx(DrawerClose, {
         ...props,
         className: clsx(Drawer_module.close, className)
     });
 }
 function Title({ className, ...props }) {
-    return /*#__PURE__*/ jsx(Drawer.Title, {
+    return /*#__PURE__*/ jsx(DrawerTitle, {
         ...props,
         className: clsx(Drawer_module.title, className)
     });
 }
 function Description({ className, ...props }) {
-    return /*#__PURE__*/ jsx(Drawer.Description, {
+    return /*#__PURE__*/ jsx(DrawerDescription, {
         ...props,
         className: clsx(Drawer_module.description, className)
     });
 }
-const Drawer_Drawer = {
+const Drawer = {
     Backdrop: Backdrop,
     Content: Content,
     Indent: Indent,
@@ -74,14 +2851,14 @@ const Drawer_Drawer = {
     Popup: Popup,
     SwipeArea: SwipeArea,
     Viewport: Viewport,
-    Root: Drawer.Root,
+    Root: DrawerRoot,
     Trigger: Trigger,
     Close: Close,
     Title: Title,
     Description: Description,
-    Portal: Drawer.Portal,
-    Provider: Drawer.Provider,
-    Handle: Drawer.Handle,
-    createHandle: Drawer.createHandle
+    Portal: DrawerPortal,
+    Provider: DrawerProvider,
+    Handle: DialogHandle,
+    createHandle: createDialogHandle
 };
-export { Drawer_Drawer as Drawer };
+export { Drawer };