@jobber/components 8.14.0 → 8.15.0

package/dist/{DrawerRoot-cjs.js → ScrollAreaViewport-cjs.js}

@@ -1918,6 +1918,109 @@ function FloatingFocusManager(props) {
   });
 }
 
+/**
+ * Opens or closes the floating element when clicking the reference element.
+ * @see https://floating-ui.com/docs/useClick
+ */
+function useClick(context, props = {}) {
+  const store = 'rootStore' in context ? context.rootStore : context;
+  const dataRef = store.context.dataRef;
+  const {
+    enabled = true,
+    event: eventOption = 'click',
+    toggle = true,
+    ignoreMouse = false,
+    stickIfOpen = true,
+    touchOpenDelay = 0,
+    reason = useValueChanged.triggerPress
+  } = props;
+  const pointerTypeRef = React__namespace.useRef(undefined);
+  const frame = useValueChanged.useAnimationFrame();
+  const touchOpenTimeout = useValueChanged.useTimeout();
+  const reference = React__namespace.useMemo(() => ({
+    onPointerDown(event) {
+      pointerTypeRef.current = event.pointerType;
+    },
+    onMouseDown(event) {
+      const pointerType = pointerTypeRef.current;
+      const nativeEvent = event.nativeEvent;
+      const open = store.select('open');
+
+      // Ignore all buttons except for the "main" button.
+      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
+      if (event.button !== 0 || eventOption === 'click' || useValueChanged.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+        return;
+      }
+      const openEvent = dataRef.current.openEvent;
+      const openEventType = openEvent?.type;
+      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;
+      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? openEventType === 'click' || openEventType === 'mousedown' : true));
+
+      // Animations sometimes won't run on a typeable element if using a rAF.
+      // Focus is always set on these elements. For touch, we may delay opening.
+      if (isTypeableElement(nativeEvent.target)) {
+        const details = useValueChanged.createChangeEventDetails(reason, nativeEvent, nativeEvent.target);
+        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
+          touchOpenTimeout.start(touchOpenDelay, () => {
+            store.setOpen(true, details);
+          });
+        } else {
+          store.setOpen(nextOpen, details);
+        }
+        return;
+      }
+
+      // Capture the currentTarget before the rAF.
+      // as React sets it to null after the event handler completes.
+      const eventCurrentTarget = event.currentTarget;
+
+      // Wait until focus is set on the element. This is an alternative to
+      // `event.preventDefault()` to avoid :focus-visible from appearing when using a pointer.
+      frame.request(() => {
+        const details = useValueChanged.createChangeEventDetails(reason, nativeEvent, eventCurrentTarget);
+        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
+          touchOpenTimeout.start(touchOpenDelay, () => {
+            store.setOpen(true, details);
+          });
+        } else {
+          store.setOpen(nextOpen, details);
+        }
+      });
+    },
+    onClick(event) {
+      if (eventOption === 'mousedown-only') {
+        return;
+      }
+      const pointerType = pointerTypeRef.current;
+      if (eventOption === 'mousedown' && pointerType) {
+        pointerTypeRef.current = undefined;
+        return;
+      }
+      if (useValueChanged.isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+        return;
+      }
+      const open = store.select('open');
+      const openEvent = dataRef.current.openEvent;
+      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;
+      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? useValueChanged.isClickLikeEvent(openEvent) : true));
+      const details = useValueChanged.createChangeEventDetails(reason, event.nativeEvent, event.currentTarget);
+      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {
+        touchOpenTimeout.start(touchOpenDelay, () => {
+          store.setOpen(true, details);
+        });
+      } else {
+        store.setOpen(nextOpen, details);
+      }
+    },
+    onKeyDown() {
+      pointerTypeRef.current = undefined;
+    }
+  }), [dataRef, eventOption, ignoreMouse, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay, reason]);
+  return React__namespace.useMemo(() => enabled ? {
+    reference
+  } : useRenderElement.EMPTY_OBJECT, [enabled, reference]);
+}
+
 const bubbleHandlerKeys = {
   intentional: 'onClick',
   sloppy: 'onPointerDown'
@@ -4608,7 +4711,7 @@ let drawerSwipeVarsRegistered = false;
  * See https://motion.dev/blog/web-animation-performance-tier-list
  * under the "Improving CSS variable performance" section.
  */
-function removeCSSVariableInheritance() {
+function removeCSSVariableInheritance$1() {
   if (drawerSwipeVarsRegistered) {
     return;
   }
@@ -4773,7 +4876,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
     if (!popupElement) {
       return undefined;
     }
-    removeCSSVariableInheritance();
+    removeCSSVariableInheritance$1();
     measureHeight();
     if (typeof ResizeObserver !== 'function') {
       return undefined;
@@ -5590,6 +5693,66 @@ function DialogRoot(props) {
   });
 }
 
+/**
+ * A button that opens the dialog.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTrigger(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    disabled = false,
+    nativeButton = true,
+    id: idProp,
+    payload,
+    handle,
+    ...elementProps
+  } = componentProps;
+  const dialogRootContext = useDialogRootContext(true);
+  const store = handle?.store ?? dialogRootContext?.store;
+  if (!store) {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: <Dialog.Trigger> must be used within <Dialog.Root> or provided with a handle.' : useRenderElement.formatErrorMessage(79));
+  }
+  const thisTriggerId = useValueChanged.useBaseUiId(idProp);
+  const floatingContext = store.useState('floatingRootContext');
+  const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);
+  const triggerElementRef = React__namespace.useRef(null);
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload
+  });
+  const {
+    getButtonProps,
+    buttonRef
+  } = useValueChanged.useButton({
+    disabled,
+    native: nativeButton
+  });
+  const click = useClick(floatingContext, {
+    enabled: floatingContext != null
+  });
+  const localInteractionProps = useInteractions([click]);
+  const state = {
+    disabled,
+    open: isOpenedByThisTrigger
+  };
+  const rootTriggerProps = store.useState('triggerProps', isMountedByThisTrigger);
+  return useRenderElement.useRenderElement('button', componentProps, {
+    state,
+    ref: [buttonRef, forwardedRef, registerTrigger, triggerElementRef],
+    props: [localInteractionProps.getReferenceProps(), rootTriggerProps, {
+      [CLICK_TRIGGER_IDENTIFIER]: '',
+      id: thisTriggerId
+    }, elementProps, getButtonProps],
+    stateAttributesMapping: triggerOpenStateMapping
+  });
+});
+if (process.env.NODE_ENV !== "production") DialogTrigger.displayName = "DialogTrigger";
+
 var _DrawerProviderReport, _DrawerProviderReport2;
 /**
  * Groups all parts of the drawer.
@@ -5809,12 +5972,878 @@ function DrawerProviderReporter() {
   return null;
 }
 
+/**
+ * A button that opens the drawer.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+const DrawerTrigger = DialogTrigger;
+
+/**
+ * @internal
+ */
+const DirectionContext = /*#__PURE__*/React__namespace.createContext(undefined);
+if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
+function useDirection() {
+  const context = React__namespace.useContext(DirectionContext);
+  return context?.direction ?? 'ltr';
+}
+
+const ScrollAreaRootContext = /*#__PURE__*/React__namespace.createContext(undefined);
+if (process.env.NODE_ENV !== "production") ScrollAreaRootContext.displayName = "ScrollAreaRootContext";
+function useScrollAreaRootContext() {
+  const context = React__namespace.useContext(ScrollAreaRootContext);
+  if (context === undefined) {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: ScrollAreaRootContext is missing. ScrollArea parts must be placed within <ScrollArea.Root>.' : useRenderElement.formatErrorMessage(53));
+  }
+  return context;
+}
+
+let ScrollAreaRootCssVars = /*#__PURE__*/function (ScrollAreaRootCssVars) {
+  /**
+   * The scroll area's corner height.
+   * @type {number}
+   */
+  ScrollAreaRootCssVars["scrollAreaCornerHeight"] = "--scroll-area-corner-height";
+  /**
+   * The scroll area's corner width.
+   * @type {number}
+   */
+  ScrollAreaRootCssVars["scrollAreaCornerWidth"] = "--scroll-area-corner-width";
+  return ScrollAreaRootCssVars;
+}({});
+
+const SCROLL_TIMEOUT = 500;
+const MIN_THUMB_SIZE = 16;
+
+function getOffset(element, prop, axis) {
+  if (!element) {
+    return 0;
+  }
+  const styles = getComputedStyle(element);
+  const propAxis = axis === 'x' ? 'Inline' : 'Block';
+
+  // Safari misreports `marginInlineEnd` in RTL.
+  // We have to assume the start/end values are symmetrical, which is likely.
+  if (axis === 'x' && prop === 'margin') {
+    return parseFloat(styles[`${prop}InlineStart`]) * 2;
+  }
+  return parseFloat(styles[`${prop}${propAxis}Start`]) + parseFloat(styles[`${prop}${propAxis}End`]);
+}
+
+let ScrollAreaScrollbarDataAttributes = /*#__PURE__*/function (ScrollAreaScrollbarDataAttributes) {
+  /**
+   * Indicates the orientation of the scrollbar.
+   * @type {'horizontal' | 'vertical'}
+   */
+  ScrollAreaScrollbarDataAttributes["orientation"] = "data-orientation";
+  /**
+   * Present when the pointer is over the scroll area.
+   */
+  ScrollAreaScrollbarDataAttributes["hovering"] = "data-hovering";
+  /**
+   * Present when the user scrolls inside the scroll area.
+   */
+  ScrollAreaScrollbarDataAttributes["scrolling"] = "data-scrolling";
+  /**
+   * Present when the scroll area content is wider than the viewport.
+   */
+  ScrollAreaScrollbarDataAttributes["hasOverflowX"] = "data-has-overflow-x";
+  /**
+   * Present when the scroll area content is taller than the viewport.
+   */
+  ScrollAreaScrollbarDataAttributes["hasOverflowY"] = "data-has-overflow-y";
+  /**
+   * Present when there is overflow on the horizontal start side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowXStart"] = "data-overflow-x-start";
+  /**
+   * Present when there is overflow on the horizontal end side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowXEnd"] = "data-overflow-x-end";
+  /**
+   * Present when there is overflow on the vertical start side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowYStart"] = "data-overflow-y-start";
+  /**
+   * Present when there is overflow on the vertical end side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowYEnd"] = "data-overflow-y-end";
+  return ScrollAreaScrollbarDataAttributes;
+}({});
+
+const DISABLE_SCROLLBAR_CLASS_NAME = 'base-ui-disable-scrollbar';
+const styleDisableScrollbar = {
+  className: DISABLE_SCROLLBAR_CLASS_NAME,
+  getElement(nonce) {
+    return /*#__PURE__*/jsxRuntime.jsx("style", {
+      nonce: nonce,
+      href: DISABLE_SCROLLBAR_CLASS_NAME,
+      precedence: "base-ui:low",
+      children: `.${DISABLE_SCROLLBAR_CLASS_NAME}{scrollbar-width:none}.${DISABLE_SCROLLBAR_CLASS_NAME}::-webkit-scrollbar{display:none}`
+    });
+  }
+};
+if (process.env.NODE_ENV !== "production") styleDisableScrollbar.getElement.displayName = "styleDisableScrollbar.getElement";
+
+let ScrollAreaRootDataAttributes = /*#__PURE__*/function (ScrollAreaRootDataAttributes) {
+  /**
+   * Present when the user scrolls inside the scroll area.
+   */
+  ScrollAreaRootDataAttributes["scrolling"] = "data-scrolling";
+  /**
+   * Present when the scroll area content is wider than the viewport.
+   */
+  ScrollAreaRootDataAttributes["hasOverflowX"] = "data-has-overflow-x";
+  /**
+   * Present when the scroll area content is taller than the viewport.
+   */
+  ScrollAreaRootDataAttributes["hasOverflowY"] = "data-has-overflow-y";
+  /**
+   * Present when there is overflow on the horizontal start side.
+   */
+  ScrollAreaRootDataAttributes["overflowXStart"] = "data-overflow-x-start";
+  /**
+   * Present when there is overflow on the horizontal end side.
+   */
+  ScrollAreaRootDataAttributes["overflowXEnd"] = "data-overflow-x-end";
+  /**
+   * Present when there is overflow on the vertical start side.
+   */
+  ScrollAreaRootDataAttributes["overflowYStart"] = "data-overflow-y-start";
+  /**
+   * Present when there is overflow on the vertical end side.
+   */
+  ScrollAreaRootDataAttributes["overflowYEnd"] = "data-overflow-y-end";
+  return ScrollAreaRootDataAttributes;
+}({});
+
+const scrollAreaStateAttributesMapping = {
+  hasOverflowX: value => value ? {
+    [ScrollAreaRootDataAttributes.hasOverflowX]: ''
+  } : null,
+  hasOverflowY: value => value ? {
+    [ScrollAreaRootDataAttributes.hasOverflowY]: ''
+  } : null,
+  overflowXStart: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowXStart]: ''
+  } : null,
+  overflowXEnd: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowXEnd]: ''
+  } : null,
+  overflowYStart: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowYStart]: ''
+  } : null,
+  overflowYEnd: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowYEnd]: ''
+  } : null,
+  cornerHidden: () => null
+};
+
+/**
+ * @internal
+ */
+const CSPContext = /*#__PURE__*/React__namespace.createContext(undefined);
+if (process.env.NODE_ENV !== "production") CSPContext.displayName = "CSPContext";
+const DEFAULT_CSP_CONTEXT_VALUE = {
+  disableStyleElements: false
+};
+
+/**
+ * @internal
+ */
+function useCSPContext() {
+  return React__namespace.useContext(CSPContext) ?? DEFAULT_CSP_CONTEXT_VALUE;
+}
+
+const DEFAULT_COORDS = {
+  x: 0,
+  y: 0
+};
+const DEFAULT_SIZE = {
+  width: 0,
+  height: 0
+};
+const DEFAULT_OVERFLOW_EDGES = {
+  xStart: false,
+  xEnd: false,
+  yStart: false,
+  yEnd: false
+};
+const DEFAULT_HIDDEN_STATE = {
+  x: true,
+  y: true,
+  corner: true
+};
+/**
+ * Groups all parts of the scroll area.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Scroll Area](https://base-ui.com/react/components/scroll-area)
+ */
+const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollAreaRoot(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    overflowEdgeThreshold: overflowEdgeThresholdProp,
+    ...elementProps
+  } = componentProps;
+  const overflowEdgeThreshold = normalizeOverflowEdgeThreshold(overflowEdgeThresholdProp);
+  const rootId = useValueChanged.useBaseUiId();
+  const scrollYTimeout = useValueChanged.useTimeout();
+  const scrollXTimeout = useValueChanged.useTimeout();
+  const {
+    nonce,
+    disableStyleElements
+  } = useCSPContext();
+  const [hovering, setHovering] = React__namespace.useState(false);
+  const [scrollingX, setScrollingX] = React__namespace.useState(false);
+  const [scrollingY, setScrollingY] = React__namespace.useState(false);
+  const [touchModality, setTouchModality] = React__namespace.useState(false);
+  const [hasMeasuredScrollbar, setHasMeasuredScrollbar] = React__namespace.useState(false);
+  const [cornerSize, setCornerSize] = React__namespace.useState(DEFAULT_SIZE);
+  const [thumbSize, setThumbSize] = React__namespace.useState(DEFAULT_SIZE);
+  const [overflowEdges, setOverflowEdges] = React__namespace.useState(DEFAULT_OVERFLOW_EDGES);
+  const [hiddenState, setHiddenState] = React__namespace.useState(DEFAULT_HIDDEN_STATE);
+  const rootRef = React__namespace.useRef(null);
+  const viewportRef = React__namespace.useRef(null);
+  const scrollbarYRef = React__namespace.useRef(null);
+  const scrollbarXRef = React__namespace.useRef(null);
+  const thumbYRef = React__namespace.useRef(null);
+  const thumbXRef = React__namespace.useRef(null);
+  const cornerRef = React__namespace.useRef(null);
+  const thumbDraggingRef = React__namespace.useRef(false);
+  const startYRef = React__namespace.useRef(0);
+  const startXRef = React__namespace.useRef(0);
+  const startScrollTopRef = React__namespace.useRef(0);
+  const startScrollLeftRef = React__namespace.useRef(0);
+  const currentOrientationRef = React__namespace.useRef('vertical');
+  const scrollPositionRef = React__namespace.useRef(DEFAULT_COORDS);
+  const handleScroll = useValueChanged.useStableCallback(scrollPosition => {
+    const offsetX = scrollPosition.x - scrollPositionRef.current.x;
+    const offsetY = scrollPosition.y - scrollPositionRef.current.y;
+    scrollPositionRef.current = scrollPosition;
+    if (offsetY !== 0) {
+      setScrollingY(true);
+      scrollYTimeout.start(SCROLL_TIMEOUT, () => {
+        setScrollingY(false);
+      });
+    }
+    if (offsetX !== 0) {
+      setScrollingX(true);
+      scrollXTimeout.start(SCROLL_TIMEOUT, () => {
+        setScrollingX(false);
+      });
+    }
+  });
+  const handlePointerDown = useValueChanged.useStableCallback(event => {
+    if (event.button !== 0) {
+      return;
+    }
+    thumbDraggingRef.current = true;
+    startYRef.current = event.clientY;
+    startXRef.current = event.clientX;
+    currentOrientationRef.current = event.currentTarget.getAttribute(ScrollAreaScrollbarDataAttributes.orientation);
+    if (viewportRef.current) {
+      startScrollTopRef.current = viewportRef.current.scrollTop;
+      startScrollLeftRef.current = viewportRef.current.scrollLeft;
+    }
+    if (thumbYRef.current && currentOrientationRef.current === 'vertical') {
+      thumbYRef.current.setPointerCapture(event.pointerId);
+    }
+    if (thumbXRef.current && currentOrientationRef.current === 'horizontal') {
+      thumbXRef.current.setPointerCapture(event.pointerId);
+    }
+  });
+  const handlePointerMove = useValueChanged.useStableCallback(event => {
+    if (!thumbDraggingRef.current) {
+      return;
+    }
+    const deltaY = event.clientY - startYRef.current;
+    const deltaX = event.clientX - startXRef.current;
+    if (viewportRef.current) {
+      const scrollableContentHeight = viewportRef.current.scrollHeight;
+      const viewportHeight = viewportRef.current.clientHeight;
+      const scrollableContentWidth = viewportRef.current.scrollWidth;
+      const viewportWidth = viewportRef.current.clientWidth;
+      if (thumbYRef.current && scrollbarYRef.current && currentOrientationRef.current === 'vertical') {
+        const scrollbarYOffset = getOffset(scrollbarYRef.current, 'padding', 'y');
+        const thumbYOffset = getOffset(thumbYRef.current, 'margin', 'y');
+        const thumbHeight = thumbYRef.current.offsetHeight;
+        const maxThumbOffsetY = scrollbarYRef.current.offsetHeight - thumbHeight - scrollbarYOffset - thumbYOffset;
+        const scrollRatioY = deltaY / maxThumbOffsetY;
+        viewportRef.current.scrollTop = startScrollTopRef.current + scrollRatioY * (scrollableContentHeight - viewportHeight);
+        event.preventDefault();
+        setScrollingY(true);
+        scrollYTimeout.start(SCROLL_TIMEOUT, () => {
+          setScrollingY(false);
+        });
+      }
+      if (thumbXRef.current && scrollbarXRef.current && currentOrientationRef.current === 'horizontal') {
+        const scrollbarXOffset = getOffset(scrollbarXRef.current, 'padding', 'x');
+        const thumbXOffset = getOffset(thumbXRef.current, 'margin', 'x');
+        const thumbWidth = thumbXRef.current.offsetWidth;
+        const maxThumbOffsetX = scrollbarXRef.current.offsetWidth - thumbWidth - scrollbarXOffset - thumbXOffset;
+        const scrollRatioX = deltaX / maxThumbOffsetX;
+        viewportRef.current.scrollLeft = startScrollLeftRef.current + scrollRatioX * (scrollableContentWidth - viewportWidth);
+        event.preventDefault();
+        setScrollingX(true);
+        scrollXTimeout.start(SCROLL_TIMEOUT, () => {
+          setScrollingX(false);
+        });
+      }
+    }
+  });
+  const handlePointerUp = useValueChanged.useStableCallback(event => {
+    thumbDraggingRef.current = false;
+    if (thumbYRef.current && currentOrientationRef.current === 'vertical') {
+      thumbYRef.current.releasePointerCapture(event.pointerId);
+    }
+    if (thumbXRef.current && currentOrientationRef.current === 'horizontal') {
+      thumbXRef.current.releasePointerCapture(event.pointerId);
+    }
+  });
+  function handleTouchModalityChange(event) {
+    setTouchModality(event.pointerType === 'touch');
+  }
+  function handlePointerEnterOrMove(event) {
+    handleTouchModalityChange(event);
+    if (event.pointerType !== 'touch') {
+      const isTargetRootChild = contains(rootRef.current, event.target);
+      setHovering(isTargetRootChild);
+    }
+  }
+  const state = React__namespace.useMemo(() => ({
+    scrolling: scrollingX || scrollingY,
+    hasOverflowX: !hiddenState.x,
+    hasOverflowY: !hiddenState.y,
+    overflowXStart: overflowEdges.xStart,
+    overflowXEnd: overflowEdges.xEnd,
+    overflowYStart: overflowEdges.yStart,
+    overflowYEnd: overflowEdges.yEnd,
+    cornerHidden: hiddenState.corner
+  }), [scrollingX, scrollingY, hiddenState.x, hiddenState.y, hiddenState.corner, overflowEdges]);
+  const props = {
+    role: 'presentation',
+    onPointerEnter: handlePointerEnterOrMove,
+    onPointerMove: handlePointerEnterOrMove,
+    onPointerDown: handleTouchModalityChange,
+    onPointerLeave() {
+      setHovering(false);
+    },
+    style: {
+      position: 'relative',
+      [ScrollAreaRootCssVars.scrollAreaCornerHeight]: `${cornerSize.height}px`,
+      [ScrollAreaRootCssVars.scrollAreaCornerWidth]: `${cornerSize.width}px`
+    }
+  };
+  const element = useRenderElement.useRenderElement('div', componentProps, {
+    state,
+    ref: [forwardedRef, rootRef],
+    props: [props, elementProps],
+    stateAttributesMapping: scrollAreaStateAttributesMapping
+  });
+  const contextValue = React__namespace.useMemo(() => ({
+    handlePointerDown,
+    handlePointerMove,
+    handlePointerUp,
+    handleScroll,
+    cornerSize,
+    setCornerSize,
+    thumbSize,
+    setThumbSize,
+    hasMeasuredScrollbar,
+    setHasMeasuredScrollbar,
+    touchModality,
+    cornerRef,
+    scrollingX,
+    setScrollingX,
+    scrollingY,
+    setScrollingY,
+    hovering,
+    setHovering,
+    viewportRef,
+    rootRef,
+    scrollbarYRef,
+    scrollbarXRef,
+    thumbYRef,
+    thumbXRef,
+    rootId,
+    hiddenState,
+    setHiddenState,
+    overflowEdges,
+    setOverflowEdges,
+    viewportState: state,
+    overflowEdgeThreshold
+  }), [handlePointerDown, handlePointerMove, handlePointerUp, handleScroll, cornerSize, thumbSize, hasMeasuredScrollbar, touchModality, scrollingX, setScrollingX, scrollingY, setScrollingY, hovering, setHovering, rootId, hiddenState, overflowEdges, state, overflowEdgeThreshold]);
+  return /*#__PURE__*/jsxRuntime.jsxs(ScrollAreaRootContext.Provider, {
+    value: contextValue,
+    children: [!disableStyleElements && styleDisableScrollbar.getElement(nonce), element]
+  });
+});
+if (process.env.NODE_ENV !== "production") ScrollAreaRoot.displayName = "ScrollAreaRoot";
+function normalizeOverflowEdgeThreshold(threshold) {
+  if (typeof threshold === 'number') {
+    const value = Math.max(0, threshold);
+    return {
+      xStart: value,
+      xEnd: value,
+      yStart: value,
+      yEnd: value
+    };
+  }
+  return {
+    xStart: Math.max(0, threshold?.xStart || 0),
+    xEnd: Math.max(0, threshold?.xEnd || 0),
+    yStart: Math.max(0, threshold?.yStart || 0),
+    yEnd: Math.max(0, threshold?.yEnd || 0)
+  };
+}
+
+const ScrollAreaViewportContext = /*#__PURE__*/React__namespace.createContext(undefined);
+if (process.env.NODE_ENV !== "production") ScrollAreaViewportContext.displayName = "ScrollAreaViewportContext";
+function useScrollAreaViewportContext() {
+  const context = React__namespace.useContext(ScrollAreaViewportContext);
+  if (context === undefined) {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: ScrollAreaViewportContext missing. ScrollAreaViewport parts must be placed within <ScrollArea.Viewport>.' : useRenderElement.formatErrorMessage(55));
+  }
+  return context;
+}
+
+/**
+ * Executes a callback when an element becomes visible.
+ */
+function onVisible(element, callback) {
+  if (typeof IntersectionObserver === 'undefined') {
+    return () => {};
+  }
+  const observer = new IntersectionObserver(entries => {
+    entries.forEach(entry => {
+      if (entry.intersectionRatio > 0) {
+        callback();
+        observer.disconnect();
+      }
+    });
+  });
+  observer.observe(element);
+  return () => {
+    observer.disconnect();
+  };
+}
+
+let ScrollAreaViewportCssVars = /*#__PURE__*/function (ScrollAreaViewportCssVars) {
+  /**
+   * The distance from the horizontal start edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowXStart"] = "--scroll-area-overflow-x-start";
+  /**
+   * The distance from the horizontal end edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowXEnd"] = "--scroll-area-overflow-x-end";
+  /**
+   * The distance from the vertical start edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowYStart"] = "--scroll-area-overflow-y-start";
+  /**
+   * The distance from the vertical end edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowYEnd"] = "--scroll-area-overflow-y-end";
+  return ScrollAreaViewportCssVars;
+}({});
+
+const SCROLL_EDGE_TOLERANCE_PX = 1;
+function normalizeScrollOffset(value, max) {
+  if (max <= 0) {
+    return 0;
+  }
+  const clamped = useValueChanged.clamp(value, 0, max);
+  const startDistance = clamped;
+  const endDistance = max - clamped;
+  const withinStartTolerance = startDistance <= SCROLL_EDGE_TOLERANCE_PX;
+  const withinEndTolerance = endDistance <= SCROLL_EDGE_TOLERANCE_PX;
+  if (withinStartTolerance && withinEndTolerance) {
+    return startDistance <= endDistance ? 0 : max;
+  }
+  if (withinStartTolerance) {
+    return 0;
+  }
+  if (withinEndTolerance) {
+    return max;
+  }
+  return clamped;
+}
+
+let scrollAreaOverflowVarsRegistered = false;
+const HAS_RESIZE_OBSERVER = typeof ResizeObserver !== 'undefined';
+
+/**
+ * Removes inheritance of the scroll area overflow CSS variables, which
+ * improves rendering performance in complex scroll areas with deep subtrees.
+ * Instead, each child must manually opt-in to using these properties by
+ * specifying `inherit`.
+ * See https://motion.dev/blog/web-animation-performance-tier-list
+ * under the "Improving CSS variable performance" section.
+ */
+function removeCSSVariableInheritance() {
+  if (scrollAreaOverflowVarsRegistered ||
+  // When `inherits: false`, specifying `inherit` on child elements doesn't work
+  // in Safari. To let CSS features work correctly, this optimization must be skipped.
+  useValueChanged.isWebKit) {
+    return;
+  }
+  if (typeof CSS !== 'undefined' && 'registerProperty' in CSS) {
+    [ScrollAreaViewportCssVars.scrollAreaOverflowXStart, ScrollAreaViewportCssVars.scrollAreaOverflowXEnd, ScrollAreaViewportCssVars.scrollAreaOverflowYStart, ScrollAreaViewportCssVars.scrollAreaOverflowYEnd].forEach(name => {
+      try {
+        CSS.registerProperty({
+          name,
+          syntax: '<length>',
+          inherits: false,
+          initialValue: '0px'
+        });
+      } catch {
+        /* ignore already-registered */
+      }
+    });
+  }
+  scrollAreaOverflowVarsRegistered = true;
+}
+
+/**
+ * The actual scrollable container of the scroll area.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Scroll Area](https://base-ui.com/react/components/scroll-area)
+ */
+const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function ScrollAreaViewport(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    ...elementProps
+  } = componentProps;
+  const {
+    viewportRef,
+    scrollbarYRef,
+    scrollbarXRef,
+    thumbYRef,
+    thumbXRef,
+    cornerRef,
+    cornerSize,
+    setCornerSize,
+    setThumbSize,
+    rootId,
+    setHiddenState,
+    hiddenState,
+    setHasMeasuredScrollbar,
+    handleScroll,
+    setHovering,
+    setOverflowEdges,
+    overflowEdges,
+    overflowEdgeThreshold,
+    scrollingX,
+    scrollingY
+  } = useScrollAreaRootContext();
+  const direction = useDirection();
+  const programmaticScrollRef = React__namespace.useRef(true);
+  const lastMeasuredViewportMetricsRef = React__namespace.useRef([NaN, NaN, NaN, NaN]);
+  const scrollEndTimeout = useValueChanged.useTimeout();
+  const waitForAnimationsTimeout = useValueChanged.useTimeout();
+  const computeThumbPosition = useValueChanged.useStableCallback(() => {
+    const viewportEl = viewportRef.current;
+    const scrollbarYEl = scrollbarYRef.current;
+    const scrollbarXEl = scrollbarXRef.current;
+    const thumbYEl = thumbYRef.current;
+    const thumbXEl = thumbXRef.current;
+    const cornerEl = cornerRef.current;
+    if (!viewportEl) {
+      return;
+    }
+    const scrollableContentHeight = viewportEl.scrollHeight;
+    const scrollableContentWidth = viewportEl.scrollWidth;
+    const viewportHeight = viewportEl.clientHeight;
+    const viewportWidth = viewportEl.clientWidth;
+    const scrollTop = viewportEl.scrollTop;
+    const scrollLeft = viewportEl.scrollLeft;
+    const lastMeasuredViewportMetrics = lastMeasuredViewportMetricsRef.current;
+    const isFirstMeasurement = Number.isNaN(lastMeasuredViewportMetrics[0]);
+    lastMeasuredViewportMetrics[0] = viewportHeight;
+    lastMeasuredViewportMetrics[1] = scrollableContentHeight;
+    lastMeasuredViewportMetrics[2] = viewportWidth;
+    lastMeasuredViewportMetrics[3] = scrollableContentWidth;
+    if (isFirstMeasurement) {
+      setHasMeasuredScrollbar(true);
+    }
+    if (scrollableContentHeight === 0 || scrollableContentWidth === 0) {
+      return;
+    }
+    const nextHiddenState = getHiddenState(viewportEl);
+    const scrollbarYHidden = nextHiddenState.y;
+    const scrollbarXHidden = nextHiddenState.x;
+    const ratioX = viewportWidth / scrollableContentWidth;
+    const ratioY = viewportHeight / scrollableContentHeight;
+    const maxScrollLeft = Math.max(0, scrollableContentWidth - viewportWidth);
+    const maxScrollTop = Math.max(0, scrollableContentHeight - viewportHeight);
+    let scrollLeftFromStart = 0;
+    let scrollLeftFromEnd = 0;
+    if (!scrollbarXHidden) {
+      let rawScrollLeftFromStart = 0;
+      if (direction === 'rtl') {
+        rawScrollLeftFromStart = useValueChanged.clamp(-scrollLeft, 0, maxScrollLeft);
+      } else {
+        rawScrollLeftFromStart = useValueChanged.clamp(scrollLeft, 0, maxScrollLeft);
+      }
+      scrollLeftFromStart = normalizeScrollOffset(rawScrollLeftFromStart, maxScrollLeft);
+      scrollLeftFromEnd = maxScrollLeft - scrollLeftFromStart;
+    }
+    const rawScrollTopFromStart = !scrollbarYHidden ? useValueChanged.clamp(scrollTop, 0, maxScrollTop) : 0;
+    const scrollTopFromStart = !scrollbarYHidden ? normalizeScrollOffset(rawScrollTopFromStart, maxScrollTop) : 0;
+    const scrollTopFromEnd = !scrollbarYHidden ? maxScrollTop - scrollTopFromStart : 0;
+    const nextWidth = scrollbarXHidden ? 0 : viewportWidth;
+    const nextHeight = scrollbarYHidden ? 0 : viewportHeight;
+    let nextCornerWidth = 0;
+    let nextCornerHeight = 0;
+    if (!scrollbarXHidden && !scrollbarYHidden) {
+      nextCornerWidth = scrollbarYEl?.offsetWidth || 0;
+      nextCornerHeight = scrollbarXEl?.offsetHeight || 0;
+    }
+
+    // Only subtract corner size from scrollbar dimensions if the corner hasn't been sized yet.
+    // Once sized, the layout will already account for it.
+    const cornerNotYetSized = cornerSize.width === 0 && cornerSize.height === 0;
+    const cornerWidthOffset = cornerNotYetSized ? nextCornerWidth : 0;
+    const cornerHeightOffset = cornerNotYetSized ? nextCornerHeight : 0;
+    const scrollbarXOffset = getOffset(scrollbarXEl, 'padding', 'x');
+    const scrollbarYOffset = getOffset(scrollbarYEl, 'padding', 'y');
+    const thumbXOffset = getOffset(thumbXEl, 'margin', 'x');
+    const thumbYOffset = getOffset(thumbYEl, 'margin', 'y');
+    const idealNextWidth = nextWidth - scrollbarXOffset - thumbXOffset;
+    const idealNextHeight = nextHeight - scrollbarYOffset - thumbYOffset;
+    const maxNextWidth = scrollbarXEl ? Math.min(scrollbarXEl.offsetWidth - cornerWidthOffset, idealNextWidth) : idealNextWidth;
+    const maxNextHeight = scrollbarYEl ? Math.min(scrollbarYEl.offsetHeight - cornerHeightOffset, idealNextHeight) : idealNextHeight;
+    const clampedNextWidth = Math.max(MIN_THUMB_SIZE, maxNextWidth * ratioX);
+    const clampedNextHeight = Math.max(MIN_THUMB_SIZE, maxNextHeight * ratioY);
+    setThumbSize(prevSize => {
+      if (prevSize.height === clampedNextHeight && prevSize.width === clampedNextWidth) {
+        return prevSize;
+      }
+      return {
+        width: clampedNextWidth,
+        height: clampedNextHeight
+      };
+    });
+
+    // Handle Y (vertical) scroll
+    if (scrollbarYEl && thumbYEl) {
+      const maxThumbOffsetY = scrollbarYEl.offsetHeight - clampedNextHeight - scrollbarYOffset - thumbYOffset;
+      const scrollRangeY = scrollableContentHeight - viewportHeight;
+      const scrollRatioY = scrollRangeY === 0 ? 0 : scrollTop / scrollRangeY;
+
+      // In Safari, don't allow it to go negative or too far as `scrollTop` considers the rubber
+      // band effect.
+      const thumbOffsetY = Math.min(maxThumbOffsetY, Math.max(0, scrollRatioY * maxThumbOffsetY));
+      thumbYEl.style.transform = `translate3d(0,${thumbOffsetY}px,0)`;
+    }
+
+    // Handle X (horizontal) scroll
+    if (scrollbarXEl && thumbXEl) {
+      const maxThumbOffsetX = scrollbarXEl.offsetWidth - clampedNextWidth - scrollbarXOffset - thumbXOffset;
+      const scrollRangeX = scrollableContentWidth - viewportWidth;
+      const scrollRatioX = scrollRangeX === 0 ? 0 : scrollLeft / scrollRangeX;
+
+      // In Safari, don't allow it to go negative or too far as `scrollLeft` considers the rubber
+      // band effect.
+      const thumbOffsetX = direction === 'rtl' ? useValueChanged.clamp(scrollRatioX * maxThumbOffsetX, -maxThumbOffsetX, 0) : useValueChanged.clamp(scrollRatioX * maxThumbOffsetX, 0, maxThumbOffsetX);
+      thumbXEl.style.transform = `translate3d(${thumbOffsetX}px,0,0)`;
+    }
+    const overflowMetricsPx = [[ScrollAreaViewportCssVars.scrollAreaOverflowXStart, scrollLeftFromStart], [ScrollAreaViewportCssVars.scrollAreaOverflowXEnd, scrollLeftFromEnd], [ScrollAreaViewportCssVars.scrollAreaOverflowYStart, scrollTopFromStart], [ScrollAreaViewportCssVars.scrollAreaOverflowYEnd, scrollTopFromEnd]];
+    for (const [cssVar, value] of overflowMetricsPx) {
+      viewportEl.style.setProperty(cssVar, `${value}px`);
+    }
+    if (cornerEl) {
+      if (scrollbarXHidden || scrollbarYHidden) {
+        setCornerSize({
+          width: 0,
+          height: 0
+        });
+      } else if (!scrollbarXHidden && !scrollbarYHidden) {
+        setCornerSize({
+          width: nextCornerWidth,
+          height: nextCornerHeight
+        });
+      }
+    }
+    setHiddenState(prevState => mergeHiddenState(prevState, nextHiddenState));
+    const nextOverflowEdges = {
+      xStart: !scrollbarXHidden && scrollLeftFromStart > overflowEdgeThreshold.xStart,
+      xEnd: !scrollbarXHidden && scrollLeftFromEnd > overflowEdgeThreshold.xEnd,
+      yStart: !scrollbarYHidden && scrollTopFromStart > overflowEdgeThreshold.yStart,
+      yEnd: !scrollbarYHidden && scrollTopFromEnd > overflowEdgeThreshold.yEnd
+    };
+    setOverflowEdges(prev => {
+      if (prev.xStart === nextOverflowEdges.xStart && prev.xEnd === nextOverflowEdges.xEnd && prev.yStart === nextOverflowEdges.yStart && prev.yEnd === nextOverflowEdges.yEnd) {
+        return prev;
+      }
+      return nextOverflowEdges;
+    });
+  });
+  useValueChanged.useIsoLayoutEffect(() => {
+    if (!viewportRef.current) {
+      return undefined;
+    }
+    removeCSSVariableInheritance();
+    if (HAS_RESIZE_OBSERVER) {
+      return undefined;
+    }
+    return onVisible(viewportRef.current, () => {
+      computeThumbPosition();
+    });
+  }, [computeThumbPosition, viewportRef]);
+  useValueChanged.useIsoLayoutEffect(() => {
+    // Wait for scrollbar and thumb refs after hidden-state toggles, and refresh math on direction flips.
+    queueMicrotask(computeThumbPosition);
+  }, [computeThumbPosition, hiddenState, direction]);
+  useValueChanged.useIsoLayoutEffect(() => {
+    // `onMouseEnter` doesn't fire upon load, so we need to check if the viewport is already
+    // being hovered.
+    if (viewportRef.current?.matches(':hover')) {
+      setHovering(true);
+    }
+  }, [viewportRef, setHovering]);
+  React__namespace.useEffect(() => {
+    const viewport = viewportRef.current;
+    if (!HAS_RESIZE_OBSERVER || !viewport) {
+      return undefined;
+    }
+    let hasInitialized = false;
+    const ro = new ResizeObserver(() => {
+      // Avoid duplicate mount-time recompute when observer data matches what the mount
+      // scheduling pass already measured. If dimensions changed before the first observer
+      // delivery, keep the recompute so overflow transitions stay in sync.
+      if (!hasInitialized) {
+        hasInitialized = true;
+        const lastMeasuredViewportMetrics = lastMeasuredViewportMetricsRef.current;
+        if (lastMeasuredViewportMetrics[0] === viewport.clientHeight && lastMeasuredViewportMetrics[1] === viewport.scrollHeight && lastMeasuredViewportMetrics[2] === viewport.clientWidth && lastMeasuredViewportMetrics[3] === viewport.scrollWidth) {
+          return;
+        }
+      }
+      computeThumbPosition();
+    });
+    ro.observe(viewport);
+
+    // If there are animations in the viewport, wait for them to finish and then recompute the thumb position.
+    // This is necessary when the viewport contains a Dialog that is animating its popup on open
+    // and the popup is using a transform for the animation, which affects the size of the viewport.
+    // Without this, the thumb position will be incorrect until scrolling (i.e. if the scrollbar shows
+    // on hover, the thumb has an incorrect size).
+    // We assume the user is using `onOpenChangeComplete` to hide the scrollbar
+    // until animations complete because otherwise the scrollbar would show the thumb resizing mid-animation.
+    waitForAnimationsTimeout.start(0, () => {
+      const animations = viewport.getAnimations({
+        subtree: true
+      });
+      if (animations.length === 0) {
+        return;
+      }
+      Promise.allSettled(animations.map(animation => animation.finished)).then(computeThumbPosition).catch(() => {});
+    });
+    return () => {
+      ro.disconnect();
+      waitForAnimationsTimeout.clear();
+    };
+  }, [computeThumbPosition, viewportRef, waitForAnimationsTimeout]);
+  function handleUserInteraction() {
+    programmaticScrollRef.current = false;
+  }
+  const props = {
+    role: 'presentation',
+    ...(rootId && {
+      'data-id': `${rootId}-viewport`
+    }),
+    // https://accessibilityinsights.io/info-examples/web/scrollable-region-focusable/
+    // Keep non-scrollable viewports out of tab order.
+    tabIndex: hiddenState.x && hiddenState.y ? -1 : 0,
+    className: styleDisableScrollbar.className,
+    style: {
+      overflow: 'scroll'
+    },
+    onScroll() {
+      if (!viewportRef.current) {
+        return;
+      }
+      computeThumbPosition();
+      if (!programmaticScrollRef.current) {
+        handleScroll({
+          x: viewportRef.current.scrollLeft,
+          y: viewportRef.current.scrollTop
+        });
+      }
+
+      // Debounce the restoration of the programmatic flag so that it only
+      // flips back to `true` once scrolling has come to a rest. This ensures
+      // that momentum scrolling (where no further user-interaction events fire)
+      // is still treated as user-driven.
+      // 100 ms without scroll events ≈ scroll end
+      // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollend_event
+      scrollEndTimeout.start(100, () => {
+        programmaticScrollRef.current = true;
+      });
+    },
+    onWheel: handleUserInteraction,
+    onTouchMove: handleUserInteraction,
+    onPointerMove: handleUserInteraction,
+    onPointerEnter: handleUserInteraction,
+    onKeyDown: handleUserInteraction
+  };
+  const viewportState = React__namespace.useMemo(() => ({
+    scrolling: scrollingX || scrollingY,
+    hasOverflowX: !hiddenState.x,
+    hasOverflowY: !hiddenState.y,
+    overflowXStart: overflowEdges.xStart,
+    overflowXEnd: overflowEdges.xEnd,
+    overflowYStart: overflowEdges.yStart,
+    overflowYEnd: overflowEdges.yEnd,
+    cornerHidden: hiddenState.corner
+  }), [scrollingX, scrollingY, hiddenState.x, hiddenState.y, hiddenState.corner, overflowEdges]);
+  const element = useRenderElement.useRenderElement('div', componentProps, {
+    ref: [forwardedRef, viewportRef],
+    state: viewportState,
+    props: [props, elementProps],
+    stateAttributesMapping: scrollAreaStateAttributesMapping
+  });
+  const contextValue = React__namespace.useMemo(() => ({
+    computeThumbPosition
+  }), [computeThumbPosition]);
+  return /*#__PURE__*/jsxRuntime.jsx(ScrollAreaViewportContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") ScrollAreaViewport.displayName = "ScrollAreaViewport";
+function getHiddenState(viewport) {
+  const y = viewport.clientHeight >= viewport.scrollHeight;
+  const x = viewport.clientWidth >= viewport.scrollWidth;
+  return {
+    y,
+    x,
+    corner: y || x
+  };
+}
+function mergeHiddenState(prevState, nextState) {
+  if (prevState.y === nextState.y && prevState.x === nextState.x && prevState.corner === nextState.corner) {
+    return prevState;
+  }
+  return nextState;
+}
+
 exports.ARROW_DOWN = ARROW_DOWN$1;
 exports.ARROW_LEFT = ARROW_LEFT$1;
 exports.ARROW_RIGHT = ARROW_RIGHT$1;
 exports.ARROW_UP = ARROW_UP$1;
 exports.BASE_UI_SWIPE_IGNORE_SELECTOR = BASE_UI_SWIPE_IGNORE_SELECTOR;
-exports.CLICK_TRIGGER_IDENTIFIER = CLICK_TRIGGER_IDENTIFIER;
 exports.COMPOSITE_KEYS = COMPOSITE_KEYS;
 exports.CommonPopupDataAttributes = CommonPopupDataAttributes;
 exports.DISABLED_TRANSITIONS_STYLE = DISABLED_TRANSITIONS_STYLE;
@@ -5830,6 +6859,7 @@ exports.DrawerPopupDataAttributes = DrawerPopupDataAttributes;
 exports.DrawerPortal = DrawerPortal;
 exports.DrawerProviderContext = DrawerProviderContext;
 exports.DrawerRoot = DrawerRoot;
+exports.DrawerTrigger = DrawerTrigger;
 exports.DrawerViewportContext = DrawerViewportContext;
 exports.FloatingFocusManager = FloatingFocusManager;
 exports.FloatingNode = FloatingNode;
@@ -5843,6 +6873,9 @@ exports.PATIENT_CLICK_THRESHOLD = PATIENT_CLICK_THRESHOLD;
 exports.POPUP_COLLISION_AVOIDANCE = POPUP_COLLISION_AVOIDANCE;
 exports.PopupTriggerMap = PopupTriggerMap;
 exports.ReactStore = ReactStore;
+exports.ScrollAreaRoot = ScrollAreaRoot;
+exports.ScrollAreaRootCssVars = ScrollAreaRootCssVars;
+exports.ScrollAreaViewport = ScrollAreaViewport;
 exports.Store = Store;
 exports.TYPEABLE_SELECTOR = TYPEABLE_SELECTOR;
 exports.TYPEAHEAD_RESET_MS = TYPEAHEAD_RESET_MS;
@@ -5864,6 +6897,7 @@ exports.getMaxListIndex = getMaxListIndex;
 exports.getMinListIndex = getMinListIndex;
 exports.getNextTabbable = getNextTabbable;
 exports.getNodeChildren = getNodeChildren;
+exports.getOffset = getOffset;
 exports.getTabbableAfterElement = getTabbableAfterElement;
 exports.getTabbableBeforeElement = getTabbableBeforeElement;
 exports.getTarget = getTarget;
@@ -5879,9 +6913,12 @@ exports.matchesFocusVisible = matchesFocusVisible;
 exports.popupStateMapping = popupStateMapping;
 exports.popupStoreSelectors = popupStoreSelectors;
 exports.pressableTriggerOpenStateMapping = pressableTriggerOpenStateMapping;
+exports.scrollAreaStateAttributesMapping = scrollAreaStateAttributesMapping;
 exports.triggerOpenStateMapping = triggerOpenStateMapping;
+exports.useClick = useClick;
 exports.useDialogPortalContext = useDialogPortalContext;
 exports.useDialogRootContext = useDialogRootContext;
+exports.useDirection = useDirection;
 exports.useDismiss = useDismiss;
 exports.useDrawerProviderContext = useDrawerProviderContext;
 exports.useDrawerRootContext = useDrawerRootContext;
@@ -5895,6 +6932,8 @@ exports.useOnFirstRender = useOnFirstRender;
 exports.useOpenInteractionType = useOpenInteractionType;
 exports.useOpenStateTransitions = useOpenStateTransitions;
 exports.useRole = useRole;
+exports.useScrollAreaRootContext = useScrollAreaRootContext;
+exports.useScrollAreaViewportContext = useScrollAreaViewportContext;
 exports.useScrollLock = useScrollLock;
 exports.useStore = useStore;
 exports.useSyncedFloatingRootContext = useSyncedFloatingRootContext;