{"version":3,"sources":["../../registry/default/ui/scroll-area.tsx","../../../../node_modules/.pnpm/@babel+runtime@7.22.3/node_modules/@babel/runtime/helpers/esm/extends.js","../../../../node_modules/.pnpm/@babel+runtime@7.22.6/node_modules/@babel/runtime/helpers/esm/extends.js","../../../../node_modules/.pnpm/@radix-ui+react-compose-refs@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-compose-refs/dist/packages/react/compose-refs/src/composeRefs.tsx","../../../../node_modules/.pnpm/@radix-ui+react-slot@1.0.2_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-slot/dist/packages/react/slot/src/Slot.tsx","../../../../node_modules/.pnpm/@radix-ui+react-primitive@1.0.3_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18.2._c26rkpxnhr3o57o2cowwo23hui/node_modules/@radix-ui/react-primitive/dist/packages/react/primitive/src/Primitive.tsx","../../../../node_modules/.pnpm/@radix-ui+react-use-layout-effect@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-use-layout-effect/dist/packages/react/use-layout-effect/src/useLayoutEffect.tsx","../../../../node_modules/.pnpm/@radix-ui+react-presence@1.0.1_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18.2.0_react@18.2.0__react@18.2.0/node_modules/@radix-ui/react-presence/dist/packages/react/presence/src/useStateMachine.tsx","../../../../node_modules/.pnpm/@radix-ui+react-presence@1.0.1_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18.2.0_react@18.2.0__react@18.2.0/node_modules/@radix-ui/react-presence/dist/packages/react/presence/src/Presence.tsx","../../../../node_modules/.pnpm/@radix-ui+react-context@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-context/dist/packages/react/context/src/createContext.tsx","../../../../node_modules/.pnpm/@radix-ui+react-use-callback-ref@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-use-callback-ref/dist/packages/react/use-callback-ref/src/useCallbackRef.tsx","../../../../node_modules/.pnpm/@radix-ui+react-direction@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-direction/dist/packages/react/direction/src/Direction.tsx","../../../../node_modules/.pnpm/@radix-ui+number@1.0.1/node_modules/@radix-ui/number/dist/packages/core/number/src/number.ts","../../../../node_modules/.pnpm/@radix-ui+primitive@1.0.1/node_modules/@radix-ui/primitive/dist/packages/core/primitive/src/primitive.tsx","../../../../node_modules/.pnpm/@radix-ui+react-scroll-area@1.0.4_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18._qmcw4ege6e3bvympf6hfqeyrde/node_modules/@radix-ui/react-scroll-area/dist/packages/react/scroll-area/src/useStateMachine.ts","../../../../node_modules/.pnpm/@radix-ui+react-scroll-area@1.0.4_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18._qmcw4ege6e3bvympf6hfqeyrde/node_modules/@radix-ui/react-scroll-area/dist/packages/react/scroll-area/src/ScrollArea.tsx","../../lib/utils.ts"],"names":["scroll_area_exports","__export","ScrollArea","ScrollBar","__toCommonJS","React","_extends","target","i","source","key","setRef","ref","value","current","composeRefs","refs","node","forEach","useComposedRefs","Slot","props","forwardedRef","children","slotProps","childrenArray","toArray","slottable","find","isSlottable","newElement","newChildren","map","child","count","only","$9IrjX$createElement","$5e63c961fc1ce211$var$SlotClone","undefined","displayName","SlotClone","mergeProps","Slottable","$9IrjX$Fragment","type","childProps","overrideProps","propName","slotPropValue","childPropValue","test","args","filter","Boolean","join","NODES","Primitive","reduce","primitive","Node","asChild","primitiveProps","Comp","window","Symbol","for","$4q5Fq$createElement","useLayoutEffect","globalThis","document","useStateMachine","initialState","machine","state","event","nextState","Presence","present","presence","usePresence","isPresent","setNode","stylesRef","prevPresentRef","prevAnimationNameRef","send","mounted","UNMOUNT","ANIMATION_OUT","unmountSuspended","MOUNT","ANIMATION_END","unmounted","currentAnimationName","getAnimationName","styles","wasPresent","prevAnimationName","display","handleAnimationEnd","isCurrentAnimation","includes","animationName","ReactDOM","handleAnimationStart","addEventListener","removeEventListener","getComputedStyle","createContextScope","scopeName","createContextScopeDeps","defaultContexts","createContext","rootComponentName","defaultContext","BaseContext","index","length","Provider","scope","context","Context","Object","values","$3bkAK$createElement","useContext","consumerName","Error","createScope","scopeContexts","contexts","composeContextScopes","scopes","baseScope","scopeHooks","useScope","overrideScopes","nextScopes","currentScope","useCallbackRef","callback","callbackRef","_callbackRef$current","DirectionContext","useDirection","localDir","globalDir","clamp","min","max","Math","composeEventHandlers","originalEventHandler","ourEventHandler","checkForDefaultPrevented","defaultPrevented","SCROLL_AREA_NAME","createScrollAreaContext","createScrollAreaScope","ScrollAreaProvider","useScrollAreaContext","__scopeScrollArea","dir","scrollHideDelay","scrollAreaProps","scrollArea","setScrollArea","viewport","setViewport","content","setContent","scrollbarX","setScrollbarX","scrollbarY","setScrollbarY","cornerWidth","setCornerWidth","cornerHeight","setCornerHeight","scrollbarXEnabled","setScrollbarXEnabled","scrollbarYEnabled","setScrollbarYEnabled","composedRefs","direction","$fnFM9$createElement","$57acba87d6e25586$var$ScrollAreaProvider","$8927f6f2acc4f386$export$250ffa63cdc0d034","position","style","VIEWPORT_NAME","ScrollAreaViewport","viewportProps","onViewportChange","$fnFM9$Fragment","__html","overflowX","overflowY","onContentChange","minWidth","SCROLLBAR_NAME","ScrollAreaScrollbar","forceMount","scrollbarProps","onScrollbarXEnabledChange","onScrollbarYEnabledChange","isHorizontal","orientation","$57acba87d6e25586$var$ScrollAreaScrollbarHover","$57acba87d6e25586$var$ScrollAreaScrollbarScroll","$57acba87d6e25586$var$ScrollAreaScrollbarAuto","$57acba87d6e25586$var$ScrollAreaScrollbarVisible","ScrollAreaScrollbarHover","visible","setVisible","hideTimer","handlePointerEnter","clearTimeout","handlePointerLeave","setTimeout","$921a889cee6df7e8$export$99c2b779aa4e8b8b","ScrollAreaScrollbarScroll","debounceScrollEnd","useDebounceCallback","hidden","SCROLL","scrolling","SCROLL_END","POINTER_ENTER","interacting","POINTER_LEAVE","idle","HIDE","scrollDirection","prevScrollPos","handleScroll","scrollPos","onPointerEnter","onPointerLeave","ScrollAreaScrollbarAuto","handleResize","isOverflowX","offsetWidth","scrollWidth","isOverflowY","offsetHeight","scrollHeight","useResizeObserver","ScrollAreaScrollbarVisible","thumbRef","pointerOffsetRef","sizes","setSizes","scrollbar","size","paddingStart","paddingEnd","thumbRatio","getThumbRatio","commonProps","onSizesChange","hasThumb","onThumbChange","thumb","onThumbPointerUp","onThumbPointerDown","pointerPos","getScrollPosition","getScrollPositionFromPointer","$57acba87d6e25586$var$ScrollAreaScrollbarX","scrollLeft","offset","getThumbOffsetFromScroll","transform","$57acba87d6e25586$var$ScrollAreaScrollbarY","scrollTop","ScrollAreaScrollbarX","computedStyle","setComputedStyle","onScrollbarXChange","$57acba87d6e25586$var$ScrollAreaScrollbarImpl","bottom","left","right","getThumbSize","x","onDragScroll","maxScrollPos","deltaX","onWheelScroll","isScrollingWithinScrollbarBounds","preventDefault","clientWidth","toInt","paddingLeft","paddingRight","ScrollAreaScrollbarY","onScrollbarYChange","top","y","deltaY","clientHeight","paddingTop","paddingBottom","ScrollbarProvider","useScrollbarContext","ScrollAreaScrollbarImpl","onThumbPositionChange","onResize","setScrollbar","rectRef","prevWebkitUserSelectRef","handleWheelScroll","handleThumbPositionChange","handleDragScroll","clientX","clientY","handleWheel","element","contains","passive","$57acba87d6e25586$var$ScrollbarProvider","onPointerDown","button","mainPointer","setPointerCapture","pointerId","getBoundingClientRect","body","webkitUserSelect","onPointerMove","onPointerUp","hasPointerCapture","releasePointerCapture","THUMB_NAME","ScrollAreaThumb","thumbProps","scrollbarContext","$57acba87d6e25586$var$ScrollAreaThumbImpl","ScrollAreaThumbImpl","scrollAreaContext","composedRef","removeUnlinkedScrollListenerRef","listener","addUnlinkedScrollListener","width","height","onPointerDownCapture","thumbRect","CORNER_NAME","ScrollAreaCorner","hasBothScrollbarsVisible","$57acba87d6e25586$var$ScrollAreaCornerImpl","ScrollAreaCornerImpl","cornerProps","setWidth","setHeight","hasSize","_context$scrollbarX","onCornerHeightChange","_context$scrollbarY","onCornerWidthChange","parseInt","viewportSize","contentSize","ratio","isNaN","scrollbarPadding","thumbSize","pointerOffset","thumbSizePx","thumbCenter","thumbOffsetFromEnd","minPointerPos","maxPointerPos","scrollRange","linearScale","maxThumbPos","scrollClampRange","scrollWithoutMomentum","input","output","handler","prevPosition","rAF","loop","isHorizontalScroll","isVerticalScroll","requestAnimationFrame","cancelAnimationFrame","delay","handleCallback","debounceTimerRef","resizeObserver","ResizeObserver","observe","unobserve","Root","Viewport","Corner","import_clsx","import_tailwind_merge","cn","inputs","import_jsx_runtime","className","$57acba87d6e25586$export$be92b6f5f03c0fe9","$57acba87d6e25586$export$d5c6c08dc2d3ca7","$57acba87d6e25586$export$ac61190d9fc311a9","$57acba87d6e25586$export$2fabd85d0eba3c57","$57acba87d6e25586$export$9fba1154677d7cd2"],"mappings":"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","sourcesContent":["\"use client\"\n\nimport * as React from \"react\"\nimport * as ScrollAreaPrimitive from \"@radix-ui/react-scroll-area\"\n\nimport { cn } from \"@/lib/utils\"\n\nconst ScrollArea = React.forwardRef<\n  React.ElementRef<typeof ScrollAreaPrimitive.Root>,\n  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>\n>(({ className, children, ...props }, ref) => (\n  <ScrollAreaPrimitive.Root\n    ref={ref}\n    className={cn(\"relative overflow-hidden\", className)}\n    {...props}\n  >\n    <ScrollAreaPrimitive.Viewport className=\"h-full w-full rounded-[inherit]\">\n      {children}\n    </ScrollAreaPrimitive.Viewport>\n    <ScrollBar />\n    <ScrollAreaPrimitive.Corner />\n  </ScrollAreaPrimitive.Root>\n))\nScrollArea.displayName = ScrollAreaPrimitive.Root.displayName\n\nconst ScrollBar = React.forwardRef<\n  React.ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,\n  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>\n>(({ className, orientation = \"vertical\", ...props }, ref) => (\n  <ScrollAreaPrimitive.ScrollAreaScrollbar\n    ref={ref}\n    orientation={orientation}\n    className={cn(\n      \"flex touch-none select-none transition-colors\",\n      orientation === \"vertical\" &&\n        \"h-full w-2.5 border-l border-l-transparent p-[1px]\",\n      orientation === \"horizontal\" &&\n        \"h-2.5 flex-col border-t border-t-transparent p-[1px]\",\n      className\n    )}\n    {...props}\n  >\n    <ScrollAreaPrimitive.ScrollAreaThumb className=\"relative flex-1 rounded-full bg-border\" />\n  </ScrollAreaPrimitive.ScrollAreaScrollbar>\n))\nScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName\n\nexport { ScrollArea, ScrollBar }\n","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import * as React from 'react';\n\ntype PossibleRef<T> = React.Ref<T> | undefined;\n\n/**\n * Set a given ref to a given value\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */\nfunction setRef<T>(ref: PossibleRef<T>, value: T) {\n  if (typeof ref === 'function') {\n    ref(value);\n  } else if (ref !== null && ref !== undefined) {\n    (ref as React.MutableRefObject<T>).current = value;\n  }\n}\n\n/**\n * A utility to compose multiple refs together\n * Accepts callback refs and RefObject(s)\n */\nfunction composeRefs<T>(...refs: PossibleRef<T>[]) {\n  return (node: T) => refs.forEach((ref) => setRef(ref, node));\n}\n\n/**\n * A custom hook that composes multiple refs\n * Accepts callback refs and RefObject(s)\n */\nfunction useComposedRefs<T>(...refs: PossibleRef<T>[]) {\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  return React.useCallback(composeRefs(...refs), refs);\n}\n\nexport { composeRefs, useComposedRefs };\n","import * as React from 'react';\nimport { composeRefs } from '@radix-ui/react-compose-refs';\n\n/* -------------------------------------------------------------------------------------------------\n * Slot\n * -----------------------------------------------------------------------------------------------*/\n\ninterface SlotProps extends React.HTMLAttributes<HTMLElement> {\n  children?: React.ReactNode;\n}\n\nconst Slot = React.forwardRef<HTMLElement, SlotProps>((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  const childrenArray = React.Children.toArray(children);\n  const slottable = childrenArray.find(isSlottable);\n\n  if (slottable) {\n    // the new element to render is the one passed as a child of `Slottable`\n    const newElement = slottable.props.children as React.ReactNode;\n\n    const newChildren = childrenArray.map((child) => {\n      if (child === slottable) {\n        // because the new element will be the one rendered, we are only interested\n        // in grabbing its children (`newElement.props.children`)\n        if (React.Children.count(newElement) > 1) return React.Children.only(null);\n        return React.isValidElement(newElement)\n          ? (newElement.props.children as React.ReactNode)\n          : null;\n      } else {\n        return child;\n      }\n    });\n\n    return (\n      <SlotClone {...slotProps} ref={forwardedRef}>\n        {React.isValidElement(newElement)\n          ? React.cloneElement(newElement, undefined, newChildren)\n          : null}\n      </SlotClone>\n    );\n  }\n\n  return (\n    <SlotClone {...slotProps} ref={forwardedRef}>\n      {children}\n    </SlotClone>\n  );\n});\n\nSlot.displayName = 'Slot';\n\n/* -------------------------------------------------------------------------------------------------\n * SlotClone\n * -----------------------------------------------------------------------------------------------*/\n\ninterface SlotCloneProps {\n  children: React.ReactNode;\n}\n\nconst SlotClone = React.forwardRef<any, SlotCloneProps>((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n\n  if (React.isValidElement(children)) {\n    return React.cloneElement(children, {\n      ...mergeProps(slotProps, children.props),\n      ref: forwardedRef ? composeRefs(forwardedRef, (children as any).ref) : (children as any).ref,\n    });\n  }\n\n  return React.Children.count(children) > 1 ? React.Children.only(null) : null;\n});\n\nSlotClone.displayName = 'SlotClone';\n\n/* -------------------------------------------------------------------------------------------------\n * Slottable\n * -----------------------------------------------------------------------------------------------*/\n\nconst Slottable = ({ children }: { children: React.ReactNode }) => {\n  return <>{children}</>;\n};\n\n/* ---------------------------------------------------------------------------------------------- */\n\ntype AnyProps = Record<string, any>;\n\nfunction isSlottable(child: React.ReactNode): child is React.ReactElement {\n  return React.isValidElement(child) && child.type === Slottable;\n}\n\nfunction mergeProps(slotProps: AnyProps, childProps: AnyProps) {\n  // all child props should override\n  const overrideProps = { ...childProps };\n\n  for (const propName in childProps) {\n    const slotPropValue = slotProps[propName];\n    const childPropValue = childProps[propName];\n\n    const isHandler = /^on[A-Z]/.test(propName);\n    if (isHandler) {\n      // if the handler exists on both, we compose them\n      if (slotPropValue && childPropValue) {\n        overrideProps[propName] = (...args: unknown[]) => {\n          childPropValue(...args);\n          slotPropValue(...args);\n        };\n      }\n      // but if it exists only on the slot, we use only this one\n      else if (slotPropValue) {\n        overrideProps[propName] = slotPropValue;\n      }\n    }\n    // if it's `style`, we merge them\n    else if (propName === 'style') {\n      overrideProps[propName] = { ...slotPropValue, ...childPropValue };\n    } else if (propName === 'className') {\n      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(' ');\n    }\n  }\n\n  return { ...slotProps, ...overrideProps };\n}\n\nconst Root = Slot;\n\nexport {\n  Slot,\n  Slottable,\n  //\n  Root,\n};\nexport type { SlotProps };\n","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { Slot } from '@radix-ui/react-slot';\n\nconst NODES = [\n  'a',\n  'button',\n  'div',\n  'form',\n  'h2',\n  'h3',\n  'img',\n  'input',\n  'label',\n  'li',\n  'nav',\n  'ol',\n  'p',\n  'span',\n  'svg',\n  'ul',\n] as const;\n\n// Temporary while we await merge of this fix:\n// https://github.com/DefinitelyTyped/DefinitelyTyped/pull/55396\n// prettier-ignore\ntype PropsWithoutRef<P> = P extends any ? ('ref' extends keyof P ? Pick<P, Exclude<keyof P, 'ref'>> : P) : P;\ntype ComponentPropsWithoutRef<T extends React.ElementType> = PropsWithoutRef<\n  React.ComponentProps<T>\n>;\n\ntype Primitives = { [E in typeof NODES[number]]: PrimitiveForwardRefComponent<E> };\ntype PrimitivePropsWithRef<E extends React.ElementType> = React.ComponentPropsWithRef<E> & {\n  asChild?: boolean;\n};\n\ninterface PrimitiveForwardRefComponent<E extends React.ElementType>\n  extends React.ForwardRefExoticComponent<PrimitivePropsWithRef<E>> {}\n\n/* -------------------------------------------------------------------------------------------------\n * Primitive\n * -----------------------------------------------------------------------------------------------*/\n\nconst Primitive = NODES.reduce((primitive, node) => {\n  const Node = React.forwardRef((props: PrimitivePropsWithRef<typeof node>, forwardedRef: any) => {\n    const { asChild, ...primitiveProps } = props;\n    const Comp: any = asChild ? Slot : node;\n\n    React.useEffect(() => {\n      (window as any)[Symbol.for('radix-ui')] = true;\n    }, []);\n\n    return <Comp {...primitiveProps} ref={forwardedRef} />;\n  });\n\n  Node.displayName = `Primitive.${node}`;\n\n  return { ...primitive, [node]: Node };\n}, {} as Primitives);\n\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * Flush custom event dispatch\n * https://github.com/radix-ui/primitives/pull/1378\n *\n * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.\n *\n * Internally, React prioritises events in the following order:\n *  - discrete\n *  - continuous\n *  - default\n *\n * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L294-L350\n *\n * `discrete` is an  important distinction as updates within these events are applied immediately.\n * React however, is not able to infer the priority of custom event types due to how they are detected internally.\n * Because of this, it's possible for updates from custom events to be unexpectedly batched when\n * dispatched by another `discrete` event.\n *\n * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.\n * This utility should be used when dispatching a custom event from within another `discrete` event, this utility\n * is not nessesary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.\n * For example:\n *\n * dispatching a known click 👎\n * target.dispatchEvent(new Event(‘click’))\n *\n * dispatching a custom type within a non-discrete event 👎\n * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}\n *\n * dispatching a custom type within a `discrete` event 👍\n * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}\n *\n * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use\n * this utility with them. This is because it's possible for those handlers to be called implicitly during render\n * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.\n */\n\nfunction dispatchDiscreteCustomEvent<E extends CustomEvent>(target: E['target'], event: E) {\n  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = Primitive;\n\nexport {\n  Primitive,\n  //\n  Root,\n  //\n  dispatchDiscreteCustomEvent,\n};\nexport type { ComponentPropsWithoutRef, PrimitivePropsWithRef };\n","import * as React from 'react';\n\n/**\n * On the server, React emits a warning when calling `useLayoutEffect`.\n * This is because neither `useLayoutEffect` nor `useEffect` run on the server.\n * We use this safe version which suppresses the warning by replacing it with a noop on the server.\n *\n * See: https://reactjs.org/docs/hooks-reference.html#uselayouteffect\n */\nconst useLayoutEffect = Boolean(globalThis?.document) ? React.useLayoutEffect : () => {};\n\nexport { useLayoutEffect };\n","import * as React from 'react';\n\ntype Machine<S> = { [k: string]: { [k: string]: S } };\ntype MachineState<T> = keyof T;\ntype MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;\n\n// 🤯 https://fettblog.eu/typescript-union-to-intersection/\ntype UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any\n  ? R\n  : never;\n\nexport function useStateMachine<M>(\n  initialState: MachineState<M>,\n  machine: M & Machine<MachineState<M>>\n) {\n  return React.useReducer((state: MachineState<M>, event: MachineEvent<M>): MachineState<M> => {\n    const nextState = (machine[state] as any)[event];\n    return nextState ?? state;\n  }, initialState);\n}\n","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\nimport { useStateMachine } from './useStateMachine';\n\ninterface PresenceProps {\n  children: React.ReactElement | ((props: { present: boolean }) => React.ReactElement);\n  present: boolean;\n}\n\nconst Presence: React.FC<PresenceProps> = (props) => {\n  const { present, children } = props;\n  const presence = usePresence(present);\n\n  const child = (\n    typeof children === 'function'\n      ? children({ present: presence.isPresent })\n      : React.Children.only(children)\n  ) as React.ReactElement;\n\n  const ref = useComposedRefs(presence.ref, (child as any).ref);\n  const forceMount = typeof children === 'function';\n  return forceMount || presence.isPresent ? React.cloneElement(child, { ref }) : null;\n};\n\nPresence.displayName = 'Presence';\n\n/* -------------------------------------------------------------------------------------------------\n * usePresence\n * -----------------------------------------------------------------------------------------------*/\n\nfunction usePresence(present: boolean) {\n  const [node, setNode] = React.useState<HTMLElement>();\n  const stylesRef = React.useRef<CSSStyleDeclaration>({} as any);\n  const prevPresentRef = React.useRef(present);\n  const prevAnimationNameRef = React.useRef<string>('none');\n  const initialState = present ? 'mounted' : 'unmounted';\n  const [state, send] = useStateMachine(initialState, {\n    mounted: {\n      UNMOUNT: 'unmounted',\n      ANIMATION_OUT: 'unmountSuspended',\n    },\n    unmountSuspended: {\n      MOUNT: 'mounted',\n      ANIMATION_END: 'unmounted',\n    },\n    unmounted: {\n      MOUNT: 'mounted',\n    },\n  });\n\n  React.useEffect(() => {\n    const currentAnimationName = getAnimationName(stylesRef.current);\n    prevAnimationNameRef.current = state === 'mounted' ? currentAnimationName : 'none';\n  }, [state]);\n\n  useLayoutEffect(() => {\n    const styles = stylesRef.current;\n    const wasPresent = prevPresentRef.current;\n    const hasPresentChanged = wasPresent !== present;\n\n    if (hasPresentChanged) {\n      const prevAnimationName = prevAnimationNameRef.current;\n      const currentAnimationName = getAnimationName(styles);\n\n      if (present) {\n        send('MOUNT');\n      } else if (currentAnimationName === 'none' || styles?.display === 'none') {\n        // If there is no exit animation or the element is hidden, animations won't run\n        // so we unmount instantly\n        send('UNMOUNT');\n      } else {\n        /**\n         * When `present` changes to `false`, we check changes to animation-name to\n         * determine whether an animation has started. We chose this approach (reading\n         * computed styles) because there is no `animationrun` event and `animationstart`\n         * fires after `animation-delay` has expired which would be too late.\n         */\n        const isAnimating = prevAnimationName !== currentAnimationName;\n\n        if (wasPresent && isAnimating) {\n          send('ANIMATION_OUT');\n        } else {\n          send('UNMOUNT');\n        }\n      }\n\n      prevPresentRef.current = present;\n    }\n  }, [present, send]);\n\n  useLayoutEffect(() => {\n    if (node) {\n      /**\n       * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`\n       * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we\n       * make sure we only trigger ANIMATION_END for the currently active animation.\n       */\n      const handleAnimationEnd = (event: AnimationEvent) => {\n        const currentAnimationName = getAnimationName(stylesRef.current);\n        const isCurrentAnimation = currentAnimationName.includes(event.animationName);\n        if (event.target === node && isCurrentAnimation) {\n          // With React 18 concurrency this update is applied\n          // a frame after the animation ends, creating a flash of visible content.\n          // By manually flushing we ensure they sync within a frame, removing the flash.\n          ReactDOM.flushSync(() => send('ANIMATION_END'));\n        }\n      };\n      const handleAnimationStart = (event: AnimationEvent) => {\n        if (event.target === node) {\n          // if animation occurred, store its name as the previous animation.\n          prevAnimationNameRef.current = getAnimationName(stylesRef.current);\n        }\n      };\n      node.addEventListener('animationstart', handleAnimationStart);\n      node.addEventListener('animationcancel', handleAnimationEnd);\n      node.addEventListener('animationend', handleAnimationEnd);\n      return () => {\n        node.removeEventListener('animationstart', handleAnimationStart);\n        node.removeEventListener('animationcancel', handleAnimationEnd);\n        node.removeEventListener('animationend', handleAnimationEnd);\n      };\n    } else {\n      // Transition to the unmounted state if the node is removed prematurely.\n      // We avoid doing so during cleanup as the node may change but still exist.\n      send('ANIMATION_END');\n    }\n  }, [node, send]);\n\n  return {\n    isPresent: ['mounted', 'unmountSuspended'].includes(state),\n    ref: React.useCallback((node: HTMLElement) => {\n      if (node) stylesRef.current = getComputedStyle(node);\n      setNode(node);\n    }, []),\n  };\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction getAnimationName(styles?: CSSStyleDeclaration) {\n  return styles?.animationName || 'none';\n}\n\nexport { Presence };\nexport type { PresenceProps };\n","import * as React from 'react';\n\nfunction createContext<ContextValueType extends object | null>(\n  rootComponentName: string,\n  defaultContext?: ContextValueType\n) {\n  const Context = React.createContext<ContextValueType | undefined>(defaultContext);\n\n  function Provider(props: ContextValueType & { children: React.ReactNode }) {\n    const { children, ...context } = props;\n    // Only re-memoize when prop values change\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    const value = React.useMemo(() => context, Object.values(context)) as ContextValueType;\n    return <Context.Provider value={value}>{children}</Context.Provider>;\n  }\n\n  function useContext(consumerName: string) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== undefined) return defaultContext;\n    // if a defaultContext wasn't specified, it's a required context.\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n\n  Provider.displayName = rootComponentName + 'Provider';\n  return [Provider, useContext] as const;\n}\n\n/* -------------------------------------------------------------------------------------------------\n * createContextScope\n * -----------------------------------------------------------------------------------------------*/\n\ntype Scope<C = any> = { [scopeName: string]: React.Context<C>[] } | undefined;\ntype ScopeHook = (scope: Scope) => { [__scopeProp: string]: Scope };\ninterface CreateScope {\n  scopeName: string;\n  (): ScopeHook;\n}\n\nfunction createContextScope(scopeName: string, createContextScopeDeps: CreateScope[] = []) {\n  let defaultContexts: any[] = [];\n\n  /* -----------------------------------------------------------------------------------------------\n   * createContext\n   * ---------------------------------------------------------------------------------------------*/\n\n  function createContext<ContextValueType extends object | null>(\n    rootComponentName: string,\n    defaultContext?: ContextValueType\n  ) {\n    const BaseContext = React.createContext<ContextValueType | undefined>(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n\n    function Provider(\n      props: ContextValueType & { scope: Scope<ContextValueType>; children: React.ReactNode }\n    ) {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName][index] || BaseContext;\n      // Only re-memoize when prop values change\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      const value = React.useMemo(() => context, Object.values(context)) as ContextValueType;\n      return <Context.Provider value={value}>{children}</Context.Provider>;\n    }\n\n    function useContext(consumerName: string, scope: Scope<ContextValueType | undefined>) {\n      const Context = scope?.[scopeName][index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== undefined) return defaultContext;\n      // if a defaultContext wasn't specified, it's a required context.\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n\n    Provider.displayName = rootComponentName + 'Provider';\n    return [Provider, useContext] as const;\n  }\n\n  /* -----------------------------------------------------------------------------------------------\n   * createScope\n   * ---------------------------------------------------------------------------------------------*/\n\n  const createScope: CreateScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope: Scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n\n  createScope.scopeName = scopeName;\n  return [createContext, composeContextScopes(createScope, ...createContextScopeDeps)] as const;\n}\n\n/* -------------------------------------------------------------------------------------------------\n * composeContextScopes\n * -----------------------------------------------------------------------------------------------*/\n\nfunction composeContextScopes(...scopes: CreateScope[]) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n\n  const createScope: CreateScope = () => {\n    const scopeHooks = scopes.map((createScope) => ({\n      useScope: createScope(),\n      scopeName: createScope.scopeName,\n    }));\n\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes, { useScope, scopeName }) => {\n        // We are calling a hook inside a callback which React warns against to avoid inconsistent\n        // renders, however, scoping doesn't have render side effects so we ignore the rule.\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes, ...currentScope };\n      }, {});\n\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nexport { createContext, createContextScope };\nexport type { CreateScope, Scope };\n","import * as React from 'react';\n\n/**\n * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a\n * prop or avoid re-executing effects when passed as a dependency\n */\nfunction useCallbackRef<T extends (...args: any[]) => any>(callback: T | undefined): T {\n  const callbackRef = React.useRef(callback);\n\n  React.useEffect(() => {\n    callbackRef.current = callback;\n  });\n\n  // https://github.com/facebook/react/issues/19240\n  return React.useMemo(() => ((...args) => callbackRef.current?.(...args)) as T, []);\n}\n\nexport { useCallbackRef };\n","import * as React from 'react';\n\ntype Direction = 'ltr' | 'rtl';\nconst DirectionContext = React.createContext<Direction | undefined>(undefined);\n\n/* -------------------------------------------------------------------------------------------------\n * Direction\n * -----------------------------------------------------------------------------------------------*/\n\ninterface DirectionProviderProps {\n  children?: React.ReactNode;\n  dir: Direction;\n}\nconst DirectionProvider: React.FC<DirectionProviderProps> = (props) => {\n  const { dir, children } = props;\n  return <DirectionContext.Provider value={dir}>{children}</DirectionContext.Provider>;\n};\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction useDirection(localDir?: Direction) {\n  const globalDir = React.useContext(DirectionContext);\n  return localDir || globalDir || 'ltr';\n}\n\nconst Provider = DirectionProvider;\n\nexport {\n  useDirection,\n  //\n  Provider,\n  //\n  DirectionProvider,\n};\n","function clamp(value: number, [min, max]: [number, number]): number {\n  return Math.min(max, Math.max(min, value));\n}\n\nexport { clamp };\n","function composeEventHandlers<E>(\n  originalEventHandler?: (event: E) => void,\n  ourEventHandler?: (event: E) => void,\n  { checkForDefaultPrevented = true } = {}\n) {\n  return function handleEvent(event: E) {\n    originalEventHandler?.(event);\n\n    if (checkForDefaultPrevented === false || !((event as unknown) as Event).defaultPrevented) {\n      return ourEventHandler?.(event);\n    }\n  };\n}\n\nexport { composeEventHandlers };\n","import * as React from 'react';\n\ntype Machine<S> = { [k: string]: { [k: string]: S } };\ntype MachineState<T> = keyof T;\ntype MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;\n\n// 🤯 https://fettblog.eu/typescript-union-to-intersection/\ntype UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any\n  ? R\n  : never;\n\nexport function useStateMachine<M>(\n  initialState: MachineState<M>,\n  machine: M & Machine<MachineState<M>>\n) {\n  return React.useReducer((state: MachineState<M>, event: MachineEvent<M>): MachineState<M> => {\n    const nextState = (machine[state] as any)[event];\n    return nextState ?? state;\n  }, initialState);\n}\n","/// <reference types=\"resize-observer-browser\" />\n\nimport * as React from 'react';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { Presence } from '@radix-ui/react-presence';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\nimport { useDirection } from '@radix-ui/react-direction';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\nimport { clamp } from '@radix-ui/number';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { useStateMachine } from './useStateMachine';\n\nimport type * as Radix from '@radix-ui/react-primitive';\nimport type { Scope } from '@radix-ui/react-context';\n\ntype Direction = 'ltr' | 'rtl';\ntype Sizes = {\n  content: number;\n  viewport: number;\n  scrollbar: {\n    size: number;\n    paddingStart: number;\n    paddingEnd: number;\n  };\n};\n\n/* -------------------------------------------------------------------------------------------------\n * ScrollArea\n * -----------------------------------------------------------------------------------------------*/\n\nconst SCROLL_AREA_NAME = 'ScrollArea';\n\ntype ScopedProps<P> = P & { __scopeScrollArea?: Scope };\nconst [createScrollAreaContext, createScrollAreaScope] = createContextScope(SCROLL_AREA_NAME);\n\ntype ScrollAreaContextValue = {\n  type: 'auto' | 'always' | 'scroll' | 'hover';\n  dir: Direction;\n  scrollHideDelay: number;\n  scrollArea: ScrollAreaElement | null;\n  viewport: ScrollAreaViewportElement | null;\n  onViewportChange(viewport: ScrollAreaViewportElement | null): void;\n  content: HTMLDivElement | null;\n  onContentChange(content: HTMLDivElement): void;\n  scrollbarX: ScrollAreaScrollbarElement | null;\n  onScrollbarXChange(scrollbar: ScrollAreaScrollbarElement | null): void;\n  scrollbarXEnabled: boolean;\n  onScrollbarXEnabledChange(rendered: boolean): void;\n  scrollbarY: ScrollAreaScrollbarElement | null;\n  onScrollbarYChange(scrollbar: ScrollAreaScrollbarElement | null): void;\n  scrollbarYEnabled: boolean;\n  onScrollbarYEnabledChange(rendered: boolean): void;\n  onCornerWidthChange(width: number): void;\n  onCornerHeightChange(height: number): void;\n};\n\nconst [ScrollAreaProvider, useScrollAreaContext] =\n  createScrollAreaContext<ScrollAreaContextValue>(SCROLL_AREA_NAME);\n\ntype ScrollAreaElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = Radix.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface ScrollAreaProps extends PrimitiveDivProps {\n  type?: ScrollAreaContextValue['type'];\n  dir?: ScrollAreaContextValue['dir'];\n  scrollHideDelay?: number;\n}\n\nconst ScrollArea = React.forwardRef<ScrollAreaElement, ScrollAreaProps>(\n  (props: ScopedProps<ScrollAreaProps>, forwardedRef) => {\n    const {\n      __scopeScrollArea,\n      type = 'hover',\n      dir,\n      scrollHideDelay = 600,\n      ...scrollAreaProps\n    } = props;\n    const [scrollArea, setScrollArea] = React.useState<ScrollAreaElement | null>(null);\n    const [viewport, setViewport] = React.useState<ScrollAreaViewportElement | null>(null);\n    const [content, setContent] = React.useState<HTMLDivElement | null>(null);\n    const [scrollbarX, setScrollbarX] = React.useState<ScrollAreaScrollbarElement | null>(null);\n    const [scrollbarY, setScrollbarY] = React.useState<ScrollAreaScrollbarElement | null>(null);\n    const [cornerWidth, setCornerWidth] = React.useState(0);\n    const [cornerHeight, setCornerHeight] = React.useState(0);\n    const [scrollbarXEnabled, setScrollbarXEnabled] = React.useState(false);\n    const [scrollbarYEnabled, setScrollbarYEnabled] = React.useState(false);\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setScrollArea(node));\n    const direction = useDirection(dir);\n\n    return (\n      <ScrollAreaProvider\n        scope={__scopeScrollArea}\n        type={type}\n        dir={direction}\n        scrollHideDelay={scrollHideDelay}\n        scrollArea={scrollArea}\n        viewport={viewport}\n        onViewportChange={setViewport}\n        content={content}\n        onContentChange={setContent}\n        scrollbarX={scrollbarX}\n        onScrollbarXChange={setScrollbarX}\n        scrollbarXEnabled={scrollbarXEnabled}\n        onScrollbarXEnabledChange={setScrollbarXEnabled}\n        scrollbarY={scrollbarY}\n        onScrollbarYChange={setScrollbarY}\n        scrollbarYEnabled={scrollbarYEnabled}\n        onScrollbarYEnabledChange={setScrollbarYEnabled}\n        onCornerWidthChange={setCornerWidth}\n        onCornerHeightChange={setCornerHeight}\n      >\n        <Primitive.div\n          dir={direction}\n          {...scrollAreaProps}\n          ref={composedRefs}\n          style={{\n            position: 'relative',\n            // Pass corner sizes as CSS vars to reduce re-renders of context consumers\n            ['--radix-scroll-area-corner-width' as any]: cornerWidth + 'px',\n            ['--radix-scroll-area-corner-height' as any]: cornerHeight + 'px',\n            ...props.style,\n          }}\n        />\n      </ScrollAreaProvider>\n    );\n  }\n);\n\nScrollArea.displayName = SCROLL_AREA_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaViewport\n * -----------------------------------------------------------------------------------------------*/\n\nconst VIEWPORT_NAME = 'ScrollAreaViewport';\n\ntype ScrollAreaViewportElement = React.ElementRef<typeof Primitive.div>;\ninterface ScrollAreaViewportProps extends PrimitiveDivProps {}\n\nconst ScrollAreaViewport = React.forwardRef<ScrollAreaViewportElement, ScrollAreaViewportProps>(\n  (props: ScopedProps<ScrollAreaViewportProps>, forwardedRef) => {\n    const { __scopeScrollArea, children, ...viewportProps } = props;\n    const context = useScrollAreaContext(VIEWPORT_NAME, __scopeScrollArea);\n    const ref = React.useRef<ScrollAreaViewportElement>(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);\n    return (\n      <>\n        {/* Hide scrollbars cross-browser and enable momentum scroll for touch devices */}\n        <style\n          dangerouslySetInnerHTML={{\n            __html: `[data-radix-scroll-area-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-scroll-area-viewport]::-webkit-scrollbar{display:none}`,\n          }}\n        />\n        <Primitive.div\n          data-radix-scroll-area-viewport=\"\"\n          {...viewportProps}\n          ref={composedRefs}\n          style={{\n            /**\n             * We don't support `visible` because the intention is to have at least one scrollbar\n             * if this component is used and `visible` will behave like `auto` in that case\n             * https://developer.mozilla.org/en-US/docs/Web/CSS/overflowed#description\n             *\n             * We don't handle `auto` because the intention is for the native implementation\n             * to be hidden if using this component. We just want to ensure the node is scrollable\n             * so could have used either `scroll` or `auto` here. We picked `scroll` to prevent\n             * the browser from having to work out whether to render native scrollbars or not,\n             * we tell it to with the intention of hiding them in CSS.\n             */\n            overflowX: context.scrollbarXEnabled ? 'scroll' : 'hidden',\n            overflowY: context.scrollbarYEnabled ? 'scroll' : 'hidden',\n            ...props.style,\n          }}\n        >\n          {/**\n           * `display: table` ensures our content div will match the size of its children in both\n           * horizontal and vertical axis so we can determine if scroll width/height changed and\n           * recalculate thumb sizes. This doesn't account for children with *percentage*\n           * widths that change. We'll wait to see what use-cases consumers come up with there\n           * before trying to resolve it.\n           */}\n          <div ref={context.onContentChange} style={{ minWidth: '100%', display: 'table' }}>\n            {children}\n          </div>\n        </Primitive.div>\n      </>\n    );\n  }\n);\n\nScrollAreaViewport.displayName = VIEWPORT_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaScrollbar\n * -----------------------------------------------------------------------------------------------*/\n\nconst SCROLLBAR_NAME = 'ScrollAreaScrollbar';\n\ntype ScrollAreaScrollbarElement = ScrollAreaScrollbarVisibleElement;\ninterface ScrollAreaScrollbarProps extends ScrollAreaScrollbarVisibleProps {\n  forceMount?: true;\n}\n\nconst ScrollAreaScrollbar = React.forwardRef<ScrollAreaScrollbarElement, ScrollAreaScrollbarProps>(\n  (props: ScopedProps<ScrollAreaScrollbarProps>, forwardedRef) => {\n    const { forceMount, ...scrollbarProps } = props;\n    const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n    const { onScrollbarXEnabledChange, onScrollbarYEnabledChange } = context;\n    const isHorizontal = props.orientation === 'horizontal';\n\n    React.useEffect(() => {\n      isHorizontal ? onScrollbarXEnabledChange(true) : onScrollbarYEnabledChange(true);\n      return () => {\n        isHorizontal ? onScrollbarXEnabledChange(false) : onScrollbarYEnabledChange(false);\n      };\n    }, [isHorizontal, onScrollbarXEnabledChange, onScrollbarYEnabledChange]);\n\n    return context.type === 'hover' ? (\n      <ScrollAreaScrollbarHover {...scrollbarProps} ref={forwardedRef} forceMount={forceMount} />\n    ) : context.type === 'scroll' ? (\n      <ScrollAreaScrollbarScroll {...scrollbarProps} ref={forwardedRef} forceMount={forceMount} />\n    ) : context.type === 'auto' ? (\n      <ScrollAreaScrollbarAuto {...scrollbarProps} ref={forwardedRef} forceMount={forceMount} />\n    ) : context.type === 'always' ? (\n      <ScrollAreaScrollbarVisible {...scrollbarProps} ref={forwardedRef} />\n    ) : null;\n  }\n);\n\nScrollAreaScrollbar.displayName = SCROLLBAR_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype ScrollAreaScrollbarHoverElement = ScrollAreaScrollbarAutoElement;\ninterface ScrollAreaScrollbarHoverProps extends ScrollAreaScrollbarAutoProps {\n  forceMount?: true;\n}\n\nconst ScrollAreaScrollbarHover = React.forwardRef<\n  ScrollAreaScrollbarHoverElement,\n  ScrollAreaScrollbarHoverProps\n>((props: ScopedProps<ScrollAreaScrollbarHoverProps>, forwardedRef) => {\n  const { forceMount, ...scrollbarProps } = props;\n  const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n  const [visible, setVisible] = React.useState(false);\n\n  React.useEffect(() => {\n    const scrollArea = context.scrollArea;\n    let hideTimer = 0;\n    if (scrollArea) {\n      const handlePointerEnter = () => {\n        window.clearTimeout(hideTimer);\n        setVisible(true);\n      };\n      const handlePointerLeave = () => {\n        hideTimer = window.setTimeout(() => setVisible(false), context.scrollHideDelay);\n      };\n      scrollArea.addEventListener('pointerenter', handlePointerEnter);\n      scrollArea.addEventListener('pointerleave', handlePointerLeave);\n      return () => {\n        window.clearTimeout(hideTimer);\n        scrollArea.removeEventListener('pointerenter', handlePointerEnter);\n        scrollArea.removeEventListener('pointerleave', handlePointerLeave);\n      };\n    }\n  }, [context.scrollArea, context.scrollHideDelay]);\n\n  return (\n    <Presence present={forceMount || visible}>\n      <ScrollAreaScrollbarAuto\n        data-state={visible ? 'visible' : 'hidden'}\n        {...scrollbarProps}\n        ref={forwardedRef}\n      />\n    </Presence>\n  );\n});\n\ntype ScrollAreaScrollbarScrollElement = ScrollAreaScrollbarVisibleElement;\ninterface ScrollAreaScrollbarScrollProps extends ScrollAreaScrollbarVisibleProps {\n  forceMount?: true;\n}\n\nconst ScrollAreaScrollbarScroll = React.forwardRef<\n  ScrollAreaScrollbarScrollElement,\n  ScrollAreaScrollbarScrollProps\n>((props: ScopedProps<ScrollAreaScrollbarScrollProps>, forwardedRef) => {\n  const { forceMount, ...scrollbarProps } = props;\n  const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n  const isHorizontal = props.orientation === 'horizontal';\n  const debounceScrollEnd = useDebounceCallback(() => send('SCROLL_END'), 100);\n  const [state, send] = useStateMachine('hidden', {\n    hidden: {\n      SCROLL: 'scrolling',\n    },\n    scrolling: {\n      SCROLL_END: 'idle',\n      POINTER_ENTER: 'interacting',\n    },\n    interacting: {\n      SCROLL: 'interacting',\n      POINTER_LEAVE: 'idle',\n    },\n    idle: {\n      HIDE: 'hidden',\n      SCROLL: 'scrolling',\n      POINTER_ENTER: 'interacting',\n    },\n  });\n\n  React.useEffect(() => {\n    if (state === 'idle') {\n      const hideTimer = window.setTimeout(() => send('HIDE'), context.scrollHideDelay);\n      return () => window.clearTimeout(hideTimer);\n    }\n  }, [state, context.scrollHideDelay, send]);\n\n  React.useEffect(() => {\n    const viewport = context.viewport;\n    const scrollDirection = isHorizontal ? 'scrollLeft' : 'scrollTop';\n\n    if (viewport) {\n      let prevScrollPos = viewport[scrollDirection];\n      const handleScroll = () => {\n        const scrollPos = viewport[scrollDirection];\n        const hasScrollInDirectionChanged = prevScrollPos !== scrollPos;\n        if (hasScrollInDirectionChanged) {\n          send('SCROLL');\n          debounceScrollEnd();\n        }\n        prevScrollPos = scrollPos;\n      };\n      viewport.addEventListener('scroll', handleScroll);\n      return () => viewport.removeEventListener('scroll', handleScroll);\n    }\n  }, [context.viewport, isHorizontal, send, debounceScrollEnd]);\n\n  return (\n    <Presence present={forceMount || state !== 'hidden'}>\n      <ScrollAreaScrollbarVisible\n        data-state={state === 'hidden' ? 'hidden' : 'visible'}\n        {...scrollbarProps}\n        ref={forwardedRef}\n        onPointerEnter={composeEventHandlers(props.onPointerEnter, () => send('POINTER_ENTER'))}\n        onPointerLeave={composeEventHandlers(props.onPointerLeave, () => send('POINTER_LEAVE'))}\n      />\n    </Presence>\n  );\n});\n\ntype ScrollAreaScrollbarAutoElement = ScrollAreaScrollbarVisibleElement;\ninterface ScrollAreaScrollbarAutoProps extends ScrollAreaScrollbarVisibleProps {\n  forceMount?: true;\n}\n\nconst ScrollAreaScrollbarAuto = React.forwardRef<\n  ScrollAreaScrollbarAutoElement,\n  ScrollAreaScrollbarAutoProps\n>((props: ScopedProps<ScrollAreaScrollbarAutoProps>, forwardedRef) => {\n  const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n  const { forceMount, ...scrollbarProps } = props;\n  const [visible, setVisible] = React.useState(false);\n  const isHorizontal = props.orientation === 'horizontal';\n  const handleResize = useDebounceCallback(() => {\n    if (context.viewport) {\n      const isOverflowX = context.viewport.offsetWidth < context.viewport.scrollWidth;\n      const isOverflowY = context.viewport.offsetHeight < context.viewport.scrollHeight;\n      setVisible(isHorizontal ? isOverflowX : isOverflowY);\n    }\n  }, 10);\n\n  useResizeObserver(context.viewport, handleResize);\n  useResizeObserver(context.content, handleResize);\n\n  return (\n    <Presence present={forceMount || visible}>\n      <ScrollAreaScrollbarVisible\n        data-state={visible ? 'visible' : 'hidden'}\n        {...scrollbarProps}\n        ref={forwardedRef}\n      />\n    </Presence>\n  );\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype ScrollAreaScrollbarVisibleElement = ScrollAreaScrollbarAxisElement;\ninterface ScrollAreaScrollbarVisibleProps\n  extends Omit<ScrollAreaScrollbarAxisProps, keyof ScrollAreaScrollbarAxisPrivateProps> {\n  orientation?: 'horizontal' | 'vertical';\n}\n\nconst ScrollAreaScrollbarVisible = React.forwardRef<\n  ScrollAreaScrollbarVisibleElement,\n  ScrollAreaScrollbarVisibleProps\n>((props: ScopedProps<ScrollAreaScrollbarVisibleProps>, forwardedRef) => {\n  const { orientation = 'vertical', ...scrollbarProps } = props;\n  const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n  const thumbRef = React.useRef<ScrollAreaThumbElement | null>(null);\n  const pointerOffsetRef = React.useRef(0);\n  const [sizes, setSizes] = React.useState<Sizes>({\n    content: 0,\n    viewport: 0,\n    scrollbar: { size: 0, paddingStart: 0, paddingEnd: 0 },\n  });\n  const thumbRatio = getThumbRatio(sizes.viewport, sizes.content);\n\n  type UncommonProps = 'onThumbPositionChange' | 'onDragScroll' | 'onWheelScroll';\n  const commonProps: Omit<ScrollAreaScrollbarAxisPrivateProps, UncommonProps> = {\n    ...scrollbarProps,\n    sizes,\n    onSizesChange: setSizes,\n    hasThumb: Boolean(thumbRatio > 0 && thumbRatio < 1),\n    onThumbChange: (thumb) => (thumbRef.current = thumb),\n    onThumbPointerUp: () => (pointerOffsetRef.current = 0),\n    onThumbPointerDown: (pointerPos) => (pointerOffsetRef.current = pointerPos),\n  };\n\n  function getScrollPosition(pointerPos: number, dir?: Direction) {\n    return getScrollPositionFromPointer(pointerPos, pointerOffsetRef.current, sizes, dir);\n  }\n\n  if (orientation === 'horizontal') {\n    return (\n      <ScrollAreaScrollbarX\n        {...commonProps}\n        ref={forwardedRef}\n        onThumbPositionChange={() => {\n          if (context.viewport && thumbRef.current) {\n            const scrollPos = context.viewport.scrollLeft;\n            const offset = getThumbOffsetFromScroll(scrollPos, sizes, context.dir);\n            thumbRef.current.style.transform = `translate3d(${offset}px, 0, 0)`;\n          }\n        }}\n        onWheelScroll={(scrollPos) => {\n          if (context.viewport) context.viewport.scrollLeft = scrollPos;\n        }}\n        onDragScroll={(pointerPos) => {\n          if (context.viewport) {\n            context.viewport.scrollLeft = getScrollPosition(pointerPos, context.dir);\n          }\n        }}\n      />\n    );\n  }\n\n  if (orientation === 'vertical') {\n    return (\n      <ScrollAreaScrollbarY\n        {...commonProps}\n        ref={forwardedRef}\n        onThumbPositionChange={() => {\n          if (context.viewport && thumbRef.current) {\n            const scrollPos = context.viewport.scrollTop;\n            const offset = getThumbOffsetFromScroll(scrollPos, sizes);\n            thumbRef.current.style.transform = `translate3d(0, ${offset}px, 0)`;\n          }\n        }}\n        onWheelScroll={(scrollPos) => {\n          if (context.viewport) context.viewport.scrollTop = scrollPos;\n        }}\n        onDragScroll={(pointerPos) => {\n          if (context.viewport) context.viewport.scrollTop = getScrollPosition(pointerPos);\n        }}\n      />\n    );\n  }\n\n  return null;\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype ScrollAreaScrollbarAxisPrivateProps = {\n  hasThumb: boolean;\n  sizes: Sizes;\n  onSizesChange(sizes: Sizes): void;\n  onThumbChange(thumb: ScrollAreaThumbElement | null): void;\n  onThumbPointerDown(pointerPos: number): void;\n  onThumbPointerUp(): void;\n  onThumbPositionChange(): void;\n  onWheelScroll(scrollPos: number): void;\n  onDragScroll(pointerPos: number): void;\n};\n\ntype ScrollAreaScrollbarAxisElement = ScrollAreaScrollbarImplElement;\ninterface ScrollAreaScrollbarAxisProps\n  extends Omit<ScrollAreaScrollbarImplProps, keyof ScrollAreaScrollbarImplPrivateProps>,\n    ScrollAreaScrollbarAxisPrivateProps {}\n\nconst ScrollAreaScrollbarX = React.forwardRef<\n  ScrollAreaScrollbarAxisElement,\n  ScrollAreaScrollbarAxisProps\n>((props: ScopedProps<ScrollAreaScrollbarAxisProps>, forwardedRef) => {\n  const { sizes, onSizesChange, ...scrollbarProps } = props;\n  const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n  const [computedStyle, setComputedStyle] = React.useState<CSSStyleDeclaration>();\n  const ref = React.useRef<ScrollAreaScrollbarAxisElement>(null);\n  const composeRefs = useComposedRefs(forwardedRef, ref, context.onScrollbarXChange);\n\n  React.useEffect(() => {\n    if (ref.current) setComputedStyle(getComputedStyle(ref.current));\n  }, [ref]);\n\n  return (\n    <ScrollAreaScrollbarImpl\n      data-orientation=\"horizontal\"\n      {...scrollbarProps}\n      ref={composeRefs}\n      sizes={sizes}\n      style={{\n        bottom: 0,\n        left: context.dir === 'rtl' ? 'var(--radix-scroll-area-corner-width)' : 0,\n        right: context.dir === 'ltr' ? 'var(--radix-scroll-area-corner-width)' : 0,\n        ['--radix-scroll-area-thumb-width' as any]: getThumbSize(sizes) + 'px',\n        ...props.style,\n      }}\n      onThumbPointerDown={(pointerPos) => props.onThumbPointerDown(pointerPos.x)}\n      onDragScroll={(pointerPos) => props.onDragScroll(pointerPos.x)}\n      onWheelScroll={(event, maxScrollPos) => {\n        if (context.viewport) {\n          const scrollPos = context.viewport.scrollLeft + event.deltaX;\n          props.onWheelScroll(scrollPos);\n          // prevent window scroll when wheeling on scrollbar\n          if (isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) {\n            event.preventDefault();\n          }\n        }\n      }}\n      onResize={() => {\n        if (ref.current && context.viewport && computedStyle) {\n          onSizesChange({\n            content: context.viewport.scrollWidth,\n            viewport: context.viewport.offsetWidth,\n            scrollbar: {\n              size: ref.current.clientWidth,\n              paddingStart: toInt(computedStyle.paddingLeft),\n              paddingEnd: toInt(computedStyle.paddingRight),\n            },\n          });\n        }\n      }}\n    />\n  );\n});\n\nconst ScrollAreaScrollbarY = React.forwardRef<\n  ScrollAreaScrollbarAxisElement,\n  ScrollAreaScrollbarAxisProps\n>((props: ScopedProps<ScrollAreaScrollbarAxisProps>, forwardedRef) => {\n  const { sizes, onSizesChange, ...scrollbarProps } = props;\n  const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);\n  const [computedStyle, setComputedStyle] = React.useState<CSSStyleDeclaration>();\n  const ref = React.useRef<ScrollAreaScrollbarAxisElement>(null);\n  const composeRefs = useComposedRefs(forwardedRef, ref, context.onScrollbarYChange);\n\n  React.useEffect(() => {\n    if (ref.current) setComputedStyle(getComputedStyle(ref.current));\n  }, [ref]);\n\n  return (\n    <ScrollAreaScrollbarImpl\n      data-orientation=\"vertical\"\n      {...scrollbarProps}\n      ref={composeRefs}\n      sizes={sizes}\n      style={{\n        top: 0,\n        right: context.dir === 'ltr' ? 0 : undefined,\n        left: context.dir === 'rtl' ? 0 : undefined,\n        bottom: 'var(--radix-scroll-area-corner-height)',\n        ['--radix-scroll-area-thumb-height' as any]: getThumbSize(sizes) + 'px',\n        ...props.style,\n      }}\n      onThumbPointerDown={(pointerPos) => props.onThumbPointerDown(pointerPos.y)}\n      onDragScroll={(pointerPos) => props.onDragScroll(pointerPos.y)}\n      onWheelScroll={(event, maxScrollPos) => {\n        if (context.viewport) {\n          const scrollPos = context.viewport.scrollTop + event.deltaY;\n          props.onWheelScroll(scrollPos);\n          // prevent window scroll when wheeling on scrollbar\n          if (isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) {\n            event.preventDefault();\n          }\n        }\n      }}\n      onResize={() => {\n        if (ref.current && context.viewport && computedStyle) {\n          onSizesChange({\n            content: context.viewport.scrollHeight,\n            viewport: context.viewport.offsetHeight,\n            scrollbar: {\n              size: ref.current.clientHeight,\n              paddingStart: toInt(computedStyle.paddingTop),\n              paddingEnd: toInt(computedStyle.paddingBottom),\n            },\n          });\n        }\n      }}\n    />\n  );\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype ScrollbarContext = {\n  hasThumb: boolean;\n  scrollbar: ScrollAreaScrollbarElement | null;\n  onThumbChange(thumb: ScrollAreaThumbElement | null): void;\n  onThumbPointerUp(): void;\n  onThumbPointerDown(pointerPos: { x: number; y: number }): void;\n  onThumbPositionChange(): void;\n};\n\nconst [ScrollbarProvider, useScrollbarContext] =\n  createScrollAreaContext<ScrollbarContext>(SCROLLBAR_NAME);\n\ntype ScrollAreaScrollbarImplElement = React.ElementRef<typeof Primitive.div>;\ntype ScrollAreaScrollbarImplPrivateProps = {\n  sizes: Sizes;\n  hasThumb: boolean;\n  onThumbChange: ScrollbarContext['onThumbChange'];\n  onThumbPointerUp: ScrollbarContext['onThumbPointerUp'];\n  onThumbPointerDown: ScrollbarContext['onThumbPointerDown'];\n  onThumbPositionChange: ScrollbarContext['onThumbPositionChange'];\n  onWheelScroll(event: WheelEvent, maxScrollPos: number): void;\n  onDragScroll(pointerPos: { x: number; y: number }): void;\n  onResize(): void;\n};\ninterface ScrollAreaScrollbarImplProps\n  extends PrimitiveDivProps,\n    ScrollAreaScrollbarImplPrivateProps {}\n\nconst ScrollAreaScrollbarImpl = React.forwardRef<\n  ScrollAreaScrollbarImplElement,\n  ScrollAreaScrollbarImplProps\n>((props: ScopedProps<ScrollAreaScrollbarImplProps>, forwardedRef) => {\n  const {\n    __scopeScrollArea,\n    sizes,\n    hasThumb,\n    onThumbChange,\n    onThumbPointerUp,\n    onThumbPointerDown,\n    onThumbPositionChange,\n    onDragScroll,\n    onWheelScroll,\n    onResize,\n    ...scrollbarProps\n  } = props;\n  const context = useScrollAreaContext(SCROLLBAR_NAME, __scopeScrollArea);\n  const [scrollbar, setScrollbar] = React.useState<ScrollAreaScrollbarElement | null>(null);\n  const composeRefs = useComposedRefs(forwardedRef, (node) => setScrollbar(node));\n  const rectRef = React.useRef<ClientRect | null>(null);\n  const prevWebkitUserSelectRef = React.useRef<string>('');\n  const viewport = context.viewport;\n  const maxScrollPos = sizes.content - sizes.viewport;\n  const handleWheelScroll = useCallbackRef(onWheelScroll);\n  const handleThumbPositionChange = useCallbackRef(onThumbPositionChange);\n  const handleResize = useDebounceCallback(onResize, 10);\n\n  function handleDragScroll(event: React.PointerEvent<HTMLElement>) {\n    if (rectRef.current) {\n      const x = event.clientX - rectRef.current.left;\n      const y = event.clientY - rectRef.current.top;\n      onDragScroll({ x, y });\n    }\n  }\n\n  /**\n   * We bind wheel event imperatively so we can switch off passive\n   * mode for document wheel event to allow it to be prevented\n   */\n  React.useEffect(() => {\n    const handleWheel = (event: WheelEvent) => {\n      const element = event.target as HTMLElement;\n      const isScrollbarWheel = scrollbar?.contains(element);\n      if (isScrollbarWheel) handleWheelScroll(event, maxScrollPos);\n    };\n    document.addEventListener('wheel', handleWheel, { passive: false });\n    return () => document.removeEventListener('wheel', handleWheel, { passive: false } as any);\n  }, [viewport, scrollbar, maxScrollPos, handleWheelScroll]);\n\n  /**\n   * Update thumb position on sizes change\n   */\n  React.useEffect(handleThumbPositionChange, [sizes, handleThumbPositionChange]);\n\n  useResizeObserver(scrollbar, handleResize);\n  useResizeObserver(context.content, handleResize);\n\n  return (\n    <ScrollbarProvider\n      scope={__scopeScrollArea}\n      scrollbar={scrollbar}\n      hasThumb={hasThumb}\n      onThumbChange={useCallbackRef(onThumbChange)}\n      onThumbPointerUp={useCallbackRef(onThumbPointerUp)}\n      onThumbPositionChange={handleThumbPositionChange}\n      onThumbPointerDown={useCallbackRef(onThumbPointerDown)}\n    >\n      <Primitive.div\n        {...scrollbarProps}\n        ref={composeRefs}\n        style={{ position: 'absolute', ...scrollbarProps.style }}\n        onPointerDown={composeEventHandlers(props.onPointerDown, (event) => {\n          const mainPointer = 0;\n          if (event.button === mainPointer) {\n            const element = event.target as HTMLElement;\n            element.setPointerCapture(event.pointerId);\n            rectRef.current = scrollbar!.getBoundingClientRect();\n            // pointer capture doesn't prevent text selection in Safari\n            // so we remove text selection manually when scrolling\n            prevWebkitUserSelectRef.current = document.body.style.webkitUserSelect;\n            document.body.style.webkitUserSelect = 'none';\n            handleDragScroll(event);\n          }\n        })}\n        onPointerMove={composeEventHandlers(props.onPointerMove, handleDragScroll)}\n        onPointerUp={composeEventHandlers(props.onPointerUp, (event) => {\n          const element = event.target as HTMLElement;\n          if (element.hasPointerCapture(event.pointerId)) {\n            element.releasePointerCapture(event.pointerId);\n          }\n          document.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;\n          rectRef.current = null;\n        })}\n      />\n    </ScrollbarProvider>\n  );\n});\n\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaThumb\n * -----------------------------------------------------------------------------------------------*/\n\nconst THUMB_NAME = 'ScrollAreaThumb';\n\ntype ScrollAreaThumbElement = ScrollAreaThumbImplElement;\ninterface ScrollAreaThumbProps extends ScrollAreaThumbImplProps {\n  /**\n   * Used to force mounting when more control is needed. Useful when\n   * controlling animation with React animation libraries.\n   */\n  forceMount?: true;\n}\n\nconst ScrollAreaThumb = React.forwardRef<ScrollAreaThumbElement, ScrollAreaThumbProps>(\n  (props: ScopedProps<ScrollAreaThumbProps>, forwardedRef) => {\n    const { forceMount, ...thumbProps } = props;\n    const scrollbarContext = useScrollbarContext(THUMB_NAME, props.__scopeScrollArea);\n    return (\n      <Presence present={forceMount || scrollbarContext.hasThumb}>\n        <ScrollAreaThumbImpl ref={forwardedRef} {...thumbProps} />\n      </Presence>\n    );\n  }\n);\n\ntype ScrollAreaThumbImplElement = React.ElementRef<typeof Primitive.div>;\ninterface ScrollAreaThumbImplProps extends PrimitiveDivProps {}\n\nconst ScrollAreaThumbImpl = React.forwardRef<ScrollAreaThumbImplElement, ScrollAreaThumbImplProps>(\n  (props: ScopedProps<ScrollAreaThumbImplProps>, forwardedRef) => {\n    const { __scopeScrollArea, style, ...thumbProps } = props;\n    const scrollAreaContext = useScrollAreaContext(THUMB_NAME, __scopeScrollArea);\n    const scrollbarContext = useScrollbarContext(THUMB_NAME, __scopeScrollArea);\n    const { onThumbPositionChange } = scrollbarContext;\n    const composedRef = useComposedRefs(forwardedRef, (node) =>\n      scrollbarContext.onThumbChange(node)\n    );\n    const removeUnlinkedScrollListenerRef = React.useRef<() => void>();\n    const debounceScrollEnd = useDebounceCallback(() => {\n      if (removeUnlinkedScrollListenerRef.current) {\n        removeUnlinkedScrollListenerRef.current();\n        removeUnlinkedScrollListenerRef.current = undefined;\n      }\n    }, 100);\n\n    React.useEffect(() => {\n      const viewport = scrollAreaContext.viewport;\n      if (viewport) {\n        /**\n         * We only bind to native scroll event so we know when scroll starts and ends.\n         * When scroll starts we start a requestAnimationFrame loop that checks for\n         * changes to scroll position. That rAF loop triggers our thumb position change\n         * when relevant to avoid scroll-linked effects. We cancel the loop when scroll ends.\n         * https://developer.mozilla.org/en-US/docs/Mozilla/Performance/Scroll-linked_effects\n         */\n        const handleScroll = () => {\n          debounceScrollEnd();\n          if (!removeUnlinkedScrollListenerRef.current) {\n            const listener = addUnlinkedScrollListener(viewport, onThumbPositionChange);\n            removeUnlinkedScrollListenerRef.current = listener;\n            onThumbPositionChange();\n          }\n        };\n        onThumbPositionChange();\n        viewport.addEventListener('scroll', handleScroll);\n        return () => viewport.removeEventListener('scroll', handleScroll);\n      }\n    }, [scrollAreaContext.viewport, debounceScrollEnd, onThumbPositionChange]);\n\n    return (\n      <Primitive.div\n        data-state={scrollbarContext.hasThumb ? 'visible' : 'hidden'}\n        {...thumbProps}\n        ref={composedRef}\n        style={{\n          width: 'var(--radix-scroll-area-thumb-width)',\n          height: 'var(--radix-scroll-area-thumb-height)',\n          ...style,\n        }}\n        onPointerDownCapture={composeEventHandlers(props.onPointerDownCapture, (event) => {\n          const thumb = event.target as HTMLElement;\n          const thumbRect = thumb.getBoundingClientRect();\n          const x = event.clientX - thumbRect.left;\n          const y = event.clientY - thumbRect.top;\n          scrollbarContext.onThumbPointerDown({ x, y });\n        })}\n        onPointerUp={composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)}\n      />\n    );\n  }\n);\n\nScrollAreaThumb.displayName = THUMB_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaCorner\n * -----------------------------------------------------------------------------------------------*/\n\nconst CORNER_NAME = 'ScrollAreaCorner';\n\ntype ScrollAreaCornerElement = ScrollAreaCornerImplElement;\ninterface ScrollAreaCornerProps extends ScrollAreaCornerImplProps {}\n\nconst ScrollAreaCorner = React.forwardRef<ScrollAreaCornerElement, ScrollAreaCornerProps>(\n  (props: ScopedProps<ScrollAreaCornerProps>, forwardedRef) => {\n    const context = useScrollAreaContext(CORNER_NAME, props.__scopeScrollArea);\n    const hasBothScrollbarsVisible = Boolean(context.scrollbarX && context.scrollbarY);\n    const hasCorner = context.type !== 'scroll' && hasBothScrollbarsVisible;\n    return hasCorner ? <ScrollAreaCornerImpl {...props} ref={forwardedRef} /> : null;\n  }\n);\n\nScrollAreaCorner.displayName = CORNER_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype ScrollAreaCornerImplElement = React.ElementRef<typeof Primitive.div>;\ninterface ScrollAreaCornerImplProps extends PrimitiveDivProps {}\n\nconst ScrollAreaCornerImpl = React.forwardRef<\n  ScrollAreaCornerImplElement,\n  ScrollAreaCornerImplProps\n>((props: ScopedProps<ScrollAreaCornerImplProps>, forwardedRef) => {\n  const { __scopeScrollArea, ...cornerProps } = props;\n  const context = useScrollAreaContext(CORNER_NAME, __scopeScrollArea);\n  const [width, setWidth] = React.useState(0);\n  const [height, setHeight] = React.useState(0);\n  const hasSize = Boolean(width && height);\n\n  useResizeObserver(context.scrollbarX, () => {\n    const height = context.scrollbarX?.offsetHeight || 0;\n    context.onCornerHeightChange(height);\n    setHeight(height);\n  });\n\n  useResizeObserver(context.scrollbarY, () => {\n    const width = context.scrollbarY?.offsetWidth || 0;\n    context.onCornerWidthChange(width);\n    setWidth(width);\n  });\n\n  return hasSize ? (\n    <Primitive.div\n      {...cornerProps}\n      ref={forwardedRef}\n      style={{\n        width,\n        height,\n        position: 'absolute',\n        right: context.dir === 'ltr' ? 0 : undefined,\n        left: context.dir === 'rtl' ? 0 : undefined,\n        bottom: 0,\n        ...props.style,\n      }}\n    />\n  ) : null;\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction toInt(value?: string) {\n  return value ? parseInt(value, 10) : 0;\n}\n\nfunction getThumbRatio(viewportSize: number, contentSize: number) {\n  const ratio = viewportSize / contentSize;\n  return isNaN(ratio) ? 0 : ratio;\n}\n\nfunction getThumbSize(sizes: Sizes) {\n  const ratio = getThumbRatio(sizes.viewport, sizes.content);\n  const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;\n  const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio;\n  // minimum of 18 matches macOS minimum\n  return Math.max(thumbSize, 18);\n}\n\nfunction getScrollPositionFromPointer(\n  pointerPos: number,\n  pointerOffset: number,\n  sizes: Sizes,\n  dir: Direction = 'ltr'\n) {\n  const thumbSizePx = getThumbSize(sizes);\n  const thumbCenter = thumbSizePx / 2;\n  const offset = pointerOffset || thumbCenter;\n  const thumbOffsetFromEnd = thumbSizePx - offset;\n  const minPointerPos = sizes.scrollbar.paddingStart + offset;\n  const maxPointerPos = sizes.scrollbar.size - sizes.scrollbar.paddingEnd - thumbOffsetFromEnd;\n  const maxScrollPos = sizes.content - sizes.viewport;\n  const scrollRange = dir === 'ltr' ? [0, maxScrollPos] : [maxScrollPos * -1, 0];\n  const interpolate = linearScale([minPointerPos, maxPointerPos], scrollRange as [number, number]);\n  return interpolate(pointerPos);\n}\n\nfunction getThumbOffsetFromScroll(scrollPos: number, sizes: Sizes, dir: Direction = 'ltr') {\n  const thumbSizePx = getThumbSize(sizes);\n  const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;\n  const scrollbar = sizes.scrollbar.size - scrollbarPadding;\n  const maxScrollPos = sizes.content - sizes.viewport;\n  const maxThumbPos = scrollbar - thumbSizePx;\n  const scrollClampRange = dir === 'ltr' ? [0, maxScrollPos] : [maxScrollPos * -1, 0];\n  const scrollWithoutMomentum = clamp(scrollPos, scrollClampRange as [number, number]);\n  const interpolate = linearScale([0, maxScrollPos], [0, maxThumbPos]);\n  return interpolate(scrollWithoutMomentum);\n}\n\n// https://github.com/tmcw-up-for-adoption/simple-linear-scale/blob/master/index.js\nfunction linearScale(input: readonly [number, number], output: readonly [number, number]) {\n  return (value: number) => {\n    if (input[0] === input[1] || output[0] === output[1]) return output[0];\n    const ratio = (output[1] - output[0]) / (input[1] - input[0]);\n    return output[0] + ratio * (value - input[0]);\n  };\n}\n\nfunction isScrollingWithinScrollbarBounds(scrollPos: number, maxScrollPos: number) {\n  return scrollPos > 0 && scrollPos < maxScrollPos;\n}\n\n// Custom scroll handler to avoid scroll-linked effects\n// https://developer.mozilla.org/en-US/docs/Mozilla/Performance/Scroll-linked_effects\nconst addUnlinkedScrollListener = (node: HTMLElement, handler = () => {}) => {\n  let prevPosition = { left: node.scrollLeft, top: node.scrollTop };\n  let rAF = 0;\n  (function loop() {\n    const position = { left: node.scrollLeft, top: node.scrollTop };\n    const isHorizontalScroll = prevPosition.left !== position.left;\n    const isVerticalScroll = prevPosition.top !== position.top;\n    if (isHorizontalScroll || isVerticalScroll) handler();\n    prevPosition = position;\n    rAF = window.requestAnimationFrame(loop);\n  })();\n  return () => window.cancelAnimationFrame(rAF);\n};\n\nfunction useDebounceCallback(callback: () => void, delay: number) {\n  const handleCallback = useCallbackRef(callback);\n  const debounceTimerRef = React.useRef(0);\n  React.useEffect(() => () => window.clearTimeout(debounceTimerRef.current), []);\n  return React.useCallback(() => {\n    window.clearTimeout(debounceTimerRef.current);\n    debounceTimerRef.current = window.setTimeout(handleCallback, delay);\n  }, [handleCallback, delay]);\n}\n\nfunction useResizeObserver(element: HTMLElement | null, onResize: () => void) {\n  const handleResize = useCallbackRef(onResize);\n  useLayoutEffect(() => {\n    let rAF = 0;\n    if (element) {\n      /**\n       * Resize Observer will throw an often benign error that says `ResizeObserver loop\n       * completed with undelivered notifications`. This means that ResizeObserver was not\n       * able to deliver all observations within a single animation frame, so we use\n       * `requestAnimationFrame` to ensure we don't deliver unnecessary observations.\n       * Further reading: https://github.com/WICG/resize-observer/issues/38\n       */\n      const resizeObserver = new ResizeObserver(() => {\n        cancelAnimationFrame(rAF);\n        rAF = window.requestAnimationFrame(handleResize);\n      });\n      resizeObserver.observe(element);\n      return () => {\n        window.cancelAnimationFrame(rAF);\n        resizeObserver.unobserve(element);\n      };\n    }\n  }, [element, handleResize]);\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = ScrollArea;\nconst Viewport = ScrollAreaViewport;\nconst Scrollbar = ScrollAreaScrollbar;\nconst Thumb = ScrollAreaThumb;\nconst Corner = ScrollAreaCorner;\n\nexport {\n  createScrollAreaScope,\n  //\n  ScrollArea,\n  ScrollAreaViewport,\n  ScrollAreaScrollbar,\n  ScrollAreaThumb,\n  ScrollAreaCorner,\n  //\n  Root,\n  Viewport,\n  Scrollbar,\n  Thumb,\n  Corner,\n};\nexport type {\n  ScrollAreaProps,\n  ScrollAreaViewportProps,\n  ScrollAreaScrollbarProps,\n  ScrollAreaThumbProps,\n  ScrollAreaCornerProps,\n};\n","import * as React from \"react\"\nimport { clsx, type ClassValue } from \"clsx\"\nimport { twMerge } from \"tailwind-merge\"\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs))\n}\n\nexport function formatDate(input: string | number): string {\n  const date = new Date(input)\n  return date.toLocaleDateString(\"en-US\", {\n    month: \"long\",\n    day: \"numeric\",\n    year: \"numeric\",\n  })\n}\n\nexport function absoluteUrl(path: string) {\n  return `${process.env.NEXT_PUBLIC_APP_URL}${path}`\n}\n"]}