@nexub/react 1.1.0 → 1.3.0

package/dist/chunk-6MYVXJPJ.js

@@ -0,0 +1,1639 @@
+'use client';
+import {
+  glassSurfaceClass
+} from "./chunk-ROZVVWPV.js";
+import {
+  cn
+} from "./chunk-AT6RPKU3.js";
+
+// src/components/Drawer/Drawer.tsx
+import * as React2 from "react";
+import { Slot } from "@radix-ui/react-slot";
+
+// ../../node_modules/.pnpm/vaul@1.1.2_@types+react-dom@19.2.3_@types+react@19.2.14__@types+react@19.2.14_react-dom_d9bfd38a4ee4f41de100e4d447baf4a5/node_modules/vaul/dist/index.mjs
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import * as React from "react";
+import React__default, { useLayoutEffect, useEffect, useMemo } from "react";
+var DrawerContext = React__default.createContext({
+  drawerRef: {
+    current: null
+  },
+  overlayRef: {
+    current: null
+  },
+  onPress: () => {
+  },
+  onRelease: () => {
+  },
+  onDrag: () => {
+  },
+  onNestedDrag: () => {
+  },
+  onNestedOpenChange: () => {
+  },
+  onNestedRelease: () => {
+  },
+  openProp: void 0,
+  dismissible: false,
+  isOpen: false,
+  isDragging: false,
+  keyboardIsOpen: {
+    current: false
+  },
+  snapPointsOffset: null,
+  snapPoints: null,
+  handleOnly: false,
+  modal: false,
+  shouldFade: false,
+  activeSnapPoint: null,
+  onOpenChange: () => {
+  },
+  setActiveSnapPoint: () => {
+  },
+  closeDrawer: () => {
+  },
+  direction: "bottom",
+  shouldAnimate: {
+    current: true
+  },
+  shouldScaleBackground: false,
+  setBackgroundColorOnScale: true,
+  noBodyStyles: false,
+  container: null,
+  autoFocus: false
+});
+var useDrawerContext = () => {
+  const context = React__default.useContext(DrawerContext);
+  if (!context) {
+    throw new Error("useDrawerContext must be used within a Drawer.Root");
+  }
+  return context;
+};
+function isMobileFirefox() {
+  const userAgent = navigator.userAgent;
+  return typeof window !== "undefined" && (/Firefox/.test(userAgent) && /Mobile/.test(userAgent) || // Android Firefox
+  /FxiOS/.test(userAgent));
+}
+function isMac() {
+  return testPlatform(/^Mac/);
+}
+function isIPhone() {
+  return testPlatform(/^iPhone/);
+}
+function isSafari() {
+  return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+function isIPad() {
+  return testPlatform(/^iPad/) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  isMac() && navigator.maxTouchPoints > 1;
+}
+function isIOS() {
+  return isIPhone() || isIPad();
+}
+function testPlatform(re) {
+  return typeof window !== "undefined" && window.navigator != null ? re.test(window.navigator.platform) : void 0;
+}
+var KEYBOARD_BUFFER = 24;
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function chain$1(...callbacks) {
+  return (...args) => {
+    for (let callback of callbacks) {
+      if (typeof callback === "function") {
+        callback(...args);
+      }
+    }
+  };
+}
+var visualViewport = typeof document !== "undefined" && window.visualViewport;
+function isScrollable(node) {
+  let style = window.getComputedStyle(node);
+  return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+}
+function getScrollParent(node) {
+  if (isScrollable(node)) {
+    node = node.parentElement;
+  }
+  while (node && !isScrollable(node)) {
+    node = node.parentElement;
+  }
+  return node || document.scrollingElement || document.documentElement;
+}
+var nonTextInputTypes = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+var preventScrollCount = 0;
+var restore;
+function usePreventScroll(options = {}) {
+  let { isDisabled } = options;
+  useIsomorphicLayoutEffect(() => {
+    if (isDisabled) {
+      return;
+    }
+    preventScrollCount++;
+    if (preventScrollCount === 1) {
+      if (isIOS()) {
+        restore = preventScrollMobileSafari();
+      }
+    }
+    return () => {
+      preventScrollCount--;
+      if (preventScrollCount === 0) {
+        restore == null ? void 0 : restore();
+      }
+    };
+  }, [
+    isDisabled
+  ]);
+}
+function preventScrollMobileSafari() {
+  let scrollable;
+  let lastY = 0;
+  let onTouchStart = (e) => {
+    scrollable = getScrollParent(e.target);
+    if (scrollable === document.documentElement && scrollable === document.body) {
+      return;
+    }
+    lastY = e.changedTouches[0].pageY;
+  };
+  let onTouchMove = (e) => {
+    if (!scrollable || scrollable === document.documentElement || scrollable === document.body) {
+      e.preventDefault();
+      return;
+    }
+    let y = e.changedTouches[0].pageY;
+    let scrollTop = scrollable.scrollTop;
+    let bottom = scrollable.scrollHeight - scrollable.clientHeight;
+    if (bottom === 0) {
+      return;
+    }
+    if (scrollTop <= 0 && y > lastY || scrollTop >= bottom && y < lastY) {
+      e.preventDefault();
+    }
+    lastY = y;
+  };
+  let onTouchEnd = (e) => {
+    let target = e.target;
+    if (isInput(target) && target !== document.activeElement) {
+      e.preventDefault();
+      target.style.transform = "translateY(-2000px)";
+      target.focus();
+      requestAnimationFrame(() => {
+        target.style.transform = "";
+      });
+    }
+  };
+  let onFocus = (e) => {
+    let target = e.target;
+    if (isInput(target)) {
+      target.style.transform = "translateY(-2000px)";
+      requestAnimationFrame(() => {
+        target.style.transform = "";
+        if (visualViewport) {
+          if (visualViewport.height < window.innerHeight) {
+            requestAnimationFrame(() => {
+              scrollIntoView(target);
+            });
+          } else {
+            visualViewport.addEventListener("resize", () => scrollIntoView(target), {
+              once: true
+            });
+          }
+        }
+      });
+    }
+  };
+  let onWindowScroll = () => {
+    window.scrollTo(0, 0);
+  };
+  let scrollX = window.pageXOffset;
+  let scrollY = window.pageYOffset;
+  let restoreStyles = chain$1(setStyle(document.documentElement, "paddingRight", `${window.innerWidth - document.documentElement.clientWidth}px`));
+  window.scrollTo(0, 0);
+  let removeEvents = chain$1(addEvent(document, "touchstart", onTouchStart, {
+    passive: false,
+    capture: true
+  }), addEvent(document, "touchmove", onTouchMove, {
+    passive: false,
+    capture: true
+  }), addEvent(document, "touchend", onTouchEnd, {
+    passive: false,
+    capture: true
+  }), addEvent(document, "focus", onFocus, true), addEvent(window, "scroll", onWindowScroll));
+  return () => {
+    restoreStyles();
+    removeEvents();
+    window.scrollTo(scrollX, scrollY);
+  };
+}
+function setStyle(element, style, value) {
+  let cur = element.style[style];
+  element.style[style] = value;
+  return () => {
+    element.style[style] = cur;
+  };
+}
+function addEvent(target, event, handler, options) {
+  target.addEventListener(event, handler, options);
+  return () => {
+    target.removeEventListener(event, handler, options);
+  };
+}
+function scrollIntoView(target) {
+  let root = document.scrollingElement || document.documentElement;
+  while (target && target !== root) {
+    let scrollable = getScrollParent(target);
+    if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== target) {
+      let scrollableTop = scrollable.getBoundingClientRect().top;
+      let targetTop = target.getBoundingClientRect().top;
+      let targetBottom = target.getBoundingClientRect().bottom;
+      const keyboardHeight = scrollable.getBoundingClientRect().bottom + KEYBOARD_BUFFER;
+      if (targetBottom > keyboardHeight) {
+        scrollable.scrollTop += targetTop - scrollableTop;
+      }
+    }
+    target = scrollable.parentElement;
+  }
+}
+function isInput(target) {
+  return target instanceof HTMLInputElement && !nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+}
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => refs.forEach((ref) => setRef(ref, node));
+}
+function useComposedRefs(...refs) {
+  return React.useCallback(composeRefs(...refs), refs);
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function set(el, styles, ignoreCache = false) {
+  if (!el || !(el instanceof HTMLElement)) return;
+  let originalStyles = {};
+  Object.entries(styles).forEach(([key, value]) => {
+    if (key.startsWith("--")) {
+      el.style.setProperty(key, value);
+      return;
+    }
+    originalStyles[key] = el.style[key];
+    el.style[key] = value;
+  });
+  if (ignoreCache) return;
+  cache.set(el, originalStyles);
+}
+function reset(el, prop) {
+  if (!el || !(el instanceof HTMLElement)) return;
+  let originalStyles = cache.get(el);
+  if (!originalStyles) {
+    return;
+  }
+  {
+    el.style[prop] = originalStyles[prop];
+  }
+}
+var isVertical = (direction) => {
+  switch (direction) {
+    case "top":
+    case "bottom":
+      return true;
+    case "left":
+    case "right":
+      return false;
+    default:
+      return direction;
+  }
+};
+function getTranslate(element, direction) {
+  if (!element) {
+    return null;
+  }
+  const style = window.getComputedStyle(element);
+  const transform = (
+    // @ts-ignore
+    style.transform || style.webkitTransform || style.mozTransform
+  );
+  let mat = transform.match(/^matrix3d\((.+)\)$/);
+  if (mat) {
+    return parseFloat(mat[1].split(", ")[isVertical(direction) ? 13 : 12]);
+  }
+  mat = transform.match(/^matrix\((.+)\)$/);
+  return mat ? parseFloat(mat[1].split(", ")[isVertical(direction) ? 5 : 4]) : null;
+}
+function dampenValue(v) {
+  return 8 * (Math.log(v + 1) - 2);
+}
+function assignStyle(element, style) {
+  if (!element) return () => {
+  };
+  const prevStyle = element.style.cssText;
+  Object.assign(element.style, style);
+  return () => {
+    element.style.cssText = prevStyle;
+  };
+}
+function chain(...fns) {
+  return (...args) => {
+    for (const fn of fns) {
+      if (typeof fn === "function") {
+        fn(...args);
+      }
+    }
+  };
+}
+var TRANSITIONS = {
+  DURATION: 0.5,
+  EASE: [
+    0.32,
+    0.72,
+    0,
+    1
+  ]
+};
+var VELOCITY_THRESHOLD = 0.4;
+var CLOSE_THRESHOLD = 0.25;
+var SCROLL_LOCK_TIMEOUT = 100;
+var BORDER_RADIUS = 8;
+var NESTED_DISPLACEMENT = 16;
+var WINDOW_TOP_OFFSET = 26;
+var DRAG_CLASS = "vaul-dragging";
+function useCallbackRef(callback) {
+  const callbackRef = React__default.useRef(callback);
+  React__default.useEffect(() => {
+    callbackRef.current = callback;
+  });
+  return React__default.useMemo(() => (...args) => callbackRef.current == null ? void 0 : callbackRef.current.call(callbackRef, ...args), []);
+}
+function useUncontrolledState({ defaultProp, onChange }) {
+  const uncontrolledState = React__default.useState(defaultProp);
+  const [value] = uncontrolledState;
+  const prevValueRef = React__default.useRef(value);
+  const handleChange = useCallbackRef(onChange);
+  React__default.useEffect(() => {
+    if (prevValueRef.current !== value) {
+      handleChange(value);
+      prevValueRef.current = value;
+    }
+  }, [
+    value,
+    prevValueRef,
+    handleChange
+  ]);
+  return uncontrolledState;
+}
+function useControllableState({ prop, defaultProp, onChange = () => {
+} }) {
+  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({
+    defaultProp,
+    onChange
+  });
+  const isControlled = prop !== void 0;
+  const value = isControlled ? prop : uncontrolledProp;
+  const handleChange = useCallbackRef(onChange);
+  const setValue = React__default.useCallback((nextValue) => {
+    if (isControlled) {
+      const setter = nextValue;
+      const value2 = typeof nextValue === "function" ? setter(prop) : nextValue;
+      if (value2 !== prop) handleChange(value2);
+    } else {
+      setUncontrolledProp(nextValue);
+    }
+  }, [
+    isControlled,
+    prop,
+    setUncontrolledProp,
+    handleChange
+  ]);
+  return [
+    value,
+    setValue
+  ];
+}
+function useSnapPoints({ activeSnapPointProp, setActiveSnapPointProp, snapPoints, drawerRef, overlayRef, fadeFromIndex, onSnapPointChange, direction = "bottom", container, snapToSequentialPoint }) {
+  const [activeSnapPoint, setActiveSnapPoint] = useControllableState({
+    prop: activeSnapPointProp,
+    defaultProp: snapPoints == null ? void 0 : snapPoints[0],
+    onChange: setActiveSnapPointProp
+  });
+  const [windowDimensions, setWindowDimensions] = React__default.useState(typeof window !== "undefined" ? {
+    innerWidth: window.innerWidth,
+    innerHeight: window.innerHeight
+  } : void 0);
+  React__default.useEffect(() => {
+    function onResize() {
+      setWindowDimensions({
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight
+      });
+    }
+    window.addEventListener("resize", onResize);
+    return () => window.removeEventListener("resize", onResize);
+  }, []);
+  const isLastSnapPoint = React__default.useMemo(() => activeSnapPoint === (snapPoints == null ? void 0 : snapPoints[snapPoints.length - 1]) || null, [
+    snapPoints,
+    activeSnapPoint
+  ]);
+  const activeSnapPointIndex = React__default.useMemo(() => {
+    var _snapPoints_findIndex;
+    return (_snapPoints_findIndex = snapPoints == null ? void 0 : snapPoints.findIndex((snapPoint) => snapPoint === activeSnapPoint)) != null ? _snapPoints_findIndex : null;
+  }, [
+    snapPoints,
+    activeSnapPoint
+  ]);
+  const shouldFade = snapPoints && snapPoints.length > 0 && (fadeFromIndex || fadeFromIndex === 0) && !Number.isNaN(fadeFromIndex) && snapPoints[fadeFromIndex] === activeSnapPoint || !snapPoints;
+  const snapPointsOffset = React__default.useMemo(() => {
+    const containerSize = container ? {
+      width: container.getBoundingClientRect().width,
+      height: container.getBoundingClientRect().height
+    } : typeof window !== "undefined" ? {
+      width: window.innerWidth,
+      height: window.innerHeight
+    } : {
+      width: 0,
+      height: 0
+    };
+    var _snapPoints_map;
+    return (_snapPoints_map = snapPoints == null ? void 0 : snapPoints.map((snapPoint) => {
+      const isPx = typeof snapPoint === "string";
+      let snapPointAsNumber = 0;
+      if (isPx) {
+        snapPointAsNumber = parseInt(snapPoint, 10);
+      }
+      if (isVertical(direction)) {
+        const height = isPx ? snapPointAsNumber : windowDimensions ? snapPoint * containerSize.height : 0;
+        if (windowDimensions) {
+          return direction === "bottom" ? containerSize.height - height : -containerSize.height + height;
+        }
+        return height;
+      }
+      const width = isPx ? snapPointAsNumber : windowDimensions ? snapPoint * containerSize.width : 0;
+      if (windowDimensions) {
+        return direction === "right" ? containerSize.width - width : -containerSize.width + width;
+      }
+      return width;
+    })) != null ? _snapPoints_map : [];
+  }, [
+    snapPoints,
+    windowDimensions,
+    container
+  ]);
+  const activeSnapPointOffset = React__default.useMemo(() => activeSnapPointIndex !== null ? snapPointsOffset == null ? void 0 : snapPointsOffset[activeSnapPointIndex] : null, [
+    snapPointsOffset,
+    activeSnapPointIndex
+  ]);
+  const snapToPoint = React__default.useCallback((dimension) => {
+    var _snapPointsOffset_findIndex;
+    const newSnapPointIndex = (_snapPointsOffset_findIndex = snapPointsOffset == null ? void 0 : snapPointsOffset.findIndex((snapPointDim) => snapPointDim === dimension)) != null ? _snapPointsOffset_findIndex : null;
+    onSnapPointChange(newSnapPointIndex);
+    set(drawerRef.current, {
+      transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`,
+      transform: isVertical(direction) ? `translate3d(0, ${dimension}px, 0)` : `translate3d(${dimension}px, 0, 0)`
+    });
+    if (snapPointsOffset && newSnapPointIndex !== snapPointsOffset.length - 1 && fadeFromIndex !== void 0 && newSnapPointIndex !== fadeFromIndex && newSnapPointIndex < fadeFromIndex) {
+      set(overlayRef.current, {
+        transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`,
+        opacity: "0"
+      });
+    } else {
+      set(overlayRef.current, {
+        transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`,
+        opacity: "1"
+      });
+    }
+    setActiveSnapPoint(snapPoints == null ? void 0 : snapPoints[Math.max(newSnapPointIndex, 0)]);
+  }, [
+    drawerRef.current,
+    snapPoints,
+    snapPointsOffset,
+    fadeFromIndex,
+    overlayRef,
+    setActiveSnapPoint
+  ]);
+  React__default.useEffect(() => {
+    if (activeSnapPoint || activeSnapPointProp) {
+      var _snapPoints_findIndex;
+      const newIndex = (_snapPoints_findIndex = snapPoints == null ? void 0 : snapPoints.findIndex((snapPoint) => snapPoint === activeSnapPointProp || snapPoint === activeSnapPoint)) != null ? _snapPoints_findIndex : -1;
+      if (snapPointsOffset && newIndex !== -1 && typeof snapPointsOffset[newIndex] === "number") {
+        snapToPoint(snapPointsOffset[newIndex]);
+      }
+    }
+  }, [
+    activeSnapPoint,
+    activeSnapPointProp,
+    snapPoints,
+    snapPointsOffset,
+    snapToPoint
+  ]);
+  function onRelease({ draggedDistance, closeDrawer, velocity, dismissible }) {
+    if (fadeFromIndex === void 0) return;
+    const currentPosition = direction === "bottom" || direction === "right" ? (activeSnapPointOffset != null ? activeSnapPointOffset : 0) - draggedDistance : (activeSnapPointOffset != null ? activeSnapPointOffset : 0) + draggedDistance;
+    const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;
+    const isFirst = activeSnapPointIndex === 0;
+    const hasDraggedUp = draggedDistance > 0;
+    if (isOverlaySnapPoint) {
+      set(overlayRef.current, {
+        transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`
+      });
+    }
+    if (!snapToSequentialPoint && velocity > 2 && !hasDraggedUp) {
+      if (dismissible) closeDrawer();
+      else snapToPoint(snapPointsOffset[0]);
+      return;
+    }
+    if (!snapToSequentialPoint && velocity > 2 && hasDraggedUp && snapPointsOffset && snapPoints) {
+      snapToPoint(snapPointsOffset[snapPoints.length - 1]);
+      return;
+    }
+    const closestSnapPoint = snapPointsOffset == null ? void 0 : snapPointsOffset.reduce((prev, curr) => {
+      if (typeof prev !== "number" || typeof curr !== "number") return prev;
+      return Math.abs(curr - currentPosition) < Math.abs(prev - currentPosition) ? curr : prev;
+    });
+    const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+    if (velocity > VELOCITY_THRESHOLD && Math.abs(draggedDistance) < dim * 0.4) {
+      const dragDirection = hasDraggedUp ? 1 : -1;
+      if (dragDirection > 0 && isLastSnapPoint && snapPoints) {
+        snapToPoint(snapPointsOffset[snapPoints.length - 1]);
+        return;
+      }
+      if (isFirst && dragDirection < 0 && dismissible) {
+        closeDrawer();
+      }
+      if (activeSnapPointIndex === null) return;
+      snapToPoint(snapPointsOffset[activeSnapPointIndex + dragDirection]);
+      return;
+    }
+    snapToPoint(closestSnapPoint);
+  }
+  function onDrag({ draggedDistance }) {
+    if (activeSnapPointOffset === null) return;
+    const newValue = direction === "bottom" || direction === "right" ? activeSnapPointOffset - draggedDistance : activeSnapPointOffset + draggedDistance;
+    if ((direction === "bottom" || direction === "right") && newValue < snapPointsOffset[snapPointsOffset.length - 1]) {
+      return;
+    }
+    if ((direction === "top" || direction === "left") && newValue > snapPointsOffset[snapPointsOffset.length - 1]) {
+      return;
+    }
+    set(drawerRef.current, {
+      transform: isVertical(direction) ? `translate3d(0, ${newValue}px, 0)` : `translate3d(${newValue}px, 0, 0)`
+    });
+  }
+  function getPercentageDragged(absDraggedDistance, isDraggingDown) {
+    if (!snapPoints || typeof activeSnapPointIndex !== "number" || !snapPointsOffset || fadeFromIndex === void 0) return null;
+    const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;
+    const isOverlaySnapPointOrHigher = activeSnapPointIndex >= fadeFromIndex;
+    if (isOverlaySnapPointOrHigher && isDraggingDown) {
+      return 0;
+    }
+    if (isOverlaySnapPoint && !isDraggingDown) return 1;
+    if (!shouldFade && !isOverlaySnapPoint) return null;
+    const targetSnapPointIndex = isOverlaySnapPoint ? activeSnapPointIndex + 1 : activeSnapPointIndex - 1;
+    const snapPointDistance = isOverlaySnapPoint ? snapPointsOffset[targetSnapPointIndex] - snapPointsOffset[targetSnapPointIndex - 1] : snapPointsOffset[targetSnapPointIndex + 1] - snapPointsOffset[targetSnapPointIndex];
+    const percentageDragged = absDraggedDistance / Math.abs(snapPointDistance);
+    if (isOverlaySnapPoint) {
+      return 1 - percentageDragged;
+    } else {
+      return percentageDragged;
+    }
+  }
+  return {
+    isLastSnapPoint,
+    activeSnapPoint,
+    shouldFade,
+    getPercentageDragged,
+    setActiveSnapPoint,
+    activeSnapPointIndex,
+    onRelease,
+    onDrag,
+    snapPointsOffset
+  };
+}
+var noop = () => () => {
+};
+function useScaleBackground() {
+  const { direction, isOpen, shouldScaleBackground, setBackgroundColorOnScale, noBodyStyles } = useDrawerContext();
+  const timeoutIdRef = React__default.useRef(null);
+  const initialBackgroundColor = useMemo(() => document.body.style.backgroundColor, []);
+  function getScale() {
+    return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;
+  }
+  React__default.useEffect(() => {
+    if (isOpen && shouldScaleBackground) {
+      if (timeoutIdRef.current) clearTimeout(timeoutIdRef.current);
+      const wrapper = document.querySelector("[data-vaul-drawer-wrapper]") || document.querySelector("[vaul-drawer-wrapper]");
+      if (!wrapper) return;
+      chain(setBackgroundColorOnScale && !noBodyStyles ? assignStyle(document.body, {
+        background: "black"
+      }) : noop, assignStyle(wrapper, {
+        transformOrigin: isVertical(direction) ? "top" : "left",
+        transitionProperty: "transform, border-radius",
+        transitionDuration: `${TRANSITIONS.DURATION}s`,
+        transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(",")})`
+      }));
+      const wrapperStylesCleanup = assignStyle(wrapper, {
+        borderRadius: `${BORDER_RADIUS}px`,
+        overflow: "hidden",
+        ...isVertical(direction) ? {
+          transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`
+        } : {
+          transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`
+        }
+      });
+      return () => {
+        wrapperStylesCleanup();
+        timeoutIdRef.current = window.setTimeout(() => {
+          if (initialBackgroundColor) {
+            document.body.style.background = initialBackgroundColor;
+          } else {
+            document.body.style.removeProperty("background");
+          }
+        }, TRANSITIONS.DURATION * 1e3);
+      };
+    }
+  }, [
+    isOpen,
+    shouldScaleBackground,
+    initialBackgroundColor
+  ]);
+}
+var previousBodyPosition = null;
+function usePositionFixed({ isOpen, modal, nested, hasBeenOpened, preventScrollRestoration, noBodyStyles }) {
+  const [activeUrl, setActiveUrl] = React__default.useState(() => typeof window !== "undefined" ? window.location.href : "");
+  const scrollPos = React__default.useRef(0);
+  const setPositionFixed = React__default.useCallback(() => {
+    if (!isSafari()) return;
+    if (previousBodyPosition === null && isOpen && !noBodyStyles) {
+      previousBodyPosition = {
+        position: document.body.style.position,
+        top: document.body.style.top,
+        left: document.body.style.left,
+        height: document.body.style.height,
+        right: "unset"
+      };
+      const { scrollX, innerHeight } = window;
+      document.body.style.setProperty("position", "fixed", "important");
+      Object.assign(document.body.style, {
+        top: `${-scrollPos.current}px`,
+        left: `${-scrollX}px`,
+        right: "0px",
+        height: "auto"
+      });
+      window.setTimeout(() => window.requestAnimationFrame(() => {
+        const bottomBarHeight = innerHeight - window.innerHeight;
+        if (bottomBarHeight && scrollPos.current >= innerHeight) {
+          document.body.style.top = `${-(scrollPos.current + bottomBarHeight)}px`;
+        }
+      }), 300);
+    }
+  }, [
+    isOpen
+  ]);
+  const restorePositionSetting = React__default.useCallback(() => {
+    if (!isSafari()) return;
+    if (previousBodyPosition !== null && !noBodyStyles) {
+      const y = -parseInt(document.body.style.top, 10);
+      const x = -parseInt(document.body.style.left, 10);
+      Object.assign(document.body.style, previousBodyPosition);
+      window.requestAnimationFrame(() => {
+        if (preventScrollRestoration && activeUrl !== window.location.href) {
+          setActiveUrl(window.location.href);
+          return;
+        }
+        window.scrollTo(x, y);
+      });
+      previousBodyPosition = null;
+    }
+  }, [
+    activeUrl
+  ]);
+  React__default.useEffect(() => {
+    function onScroll() {
+      scrollPos.current = window.scrollY;
+    }
+    onScroll();
+    window.addEventListener("scroll", onScroll);
+    return () => {
+      window.removeEventListener("scroll", onScroll);
+    };
+  }, []);
+  React__default.useEffect(() => {
+    if (!modal) return;
+    return () => {
+      if (typeof document === "undefined") return;
+      const hasDrawerOpened = !!document.querySelector("[data-vaul-drawer]");
+      if (hasDrawerOpened) return;
+      restorePositionSetting();
+    };
+  }, [
+    modal,
+    restorePositionSetting
+  ]);
+  React__default.useEffect(() => {
+    if (nested || !hasBeenOpened) return;
+    if (isOpen) {
+      const isStandalone = window.matchMedia("(display-mode: standalone)").matches;
+      !isStandalone && setPositionFixed();
+      if (!modal) {
+        window.setTimeout(() => {
+          restorePositionSetting();
+        }, 500);
+      }
+    } else {
+      restorePositionSetting();
+    }
+  }, [
+    isOpen,
+    hasBeenOpened,
+    activeUrl,
+    modal,
+    nested,
+    setPositionFixed,
+    restorePositionSetting
+  ]);
+  return {
+    restorePositionSetting
+  };
+}
+function Root2({ open: openProp, onOpenChange, children, onDrag: onDragProp, onRelease: onReleaseProp, snapPoints, shouldScaleBackground = false, setBackgroundColorOnScale = true, closeThreshold = CLOSE_THRESHOLD, scrollLockTimeout = SCROLL_LOCK_TIMEOUT, dismissible = true, handleOnly = false, fadeFromIndex = snapPoints && snapPoints.length - 1, activeSnapPoint: activeSnapPointProp, setActiveSnapPoint: setActiveSnapPointProp, fixed, modal = true, onClose, nested, noBodyStyles = false, direction = "bottom", defaultOpen = false, disablePreventScroll = true, snapToSequentialPoint = false, preventScrollRestoration = false, repositionInputs = true, onAnimationEnd, container, autoFocus = false }) {
+  var _drawerRef_current, _drawerRef_current1;
+  const [isOpen = false, setIsOpen] = useControllableState({
+    defaultProp: defaultOpen,
+    prop: openProp,
+    onChange: (o) => {
+      onOpenChange == null ? void 0 : onOpenChange(o);
+      if (!o && !nested) {
+        restorePositionSetting();
+      }
+      setTimeout(() => {
+        onAnimationEnd == null ? void 0 : onAnimationEnd(o);
+      }, TRANSITIONS.DURATION * 1e3);
+      if (o && !modal) {
+        if (typeof window !== "undefined") {
+          window.requestAnimationFrame(() => {
+            document.body.style.pointerEvents = "auto";
+          });
+        }
+      }
+      if (!o) {
+        document.body.style.pointerEvents = "auto";
+      }
+    }
+  });
+  const [hasBeenOpened, setHasBeenOpened] = React__default.useState(false);
+  const [isDragging, setIsDragging] = React__default.useState(false);
+  const [justReleased, setJustReleased] = React__default.useState(false);
+  const overlayRef = React__default.useRef(null);
+  const openTime = React__default.useRef(null);
+  const dragStartTime = React__default.useRef(null);
+  const dragEndTime = React__default.useRef(null);
+  const lastTimeDragPrevented = React__default.useRef(null);
+  const isAllowedToDrag = React__default.useRef(false);
+  const nestedOpenChangeTimer = React__default.useRef(null);
+  const pointerStart = React__default.useRef(0);
+  const keyboardIsOpen = React__default.useRef(false);
+  const shouldAnimate = React__default.useRef(!defaultOpen);
+  const previousDiffFromInitial = React__default.useRef(0);
+  const drawerRef = React__default.useRef(null);
+  const drawerHeightRef = React__default.useRef(((_drawerRef_current = drawerRef.current) == null ? void 0 : _drawerRef_current.getBoundingClientRect().height) || 0);
+  const drawerWidthRef = React__default.useRef(((_drawerRef_current1 = drawerRef.current) == null ? void 0 : _drawerRef_current1.getBoundingClientRect().width) || 0);
+  const initialDrawerHeight = React__default.useRef(0);
+  const onSnapPointChange = React__default.useCallback((activeSnapPointIndex2) => {
+    if (snapPoints && activeSnapPointIndex2 === snapPointsOffset.length - 1) openTime.current = /* @__PURE__ */ new Date();
+  }, []);
+  const { activeSnapPoint, activeSnapPointIndex, setActiveSnapPoint, onRelease: onReleaseSnapPoints, snapPointsOffset, onDrag: onDragSnapPoints, shouldFade, getPercentageDragged: getSnapPointsPercentageDragged } = useSnapPoints({
+    snapPoints,
+    activeSnapPointProp,
+    setActiveSnapPointProp,
+    drawerRef,
+    fadeFromIndex,
+    overlayRef,
+    onSnapPointChange,
+    direction,
+    container,
+    snapToSequentialPoint
+  });
+  usePreventScroll({
+    isDisabled: !isOpen || isDragging || !modal || justReleased || !hasBeenOpened || !repositionInputs || !disablePreventScroll
+  });
+  const { restorePositionSetting } = usePositionFixed({
+    isOpen,
+    modal,
+    nested: nested != null ? nested : false,
+    hasBeenOpened,
+    preventScrollRestoration,
+    noBodyStyles
+  });
+  function getScale() {
+    return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;
+  }
+  function onPress(event) {
+    var _drawerRef_current2, _drawerRef_current12;
+    if (!dismissible && !snapPoints) return;
+    if (drawerRef.current && !drawerRef.current.contains(event.target)) return;
+    drawerHeightRef.current = ((_drawerRef_current2 = drawerRef.current) == null ? void 0 : _drawerRef_current2.getBoundingClientRect().height) || 0;
+    drawerWidthRef.current = ((_drawerRef_current12 = drawerRef.current) == null ? void 0 : _drawerRef_current12.getBoundingClientRect().width) || 0;
+    setIsDragging(true);
+    dragStartTime.current = /* @__PURE__ */ new Date();
+    if (isIOS()) {
+      window.addEventListener("touchend", () => isAllowedToDrag.current = false, {
+        once: true
+      });
+    }
+    event.target.setPointerCapture(event.pointerId);
+    pointerStart.current = isVertical(direction) ? event.pageY : event.pageX;
+  }
+  function shouldDrag(el, isDraggingInDirection) {
+    var _window_getSelection;
+    let element = el;
+    const highlightedText = (_window_getSelection = window.getSelection()) == null ? void 0 : _window_getSelection.toString();
+    const swipeAmount = drawerRef.current ? getTranslate(drawerRef.current, direction) : null;
+    const date = /* @__PURE__ */ new Date();
+    if (element.tagName === "SELECT") {
+      return false;
+    }
+    if (element.hasAttribute("data-vaul-no-drag") || element.closest("[data-vaul-no-drag]")) {
+      return false;
+    }
+    if (direction === "right" || direction === "left") {
+      return true;
+    }
+    if (openTime.current && date.getTime() - openTime.current.getTime() < 500) {
+      return false;
+    }
+    if (swipeAmount !== null) {
+      if (direction === "bottom" ? swipeAmount > 0 : swipeAmount < 0) {
+        return true;
+      }
+    }
+    if (highlightedText && highlightedText.length > 0) {
+      return false;
+    }
+    if (lastTimeDragPrevented.current && date.getTime() - lastTimeDragPrevented.current.getTime() < scrollLockTimeout && swipeAmount === 0) {
+      lastTimeDragPrevented.current = date;
+      return false;
+    }
+    if (isDraggingInDirection) {
+      lastTimeDragPrevented.current = date;
+      return false;
+    }
+    while (element) {
+      if (element.scrollHeight > element.clientHeight) {
+        if (element.scrollTop !== 0) {
+          lastTimeDragPrevented.current = /* @__PURE__ */ new Date();
+          return false;
+        }
+        if (element.getAttribute("role") === "dialog") {
+          return true;
+        }
+      }
+      element = element.parentNode;
+    }
+    return true;
+  }
+  function onDrag(event) {
+    if (!drawerRef.current) {
+      return;
+    }
+    if (isDragging) {
+      const directionMultiplier = direction === "bottom" || direction === "right" ? 1 : -1;
+      const draggedDistance = (pointerStart.current - (isVertical(direction) ? event.pageY : event.pageX)) * directionMultiplier;
+      const isDraggingInDirection = draggedDistance > 0;
+      const noCloseSnapPointsPreCondition = snapPoints && !dismissible && !isDraggingInDirection;
+      if (noCloseSnapPointsPreCondition && activeSnapPointIndex === 0) return;
+      const absDraggedDistance = Math.abs(draggedDistance);
+      const wrapper = document.querySelector("[data-vaul-drawer-wrapper]");
+      const drawerDimension = direction === "bottom" || direction === "top" ? drawerHeightRef.current : drawerWidthRef.current;
+      let percentageDragged = absDraggedDistance / drawerDimension;
+      const snapPointPercentageDragged = getSnapPointsPercentageDragged(absDraggedDistance, isDraggingInDirection);
+      if (snapPointPercentageDragged !== null) {
+        percentageDragged = snapPointPercentageDragged;
+      }
+      if (noCloseSnapPointsPreCondition && percentageDragged >= 1) {
+        return;
+      }
+      if (!isAllowedToDrag.current && !shouldDrag(event.target, isDraggingInDirection)) return;
+      drawerRef.current.classList.add(DRAG_CLASS);
+      isAllowedToDrag.current = true;
+      set(drawerRef.current, {
+        transition: "none"
+      });
+      set(overlayRef.current, {
+        transition: "none"
+      });
+      if (snapPoints) {
+        onDragSnapPoints({
+          draggedDistance
+        });
+      }
+      if (isDraggingInDirection && !snapPoints) {
+        const dampenedDraggedDistance = dampenValue(draggedDistance);
+        const translateValue = Math.min(dampenedDraggedDistance * -1, 0) * directionMultiplier;
+        set(drawerRef.current, {
+          transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`
+        });
+        return;
+      }
+      const opacityValue = 1 - percentageDragged;
+      if (shouldFade || fadeFromIndex && activeSnapPointIndex === fadeFromIndex - 1) {
+        onDragProp == null ? void 0 : onDragProp(event, percentageDragged);
+        set(overlayRef.current, {
+          opacity: `${opacityValue}`,
+          transition: "none"
+        }, true);
+      }
+      if (wrapper && overlayRef.current && shouldScaleBackground) {
+        const scaleValue = Math.min(getScale() + percentageDragged * (1 - getScale()), 1);
+        const borderRadiusValue = 8 - percentageDragged * 8;
+        const translateValue = Math.max(0, 14 - percentageDragged * 14);
+        set(wrapper, {
+          borderRadius: `${borderRadiusValue}px`,
+          transform: isVertical(direction) ? `scale(${scaleValue}) translate3d(0, ${translateValue}px, 0)` : `scale(${scaleValue}) translate3d(${translateValue}px, 0, 0)`,
+          transition: "none"
+        }, true);
+      }
+      if (!snapPoints) {
+        const translateValue = absDraggedDistance * directionMultiplier;
+        set(drawerRef.current, {
+          transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`
+        });
+      }
+    }
+  }
+  React__default.useEffect(() => {
+    window.requestAnimationFrame(() => {
+      shouldAnimate.current = true;
+    });
+  }, []);
+  React__default.useEffect(() => {
+    var _window_visualViewport;
+    function onVisualViewportChange() {
+      if (!drawerRef.current || !repositionInputs) return;
+      const focusedElement = document.activeElement;
+      if (isInput(focusedElement) || keyboardIsOpen.current) {
+        var _window_visualViewport2;
+        const visualViewportHeight = ((_window_visualViewport2 = window.visualViewport) == null ? void 0 : _window_visualViewport2.height) || 0;
+        const totalHeight = window.innerHeight;
+        let diffFromInitial = totalHeight - visualViewportHeight;
+        const drawerHeight = drawerRef.current.getBoundingClientRect().height || 0;
+        const isTallEnough = drawerHeight > totalHeight * 0.8;
+        if (!initialDrawerHeight.current) {
+          initialDrawerHeight.current = drawerHeight;
+        }
+        const offsetFromTop = drawerRef.current.getBoundingClientRect().top;
+        if (Math.abs(previousDiffFromInitial.current - diffFromInitial) > 60) {
+          keyboardIsOpen.current = !keyboardIsOpen.current;
+        }
+        if (snapPoints && snapPoints.length > 0 && snapPointsOffset && activeSnapPointIndex) {
+          const activeSnapPointHeight = snapPointsOffset[activeSnapPointIndex] || 0;
+          diffFromInitial += activeSnapPointHeight;
+        }
+        previousDiffFromInitial.current = diffFromInitial;
+        if (drawerHeight > visualViewportHeight || keyboardIsOpen.current) {
+          const height = drawerRef.current.getBoundingClientRect().height;
+          let newDrawerHeight = height;
+          if (height > visualViewportHeight) {
+            newDrawerHeight = visualViewportHeight - (isTallEnough ? offsetFromTop : WINDOW_TOP_OFFSET);
+          }
+          if (fixed) {
+            drawerRef.current.style.height = `${height - Math.max(diffFromInitial, 0)}px`;
+          } else {
+            drawerRef.current.style.height = `${Math.max(newDrawerHeight, visualViewportHeight - offsetFromTop)}px`;
+          }
+        } else if (!isMobileFirefox()) {
+          drawerRef.current.style.height = `${initialDrawerHeight.current}px`;
+        }
+        if (snapPoints && snapPoints.length > 0 && !keyboardIsOpen.current) {
+          drawerRef.current.style.bottom = `0px`;
+        } else {
+          drawerRef.current.style.bottom = `${Math.max(diffFromInitial, 0)}px`;
+        }
+      }
+    }
+    (_window_visualViewport = window.visualViewport) == null ? void 0 : _window_visualViewport.addEventListener("resize", onVisualViewportChange);
+    return () => {
+      var _window_visualViewport2;
+      return (_window_visualViewport2 = window.visualViewport) == null ? void 0 : _window_visualViewport2.removeEventListener("resize", onVisualViewportChange);
+    };
+  }, [
+    activeSnapPointIndex,
+    snapPoints,
+    snapPointsOffset
+  ]);
+  function closeDrawer(fromWithin) {
+    cancelDrag();
+    onClose == null ? void 0 : onClose();
+    if (!fromWithin) {
+      setIsOpen(false);
+    }
+    setTimeout(() => {
+      if (snapPoints) {
+        setActiveSnapPoint(snapPoints[0]);
+      }
+    }, TRANSITIONS.DURATION * 1e3);
+  }
+  function resetDrawer() {
+    if (!drawerRef.current) return;
+    const wrapper = document.querySelector("[data-vaul-drawer-wrapper]");
+    const currentSwipeAmount = getTranslate(drawerRef.current, direction);
+    set(drawerRef.current, {
+      transform: "translate3d(0, 0, 0)",
+      transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`
+    });
+    set(overlayRef.current, {
+      transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`,
+      opacity: "1"
+    });
+    if (shouldScaleBackground && currentSwipeAmount && currentSwipeAmount > 0 && isOpen) {
+      set(wrapper, {
+        borderRadius: `${BORDER_RADIUS}px`,
+        overflow: "hidden",
+        ...isVertical(direction) ? {
+          transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`,
+          transformOrigin: "top"
+        } : {
+          transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`,
+          transformOrigin: "left"
+        },
+        transitionProperty: "transform, border-radius",
+        transitionDuration: `${TRANSITIONS.DURATION}s`,
+        transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(",")})`
+      }, true);
+    }
+  }
+  function cancelDrag() {
+    if (!isDragging || !drawerRef.current) return;
+    drawerRef.current.classList.remove(DRAG_CLASS);
+    isAllowedToDrag.current = false;
+    setIsDragging(false);
+    dragEndTime.current = /* @__PURE__ */ new Date();
+  }
+  function onRelease(event) {
+    if (!isDragging || !drawerRef.current) return;
+    drawerRef.current.classList.remove(DRAG_CLASS);
+    isAllowedToDrag.current = false;
+    setIsDragging(false);
+    dragEndTime.current = /* @__PURE__ */ new Date();
+    const swipeAmount = getTranslate(drawerRef.current, direction);
+    if (!event || !shouldDrag(event.target, false) || !swipeAmount || Number.isNaN(swipeAmount)) return;
+    if (dragStartTime.current === null) return;
+    const timeTaken = dragEndTime.current.getTime() - dragStartTime.current.getTime();
+    const distMoved = pointerStart.current - (isVertical(direction) ? event.pageY : event.pageX);
+    const velocity = Math.abs(distMoved) / timeTaken;
+    if (velocity > 0.05) {
+      setJustReleased(true);
+      setTimeout(() => {
+        setJustReleased(false);
+      }, 200);
+    }
+    if (snapPoints) {
+      const directionMultiplier = direction === "bottom" || direction === "right" ? 1 : -1;
+      onReleaseSnapPoints({
+        draggedDistance: distMoved * directionMultiplier,
+        closeDrawer,
+        velocity,
+        dismissible
+      });
+      onReleaseProp == null ? void 0 : onReleaseProp(event, true);
+      return;
+    }
+    if (direction === "bottom" || direction === "right" ? distMoved > 0 : distMoved < 0) {
+      resetDrawer();
+      onReleaseProp == null ? void 0 : onReleaseProp(event, true);
+      return;
+    }
+    if (velocity > VELOCITY_THRESHOLD) {
+      closeDrawer();
+      onReleaseProp == null ? void 0 : onReleaseProp(event, false);
+      return;
+    }
+    var _drawerRef_current_getBoundingClientRect_height;
+    const visibleDrawerHeight = Math.min((_drawerRef_current_getBoundingClientRect_height = drawerRef.current.getBoundingClientRect().height) != null ? _drawerRef_current_getBoundingClientRect_height : 0, window.innerHeight);
+    var _drawerRef_current_getBoundingClientRect_width;
+    const visibleDrawerWidth = Math.min((_drawerRef_current_getBoundingClientRect_width = drawerRef.current.getBoundingClientRect().width) != null ? _drawerRef_current_getBoundingClientRect_width : 0, window.innerWidth);
+    const isHorizontalSwipe = direction === "left" || direction === "right";
+    if (Math.abs(swipeAmount) >= (isHorizontalSwipe ? visibleDrawerWidth : visibleDrawerHeight) * closeThreshold) {
+      closeDrawer();
+      onReleaseProp == null ? void 0 : onReleaseProp(event, false);
+      return;
+    }
+    onReleaseProp == null ? void 0 : onReleaseProp(event, true);
+    resetDrawer();
+  }
+  React__default.useEffect(() => {
+    if (isOpen) {
+      set(document.documentElement, {
+        scrollBehavior: "auto"
+      });
+      openTime.current = /* @__PURE__ */ new Date();
+    }
+    return () => {
+      reset(document.documentElement, "scrollBehavior");
+    };
+  }, [
+    isOpen
+  ]);
+  function onNestedOpenChange(o) {
+    const scale = o ? (window.innerWidth - NESTED_DISPLACEMENT) / window.innerWidth : 1;
+    const initialTranslate = o ? -NESTED_DISPLACEMENT : 0;
+    if (nestedOpenChangeTimer.current) {
+      window.clearTimeout(nestedOpenChangeTimer.current);
+    }
+    set(drawerRef.current, {
+      transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`,
+      transform: isVertical(direction) ? `scale(${scale}) translate3d(0, ${initialTranslate}px, 0)` : `scale(${scale}) translate3d(${initialTranslate}px, 0, 0)`
+    });
+    if (!o && drawerRef.current) {
+      nestedOpenChangeTimer.current = setTimeout(() => {
+        const translateValue = getTranslate(drawerRef.current, direction);
+        set(drawerRef.current, {
+          transition: "none",
+          transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`
+        });
+      }, 500);
+    }
+  }
+  function onNestedDrag(_event, percentageDragged) {
+    if (percentageDragged < 0) return;
+    const initialScale = (window.innerWidth - NESTED_DISPLACEMENT) / window.innerWidth;
+    const newScale = initialScale + percentageDragged * (1 - initialScale);
+    const newTranslate = -NESTED_DISPLACEMENT + percentageDragged * NESTED_DISPLACEMENT;
+    set(drawerRef.current, {
+      transform: isVertical(direction) ? `scale(${newScale}) translate3d(0, ${newTranslate}px, 0)` : `scale(${newScale}) translate3d(${newTranslate}px, 0, 0)`,
+      transition: "none"
+    });
+  }
+  function onNestedRelease(_event, o) {
+    const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+    const scale = o ? (dim - NESTED_DISPLACEMENT) / dim : 1;
+    const translate = o ? -NESTED_DISPLACEMENT : 0;
+    if (o) {
+      set(drawerRef.current, {
+        transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(",")})`,
+        transform: isVertical(direction) ? `scale(${scale}) translate3d(0, ${translate}px, 0)` : `scale(${scale}) translate3d(${translate}px, 0, 0)`
+      });
+    }
+  }
+  React__default.useEffect(() => {
+    if (!modal) {
+      window.requestAnimationFrame(() => {
+        document.body.style.pointerEvents = "auto";
+      });
+    }
+  }, [
+    modal
+  ]);
+  return /* @__PURE__ */ React__default.createElement(DialogPrimitive.Root, {
+    defaultOpen,
+    onOpenChange: (open) => {
+      if (!dismissible && !open) return;
+      if (open) {
+        setHasBeenOpened(true);
+      } else {
+        closeDrawer(true);
+      }
+      setIsOpen(open);
+    },
+    open: isOpen
+  }, /* @__PURE__ */ React__default.createElement(DrawerContext.Provider, {
+    value: {
+      activeSnapPoint,
+      snapPoints,
+      setActiveSnapPoint,
+      drawerRef,
+      overlayRef,
+      onOpenChange,
+      onPress,
+      onRelease,
+      onDrag,
+      dismissible,
+      shouldAnimate,
+      handleOnly,
+      isOpen,
+      isDragging,
+      shouldFade,
+      closeDrawer,
+      onNestedDrag,
+      onNestedOpenChange,
+      onNestedRelease,
+      keyboardIsOpen,
+      modal,
+      snapPointsOffset,
+      activeSnapPointIndex,
+      direction,
+      shouldScaleBackground,
+      setBackgroundColorOnScale,
+      noBodyStyles,
+      container,
+      autoFocus
+    }
+  }, children));
+}
+var Overlay2 = /* @__PURE__ */ React__default.forwardRef(function({ ...rest }, ref) {
+  const { overlayRef, snapPoints, onRelease, shouldFade, isOpen, modal, shouldAnimate } = useDrawerContext();
+  const composedRef = useComposedRefs(ref, overlayRef);
+  const hasSnapPoints = snapPoints && snapPoints.length > 0;
+  if (!modal) {
+    return null;
+  }
+  const onMouseUp = React__default.useCallback((event) => onRelease(event), [
+    onRelease
+  ]);
+  return /* @__PURE__ */ React__default.createElement(DialogPrimitive.Overlay, {
+    onMouseUp,
+    ref: composedRef,
+    "data-vaul-overlay": "",
+    "data-vaul-snap-points": isOpen && hasSnapPoints ? "true" : "false",
+    "data-vaul-snap-points-overlay": isOpen && shouldFade ? "true" : "false",
+    "data-vaul-animate": (shouldAnimate == null ? void 0 : shouldAnimate.current) ? "true" : "false",
+    ...rest
+  });
+});
+Overlay2.displayName = "Drawer.Overlay";
+var Content2 = /* @__PURE__ */ React__default.forwardRef(function({ onPointerDownOutside, style, onOpenAutoFocus, ...rest }, ref) {
+  const { drawerRef, onPress, onRelease, onDrag, keyboardIsOpen, snapPointsOffset, activeSnapPointIndex, modal, isOpen, direction, snapPoints, container, handleOnly, shouldAnimate, autoFocus } = useDrawerContext();
+  const [delayedSnapPoints, setDelayedSnapPoints] = React__default.useState(false);
+  const composedRef = useComposedRefs(ref, drawerRef);
+  const pointerStartRef = React__default.useRef(null);
+  const lastKnownPointerEventRef = React__default.useRef(null);
+  const wasBeyondThePointRef = React__default.useRef(false);
+  const hasSnapPoints = snapPoints && snapPoints.length > 0;
+  useScaleBackground();
+  const isDeltaInDirection = (delta, direction2, threshold = 0) => {
+    if (wasBeyondThePointRef.current) return true;
+    const deltaY = Math.abs(delta.y);
+    const deltaX = Math.abs(delta.x);
+    const isDeltaX = deltaX > deltaY;
+    const dFactor = [
+      "bottom",
+      "right"
+    ].includes(direction2) ? 1 : -1;
+    if (direction2 === "left" || direction2 === "right") {
+      const isReverseDirection = delta.x * dFactor < 0;
+      if (!isReverseDirection && deltaX >= 0 && deltaX <= threshold) {
+        return isDeltaX;
+      }
+    } else {
+      const isReverseDirection = delta.y * dFactor < 0;
+      if (!isReverseDirection && deltaY >= 0 && deltaY <= threshold) {
+        return !isDeltaX;
+      }
+    }
+    wasBeyondThePointRef.current = true;
+    return true;
+  };
+  React__default.useEffect(() => {
+    if (hasSnapPoints) {
+      window.requestAnimationFrame(() => {
+        setDelayedSnapPoints(true);
+      });
+    }
+  }, []);
+  function handleOnPointerUp(event) {
+    pointerStartRef.current = null;
+    wasBeyondThePointRef.current = false;
+    onRelease(event);
+  }
+  return /* @__PURE__ */ React__default.createElement(DialogPrimitive.Content, {
+    "data-vaul-drawer-direction": direction,
+    "data-vaul-drawer": "",
+    "data-vaul-delayed-snap-points": delayedSnapPoints ? "true" : "false",
+    "data-vaul-snap-points": isOpen && hasSnapPoints ? "true" : "false",
+    "data-vaul-custom-container": container ? "true" : "false",
+    "data-vaul-animate": (shouldAnimate == null ? void 0 : shouldAnimate.current) ? "true" : "false",
+    ...rest,
+    ref: composedRef,
+    style: snapPointsOffset && snapPointsOffset.length > 0 ? {
+      "--snap-point-height": `${snapPointsOffset[activeSnapPointIndex != null ? activeSnapPointIndex : 0]}px`,
+      ...style
+    } : style,
+    onPointerDown: (event) => {
+      if (handleOnly) return;
+      rest.onPointerDown == null ? void 0 : rest.onPointerDown.call(rest, event);
+      pointerStartRef.current = {
+        x: event.pageX,
+        y: event.pageY
+      };
+      onPress(event);
+    },
+    onOpenAutoFocus: (e) => {
+      onOpenAutoFocus == null ? void 0 : onOpenAutoFocus(e);
+      if (!autoFocus) {
+        e.preventDefault();
+      }
+    },
+    onPointerDownOutside: (e) => {
+      onPointerDownOutside == null ? void 0 : onPointerDownOutside(e);
+      if (!modal || e.defaultPrevented) {
+        e.preventDefault();
+        return;
+      }
+      if (keyboardIsOpen.current) {
+        keyboardIsOpen.current = false;
+      }
+    },
+    onFocusOutside: (e) => {
+      if (!modal) {
+        e.preventDefault();
+        return;
+      }
+    },
+    onPointerMove: (event) => {
+      lastKnownPointerEventRef.current = event;
+      if (handleOnly) return;
+      rest.onPointerMove == null ? void 0 : rest.onPointerMove.call(rest, event);
+      if (!pointerStartRef.current) return;
+      const yPosition = event.pageY - pointerStartRef.current.y;
+      const xPosition = event.pageX - pointerStartRef.current.x;
+      const swipeStartThreshold = event.pointerType === "touch" ? 10 : 2;
+      const delta = {
+        x: xPosition,
+        y: yPosition
+      };
+      const isAllowedToSwipe = isDeltaInDirection(delta, direction, swipeStartThreshold);
+      if (isAllowedToSwipe) onDrag(event);
+      else if (Math.abs(xPosition) > swipeStartThreshold || Math.abs(yPosition) > swipeStartThreshold) {
+        pointerStartRef.current = null;
+      }
+    },
+    onPointerUp: (event) => {
+      rest.onPointerUp == null ? void 0 : rest.onPointerUp.call(rest, event);
+      pointerStartRef.current = null;
+      wasBeyondThePointRef.current = false;
+      onRelease(event);
+    },
+    onPointerOut: (event) => {
+      rest.onPointerOut == null ? void 0 : rest.onPointerOut.call(rest, event);
+      handleOnPointerUp(lastKnownPointerEventRef.current);
+    },
+    onContextMenu: (event) => {
+      rest.onContextMenu == null ? void 0 : rest.onContextMenu.call(rest, event);
+      if (lastKnownPointerEventRef.current) {
+        handleOnPointerUp(lastKnownPointerEventRef.current);
+      }
+    }
+  });
+});
+Content2.displayName = "Drawer.Content";
+var LONG_HANDLE_PRESS_TIMEOUT = 250;
+var DOUBLE_TAP_TIMEOUT = 120;
+var Handle = /* @__PURE__ */ React__default.forwardRef(function({ preventCycle = false, children, ...rest }, ref) {
+  const { closeDrawer, isDragging, snapPoints, activeSnapPoint, setActiveSnapPoint, dismissible, handleOnly, isOpen, onPress, onDrag } = useDrawerContext();
+  const closeTimeoutIdRef = React__default.useRef(null);
+  const shouldCancelInteractionRef = React__default.useRef(false);
+  function handleStartCycle() {
+    if (shouldCancelInteractionRef.current) {
+      handleCancelInteraction();
+      return;
+    }
+    window.setTimeout(() => {
+      handleCycleSnapPoints();
+    }, DOUBLE_TAP_TIMEOUT);
+  }
+  function handleCycleSnapPoints() {
+    if (isDragging || preventCycle || shouldCancelInteractionRef.current) {
+      handleCancelInteraction();
+      return;
+    }
+    handleCancelInteraction();
+    if (!snapPoints || snapPoints.length === 0) {
+      if (!dismissible) {
+        closeDrawer();
+      }
+      return;
+    }
+    const isLastSnapPoint = activeSnapPoint === snapPoints[snapPoints.length - 1];
+    if (isLastSnapPoint && dismissible) {
+      closeDrawer();
+      return;
+    }
+    const currentSnapIndex = snapPoints.findIndex((point) => point === activeSnapPoint);
+    if (currentSnapIndex === -1) return;
+    const nextSnapPoint = snapPoints[currentSnapIndex + 1];
+    setActiveSnapPoint(nextSnapPoint);
+  }
+  function handleStartInteraction() {
+    closeTimeoutIdRef.current = window.setTimeout(() => {
+      shouldCancelInteractionRef.current = true;
+    }, LONG_HANDLE_PRESS_TIMEOUT);
+  }
+  function handleCancelInteraction() {
+    if (closeTimeoutIdRef.current) {
+      window.clearTimeout(closeTimeoutIdRef.current);
+    }
+    shouldCancelInteractionRef.current = false;
+  }
+  return /* @__PURE__ */ React__default.createElement("div", {
+    onClick: handleStartCycle,
+    onPointerCancel: handleCancelInteraction,
+    onPointerDown: (e) => {
+      if (handleOnly) onPress(e);
+      handleStartInteraction();
+    },
+    onPointerMove: (e) => {
+      if (handleOnly) onDrag(e);
+    },
+    // onPointerUp is already handled by the content component
+    ref,
+    "data-vaul-drawer-visible": isOpen ? "true" : "false",
+    "data-vaul-handle": "",
+    "aria-hidden": "true",
+    ...rest
+  }, /* @__PURE__ */ React__default.createElement("span", {
+    "data-vaul-handle-hitarea": "",
+    "aria-hidden": "true"
+  }, children));
+});
+Handle.displayName = "Drawer.Handle";
+function NestedRoot({ onDrag, onOpenChange, open: nestedIsOpen, ...rest }) {
+  const { onNestedDrag, onNestedOpenChange, onNestedRelease } = useDrawerContext();
+  if (!onNestedDrag) {
+    throw new Error("Drawer.NestedRoot must be placed in another drawer");
+  }
+  return /* @__PURE__ */ React__default.createElement(Root2, {
+    nested: true,
+    open: nestedIsOpen,
+    onClose: () => {
+      onNestedOpenChange(false);
+    },
+    onDrag: (e, p) => {
+      onNestedDrag(e, p);
+      onDrag == null ? void 0 : onDrag(e, p);
+    },
+    onOpenChange: (o) => {
+      if (o) {
+        onNestedOpenChange(o);
+      }
+      onOpenChange == null ? void 0 : onOpenChange(o);
+    },
+    onRelease: onNestedRelease,
+    ...rest
+  });
+}
+function Portal2(props) {
+  const context = useDrawerContext();
+  const { container = context.container, ...portalProps } = props;
+  return /* @__PURE__ */ React__default.createElement(DialogPrimitive.Portal, {
+    container,
+    ...portalProps
+  });
+}
+var Drawer = {
+  Root: Root2,
+  NestedRoot,
+  Content: Content2,
+  Overlay: Overlay2,
+  Trigger: DialogPrimitive.Trigger,
+  Portal: Portal2,
+  Handle,
+  Close: DialogPrimitive.Close,
+  Title: DialogPrimitive.Title,
+  Description: DialogPrimitive.Description
+};
+
+// src/components/Drawer/Drawer.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var DrawerContext2 = React2.createContext({ scrollLock: "style", open: false, modal: true });
+function Root3({ scrollLock = "style", onOpenChange, ...props }) {
+  const [uncontrolledOpen, setUncontrolledOpen] = React2.useState(props.defaultOpen ?? false);
+  const open = props.open ?? uncontrolledOpen;
+  return /* @__PURE__ */ jsx(DrawerContext2.Provider, { value: { scrollLock, open, modal: props.modal ?? true }, children: /* @__PURE__ */ jsx(
+    Drawer.Root,
+    {
+      ...props,
+      onOpenChange: (next) => {
+        setUncontrolledOpen(next);
+        onOpenChange?.(next);
+      }
+    }
+  ) });
+}
+Root3.displayName = "Drawer.Root";
+var Trigger2 = Drawer.Trigger;
+var Close2 = Drawer.Close;
+var Portal3 = Drawer.Portal;
+var scrollLocks = 0;
+function useClassScrollLock() {
+  React2.useEffect(() => {
+    const html = document.documentElement;
+    if (scrollLocks++ === 0) {
+      html.classList.toggle("nexub-scroll-gutter", window.innerWidth > html.clientWidth);
+      html.classList.add("nexub-scroll-lock");
+    }
+    return () => {
+      if (--scrollLocks === 0) html.classList.remove("nexub-scroll-lock", "nexub-scroll-gutter");
+    };
+  }, []);
+}
+var ClassLockOverlay = React2.forwardRef(
+  ({ asChild, forceMount: _forceMount, open, ...props }, ref) => {
+    useClassScrollLock();
+    const Comp = asChild ? Slot : "div";
+    return /* @__PURE__ */ jsx(
+      Comp,
+      {
+        ref,
+        "data-vaul-overlay": "",
+        "data-vaul-snap-points": "false",
+        "data-state": open ? "open" : "closed",
+        ...props
+      }
+    );
+  }
+);
+var Overlay3 = React2.forwardRef(
+  ({ className, ...props }, ref) => {
+    const { scrollLock, open, modal } = React2.useContext(DrawerContext2);
+    const classes = cn("fixed inset-0 z-[var(--z-modal)] bg-[var(--color-overlay)]", className);
+    if (scrollLock === "class") {
+      if (!modal) return null;
+      return /* @__PURE__ */ jsx(ClassLockOverlay, { ref, open, className: cn("pointer-events-auto", classes), ...props });
+    }
+    return /* @__PURE__ */ jsx(Drawer.Overlay, { ref, className: classes, ...props });
+  }
+);
+Overlay3.displayName = "Drawer.Overlay";
+var Content3 = React2.forwardRef(({ className, children, side = "right", surface = "solid", ...props }, ref) => {
+  const sideMap = {
+    right: "inset-y-0 right-0 h-full w-3/4 max-w-sm border-l overflow-x-hidden",
+    left: "inset-y-0 left-0 h-full w-3/4 max-w-sm border-r overflow-x-hidden",
+    top: "inset-x-0 top-0 w-full border-b",
+    bottom: "inset-x-0 bottom-0 w-full border-t rounded-t-2xl"
+  };
+  return /* @__PURE__ */ jsxs(
+    Drawer.Content,
+    {
+      ref,
+      className: cn(
+        "fixed z-[var(--z-modal)] flex flex-col bg-[var(--color-bg-default)] shadow-xl focus:outline-none",
+        sideMap[side],
+        surface === "glass" && glassSurfaceClass,
+        className
+      ),
+      "data-material": surface === "glass" ? "glass" : void 0,
+      ...props,
+      children: [
+        side === "bottom" && /* @__PURE__ */ jsx("div", { className: "mx-auto mt-4 h-2 w-20 rounded-full bg-[var(--color-border-default)]" }),
+        children
+      ]
+    }
+  );
+});
+Content3.displayName = "Drawer.Content";
+var Title2 = React2.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+    Drawer.Title,
+    {
+      ref,
+      className: cn("text-lg font-semibold text-[var(--color-text-primary)]", className),
+      ...props
+    }
+  )
+);
+Title2.displayName = "Drawer.Title";
+var Description2 = React2.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+    Drawer.Description,
+    {
+      ref,
+      className: cn("text-sm text-[var(--color-text-muted)]", className),
+      ...props
+    }
+  )
+);
+Description2.displayName = "Drawer.Description";
+var Header = React2.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: cn("flex flex-col gap-1.5 p-6", className), ...props })
+);
+Header.displayName = "Drawer.Header";
+var Footer = React2.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: cn("mt-auto flex flex-col gap-2 p-6", className), ...props })
+);
+Footer.displayName = "Drawer.Footer";
+var Drawer2 = {
+  Root: Root3,
+  Trigger: Trigger2,
+  Portal: Portal3,
+  Overlay: Overlay3,
+  Content: Content3,
+  Close: Close2,
+  Title: Title2,
+  Description: Description2,
+  Header,
+  Footer
+};
+var Sheet = Drawer2;
+
+export {
+  Drawer2 as Drawer,
+  Sheet
+};