{"version":3,"sources":["../../registry/new-york/ui/accordion.tsx","../../../../node_modules/.pnpm/@babel+runtime@7.22.3/node_modules/@babel/runtime/helpers/esm/extends.js","../../../../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-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/@babel+runtime@7.22.6/node_modules/@babel/runtime/helpers/esm/extends.js","../../../../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-collection@1.0.3_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18.2_jxq2dj3ts3nidk7ucehqzsghlm/node_modules/@radix-ui/react-collection/dist/packages/react/collection/src/Collection.tsx","../../../../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-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-use-controllable-state@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-use-controllable-state/dist/packages/react/use-controllable-state/src/useControllableState.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-id@1.0.1_@types+react@18.2.65_react@18.2.0/node_modules/@radix-ui/react-id/dist/packages/react/id/src/id.tsx","../../../../node_modules/.pnpm/@radix-ui+react-collapsible@1.0.3_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18._oahszjvwamubjbxyyjgmzpjnfq/node_modules/@radix-ui/react-collapsible/dist/packages/react/collapsible/src/Collapsible.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+react-accordion@1.1.2_@types+react-dom@18.2.22_@types+react@18.2.65_react-dom@18.2._t2sdpfqaierapalzc6z6ly5say/node_modules/@radix-ui/react-accordion/dist/packages/react/accordion/src/Accordion.tsx","../../../../node_modules/.pnpm/@radix-ui+react-icons@1.3.0_react@18.2.0/node_modules/@radix-ui/react-icons/src/ChevronDownIcon.tsx","../../lib/utils.ts"],"names":["accordion_exports","__export","Accordion","AccordionContent","AccordionItem","AccordionTrigger","__toCommonJS","React","_extends","target","i","source","key","createContextScope","scopeName","createContextScopeDeps","defaultContexts","createContext","rootComponentName","defaultContext","BaseContext","index","length","Provider","props","scope","children","context","Context","value","Object","values","$3bkAK$createElement","useContext","consumerName","undefined","Error","displayName","createScope","scopeContexts","map","contexts","composeContextScopes","scopes","baseScope","scopeHooks","useScope","overrideScopes","nextScopes","reduce","currentScope","setRef","ref","current","composeRefs","refs","node","forEach","useComposedRefs","Slot","forwardedRef","slotProps","childrenArray","toArray","slottable","find","isSlottable","newElement","newChildren","child","count","only","$9IrjX$createElement","$5e63c961fc1ce211$var$SlotClone","SlotClone","mergeProps","Slottable","$9IrjX$Fragment","type","childProps","overrideProps","propName","slotPropValue","childPropValue","test","args","filter","Boolean","join","createCollection","name","PROVIDER_NAME","createCollectionContext","createCollectionScope","CollectionProviderImpl","useCollectionContext","collectionRef","itemMap","Map","CollectionProvider","useRef","$6vYhU$react","COLLECTION_SLOT_NAME","CollectionSlot","forwardRef","composedRefs","$5e63c961fc1ce211$export$8c6ed5c666ac1360","ITEM_SLOT_NAME","ITEM_DATA_ATTR","CollectionItemSlot","itemData","useEffect","set","delete","useCollection","useCallback","collectionNode","orderedNodes","Array","from","querySelectorAll","sort","a","b","indexOf","ItemSlot","composeEventHandlers","originalEventHandler","ourEventHandler","checkForDefaultPrevented","event","defaultPrevented","useCallbackRef","callback","callbackRef","_callbackRef$current","useControllableState","prop","defaultProp","onChange","uncontrolledProp","setUncontrolledProp","useUncontrolledState","isControlled","handleChange","setValue","nextValue","uncontrolledState","prevValueRef","NODES","Primitive","primitive","Node","asChild","primitiveProps","Comp","window","Symbol","for","$4q5Fq$createElement","useLayoutEffect","globalThis","document","useStateMachine","initialState","machine","state","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","useReactId","useId","deterministicId","id","setId","useState","reactId","String","COLLAPSIBLE_NAME","createCollapsibleContext","createCollapsibleScope","CollapsibleProvider","useCollapsibleContext","Collapsible","__scopeCollapsible","open","openProp","defaultOpen","disabled","onOpenChange","collapsibleProps","setOpen","$73KQ4$createElement","$409067139f391064$var$CollapsibleProvider","prevOpen","$8927f6f2acc4f386$export$250ffa63cdc0d034","getState","TRIGGER_NAME","CollapsibleTrigger","triggerProps","contentId","onClick","onOpenToggle","CONTENT_NAME","CollapsibleContent","forceMount","contentProps","$921a889cee6df7e8$export$99c2b779aa4e8b8b","$409067139f391064$var$CollapsibleContentImpl","CollapsibleContentImpl","setIsPresent","heightRef","height","widthRef","width","isOpen","isMountAnimationPreventedRef","originalStylesRef","rAF","requestAnimationFrame","cancelAnimationFrame","transitionDuration","style","rect","getBoundingClientRect","Root","Trigger","Content","DirectionContext","useDirection","localDir","globalDir","ACCORDION_NAME","ACCORDION_KEYS","Collection","createAccordionContext","createAccordionScope","useCollapsibleScope","accordionProps","singleProps","multipleProps","$3DjNB$react","$1bf158f521e1b1b4$var$Collection","__scopeAccordion","$1bf158f521e1b1b4$var$AccordionImplMultiple","$1bf158f521e1b1b4$var$AccordionImplSingle","propTypes","defaultValue","isArray","AccordionValueProvider","useAccordionValueContext","AccordionCollapsibleProvider","useAccordionCollapsibleContext","collapsible","AccordionImplSingle","valueProp","onValueChange","accordionSingleProps","$1bf158f521e1b1b4$var$AccordionValueProvider","$1bf158f521e1b1b4$var$AccordionCollapsibleProvider","$1bf158f521e1b1b4$var$AccordionImpl","AccordionImplMultiple","accordionMultipleProps","handleItemOpen","itemValue","prevValue","handleItemClose","AccordionImplProvider","useAccordionContext","AccordionImpl","dir","orientation","accordionRef","getItems","isDirectionLTR","handleKeyDown","onKeyDown","_triggerCollection$cl","triggerCollection","item","_item$ref$current","triggerIndex","findIndex","triggerCount","preventDefault","nextIndex","homeIndex","endIndex","moveNext","movePrev","clampedIndex","focus","$1bf158f521e1b1b4$var$AccordionImplProvider","ITEM_NAME","AccordionItemProvider","useAccordionItemContext","accordionItemProps","accordionContext","valueContext","collapsibleScope","triggerId","$1bf158f521e1b1b4$var$AccordionItemProvider","$409067139f391064$export$be92b6f5f03c0fe9","onItemOpen","onItemClose","HEADER_NAME","AccordionHeader","headerProps","itemContext","collapsibleContext","$409067139f391064$export$41fb9f06171c75f4","$409067139f391064$export$7c6e2c02157bb7d2","Item","Header","ChevronDownIcon","_ref","color","_ref$color","viewBox","fill","xmlns","d","fillRule","clipRule","import_clsx","import_tailwind_merge","cn","inputs","import_jsx_runtime","$1bf158f521e1b1b4$export$be92b6f5f03c0fe9","className","$1bf158f521e1b1b4$export$6d08773d2e66f8f2","$1bf158f521e1b1b4$export$8b251419efc915eb","$1bf158f521e1b1b4$export$41fb9f06171c75f4","$1bf158f521e1b1b4$export$7c6e2c02157bb7d2"],"mappings":"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","sourcesContent":["\"use client\"\n\nimport * as React from \"react\"\nimport * as AccordionPrimitive from \"@radix-ui/react-accordion\"\nimport { ChevronDownIcon } from \"@radix-ui/react-icons\"\n\nimport { cn } from \"@/lib/utils\"\n\nconst Accordion = AccordionPrimitive.Root\n\nconst AccordionItem = React.forwardRef<\n  React.ElementRef<typeof AccordionPrimitive.Item>,\n  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>\n>(({ className, ...props }, ref) => (\n  <AccordionPrimitive.Item\n    ref={ref}\n    className={cn(\"border-b\", className)}\n    {...props}\n  />\n))\nAccordionItem.displayName = \"AccordionItem\"\n\nconst AccordionTrigger = React.forwardRef<\n  React.ElementRef<typeof AccordionPrimitive.Trigger>,\n  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>\n>(({ className, children, ...props }, ref) => (\n  <AccordionPrimitive.Header className=\"flex\">\n    <AccordionPrimitive.Trigger\n      ref={ref}\n      className={cn(\n        \"flex flex-1 items-center justify-between py-4 text-sm font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180\",\n        className\n      )}\n      {...props}\n    >\n      {children}\n      <ChevronDownIcon className=\"h-4 w-4 shrink-0 text-muted-foreground transition-transform duration-200\" />\n    </AccordionPrimitive.Trigger>\n  </AccordionPrimitive.Header>\n))\nAccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName\n\nconst AccordionContent = React.forwardRef<\n  React.ElementRef<typeof AccordionPrimitive.Content>,\n  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>\n>(({ className, children, ...props }, ref) => (\n  <AccordionPrimitive.Content\n    ref={ref}\n    className=\"overflow-hidden text-sm data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down\"\n    {...props}\n  >\n    <div className={cn(\"pb-4 pt-0\", className)}>{children}</div>\n  </AccordionPrimitive.Content>\n))\nAccordionContent.displayName = AccordionPrimitive.Content.displayName\n\nexport { Accordion, AccordionItem, AccordionTrigger, AccordionContent }\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\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\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","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';\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 React from 'react';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { Slot } from '@radix-ui/react-slot';\n\nimport type * as Radix from '@radix-ui/react-primitive';\n\ntype SlotProps = Radix.ComponentPropsWithoutRef<typeof Slot>;\ntype CollectionElement = HTMLElement;\ninterface CollectionProps extends SlotProps {\n  scope: any;\n}\n\n// We have resorted to returning slots directly rather than exposing primitives that can then\n// be slotted like `<CollectionItem as={Slot}>…</CollectionItem>`.\n// This is because we encountered issues with generic types that cannot be statically analysed\n// due to creating them dynamically via createCollection.\n\nfunction createCollection<ItemElement extends HTMLElement, ItemData = {}>(name: string) {\n  /* -----------------------------------------------------------------------------------------------\n   * CollectionProvider\n   * ---------------------------------------------------------------------------------------------*/\n\n  const PROVIDER_NAME = name + 'CollectionProvider';\n  const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);\n\n  type ContextValue = {\n    collectionRef: React.RefObject<CollectionElement>;\n    itemMap: Map<React.RefObject<ItemElement>, { ref: React.RefObject<ItemElement> } & ItemData>;\n  };\n\n  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext<ContextValue>(\n    PROVIDER_NAME,\n    { collectionRef: { current: null }, itemMap: new Map() }\n  );\n\n  const CollectionProvider: React.FC<{ children?: React.ReactNode; scope: any }> = (props) => {\n    const { scope, children } = props;\n    const ref = React.useRef<CollectionElement>(null);\n    const itemMap = React.useRef<ContextValue['itemMap']>(new Map()).current;\n    return (\n      <CollectionProviderImpl scope={scope} itemMap={itemMap} collectionRef={ref}>\n        {children}\n      </CollectionProviderImpl>\n    );\n  };\n\n  CollectionProvider.displayName = PROVIDER_NAME;\n\n  /* -----------------------------------------------------------------------------------------------\n   * CollectionSlot\n   * ---------------------------------------------------------------------------------------------*/\n\n  const COLLECTION_SLOT_NAME = name + 'CollectionSlot';\n\n  const CollectionSlot = React.forwardRef<CollectionElement, CollectionProps>(\n    (props, forwardedRef) => {\n      const { scope, children } = props;\n      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);\n      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);\n      return <Slot ref={composedRefs}>{children}</Slot>;\n    }\n  );\n\n  CollectionSlot.displayName = COLLECTION_SLOT_NAME;\n\n  /* -----------------------------------------------------------------------------------------------\n   * CollectionItem\n   * ---------------------------------------------------------------------------------------------*/\n\n  const ITEM_SLOT_NAME = name + 'CollectionItemSlot';\n  const ITEM_DATA_ATTR = 'data-radix-collection-item';\n\n  type CollectionItemSlotProps = ItemData & {\n    children: React.ReactNode;\n    scope: any;\n  };\n\n  const CollectionItemSlot = React.forwardRef<ItemElement, CollectionItemSlotProps>(\n    (props, forwardedRef) => {\n      const { scope, children, ...itemData } = props;\n      const ref = React.useRef<ItemElement>(null);\n      const composedRefs = useComposedRefs(forwardedRef, ref);\n      const context = useCollectionContext(ITEM_SLOT_NAME, scope);\n\n      React.useEffect(() => {\n        context.itemMap.set(ref, { ref, ...(itemData as unknown as ItemData) });\n        return () => void context.itemMap.delete(ref);\n      });\n\n      return (\n        <Slot {...{ [ITEM_DATA_ATTR]: '' }} ref={composedRefs}>\n          {children}\n        </Slot>\n      );\n    }\n  );\n\n  CollectionItemSlot.displayName = ITEM_SLOT_NAME;\n\n  /* -----------------------------------------------------------------------------------------------\n   * useCollection\n   * ---------------------------------------------------------------------------------------------*/\n\n  function useCollection(scope: any) {\n    const context = useCollectionContext(name + 'CollectionConsumer', scope);\n\n    const getItems = React.useCallback(() => {\n      const collectionNode = context.collectionRef.current;\n      if (!collectionNode) return [];\n      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));\n      const items = Array.from(context.itemMap.values());\n      const orderedItems = items.sort(\n        (a, b) => orderedNodes.indexOf(a.ref.current!) - orderedNodes.indexOf(b.ref.current!)\n      );\n      return orderedItems;\n    }, [context.collectionRef, context.itemMap]);\n\n    return getItems;\n  }\n\n  return [\n    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },\n    useCollection,\n    createCollectionScope,\n  ] as const;\n}\n\nexport { createCollection };\nexport type { CollectionProps };\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\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';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\n\ntype UseControllableStateParams<T> = {\n  prop?: T | undefined;\n  defaultProp?: T | undefined;\n  onChange?: (state: T) => void;\n};\n\ntype SetStateFn<T> = (prevState?: T) => T;\n\nfunction useControllableState<T>({\n  prop,\n  defaultProp,\n  onChange = () => {},\n}: UseControllableStateParams<T>) {\n  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });\n  const isControlled = prop !== undefined;\n  const value = isControlled ? prop : uncontrolledProp;\n  const handleChange = useCallbackRef(onChange);\n\n  const setValue: React.Dispatch<React.SetStateAction<T | undefined>> = React.useCallback(\n    (nextValue) => {\n      if (isControlled) {\n        const setter = nextValue as SetStateFn<T>;\n        const value = typeof nextValue === 'function' ? setter(prop) : nextValue;\n        if (value !== prop) handleChange(value as T);\n      } else {\n        setUncontrolledProp(nextValue);\n      }\n    },\n    [isControlled, prop, setUncontrolledProp, handleChange]\n  );\n\n  return [value, setValue] as const;\n}\n\nfunction useUncontrolledState<T>({\n  defaultProp,\n  onChange,\n}: Omit<UseControllableStateParams<T>, 'prop'>) {\n  const uncontrolledState = React.useState<T | undefined>(defaultProp);\n  const [value] = uncontrolledState;\n  const prevValueRef = React.useRef(value);\n  const handleChange = useCallbackRef(onChange);\n\n  React.useEffect(() => {\n    if (prevValueRef.current !== value) {\n      handleChange(value as T);\n      prevValueRef.current = value;\n    }\n  }, [value, prevValueRef, handleChange]);\n\n  return uncontrolledState;\n}\n\nexport { useControllableState };\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';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\n\n// We `toString()` to prevent bundlers from trying to `import { useId } from 'react';`\nconst useReactId = (React as any)['useId'.toString()] || (() => undefined);\nlet count = 0;\n\nfunction useId(deterministicId?: string): string {\n  const [id, setId] = React.useState<string | undefined>(useReactId());\n  // React versions older than 18 will have client-side ids only.\n  useLayoutEffect(() => {\n    if (!deterministicId) setId((reactId) => reactId ?? String(count++));\n  }, [deterministicId]);\n  return deterministicId || (id ? `radix-${id}` : '');\n}\n\nexport { useId };\n","import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { useControllableState } from '@radix-ui/react-use-controllable-state';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { Presence } from '@radix-ui/react-presence';\nimport { useId } from '@radix-ui/react-id';\n\nimport type * as Radix from '@radix-ui/react-primitive';\nimport type { Scope } from '@radix-ui/react-context';\n\n/* -------------------------------------------------------------------------------------------------\n * Collapsible\n * -----------------------------------------------------------------------------------------------*/\n\nconst COLLAPSIBLE_NAME = 'Collapsible';\n\ntype ScopedProps<P> = P & { __scopeCollapsible?: Scope };\nconst [createCollapsibleContext, createCollapsibleScope] = createContextScope(COLLAPSIBLE_NAME);\n\ntype CollapsibleContextValue = {\n  contentId: string;\n  disabled?: boolean;\n  open: boolean;\n  onOpenToggle(): void;\n};\n\nconst [CollapsibleProvider, useCollapsibleContext] =\n  createCollapsibleContext<CollapsibleContextValue>(COLLAPSIBLE_NAME);\n\ntype CollapsibleElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = Radix.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface CollapsibleProps extends PrimitiveDivProps {\n  defaultOpen?: boolean;\n  open?: boolean;\n  disabled?: boolean;\n  onOpenChange?(open: boolean): void;\n}\n\nconst Collapsible = React.forwardRef<CollapsibleElement, CollapsibleProps>(\n  (props: ScopedProps<CollapsibleProps>, forwardedRef) => {\n    const {\n      __scopeCollapsible,\n      open: openProp,\n      defaultOpen,\n      disabled,\n      onOpenChange,\n      ...collapsibleProps\n    } = props;\n\n    const [open = false, setOpen] = useControllableState({\n      prop: openProp,\n      defaultProp: defaultOpen,\n      onChange: onOpenChange,\n    });\n\n    return (\n      <CollapsibleProvider\n        scope={__scopeCollapsible}\n        disabled={disabled}\n        contentId={useId()}\n        open={open}\n        onOpenToggle={React.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen])}\n      >\n        <Primitive.div\n          data-state={getState(open)}\n          data-disabled={disabled ? '' : undefined}\n          {...collapsibleProps}\n          ref={forwardedRef}\n        />\n      </CollapsibleProvider>\n    );\n  }\n);\n\nCollapsible.displayName = COLLAPSIBLE_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * CollapsibleTrigger\n * -----------------------------------------------------------------------------------------------*/\n\nconst TRIGGER_NAME = 'CollapsibleTrigger';\n\ntype CollapsibleTriggerElement = React.ElementRef<typeof Primitive.button>;\ntype PrimitiveButtonProps = Radix.ComponentPropsWithoutRef<typeof Primitive.button>;\ninterface CollapsibleTriggerProps extends PrimitiveButtonProps {}\n\nconst CollapsibleTrigger = React.forwardRef<CollapsibleTriggerElement, CollapsibleTriggerProps>(\n  (props: ScopedProps<CollapsibleTriggerProps>, forwardedRef) => {\n    const { __scopeCollapsible, ...triggerProps } = props;\n    const context = useCollapsibleContext(TRIGGER_NAME, __scopeCollapsible);\n    return (\n      <Primitive.button\n        type=\"button\"\n        aria-controls={context.contentId}\n        aria-expanded={context.open || false}\n        data-state={getState(context.open)}\n        data-disabled={context.disabled ? '' : undefined}\n        disabled={context.disabled}\n        {...triggerProps}\n        ref={forwardedRef}\n        onClick={composeEventHandlers(props.onClick, context.onOpenToggle)}\n      />\n    );\n  }\n);\n\nCollapsibleTrigger.displayName = TRIGGER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * CollapsibleContent\n * -----------------------------------------------------------------------------------------------*/\n\nconst CONTENT_NAME = 'CollapsibleContent';\n\ntype CollapsibleContentElement = CollapsibleContentImplElement;\ninterface CollapsibleContentProps extends Omit<CollapsibleContentImplProps, 'present'> {\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 CollapsibleContent = React.forwardRef<CollapsibleContentElement, CollapsibleContentProps>(\n  (props: ScopedProps<CollapsibleContentProps>, forwardedRef) => {\n    const { forceMount, ...contentProps } = props;\n    const context = useCollapsibleContext(CONTENT_NAME, props.__scopeCollapsible);\n    return (\n      <Presence present={forceMount || context.open}>\n        {({ present }) => (\n          <CollapsibleContentImpl {...contentProps} ref={forwardedRef} present={present} />\n        )}\n      </Presence>\n    );\n  }\n);\n\nCollapsibleContent.displayName = CONTENT_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype CollapsibleContentImplElement = React.ElementRef<typeof Primitive.div>;\ninterface CollapsibleContentImplProps extends PrimitiveDivProps {\n  present: boolean;\n}\n\nconst CollapsibleContentImpl = React.forwardRef<\n  CollapsibleContentImplElement,\n  CollapsibleContentImplProps\n>((props: ScopedProps<CollapsibleContentImplProps>, forwardedRef) => {\n  const { __scopeCollapsible, present, children, ...contentProps } = props;\n  const context = useCollapsibleContext(CONTENT_NAME, __scopeCollapsible);\n  const [isPresent, setIsPresent] = React.useState(present);\n  const ref = React.useRef<CollapsibleContentImplElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  const heightRef = React.useRef<number | undefined>(0);\n  const height = heightRef.current;\n  const widthRef = React.useRef<number | undefined>(0);\n  const width = widthRef.current;\n  // when opening we want it to immediately open to retrieve dimensions\n  // when closing we delay `present` to retrieve dimensions before closing\n  const isOpen = context.open || isPresent;\n  const isMountAnimationPreventedRef = React.useRef(isOpen);\n  const originalStylesRef = React.useRef<Record<string, string>>();\n\n  React.useEffect(() => {\n    const rAF = requestAnimationFrame(() => (isMountAnimationPreventedRef.current = false));\n    return () => cancelAnimationFrame(rAF);\n  }, []);\n\n  useLayoutEffect(() => {\n    const node = ref.current;\n    if (node) {\n      originalStylesRef.current = originalStylesRef.current || {\n        transitionDuration: node.style.transitionDuration,\n        animationName: node.style.animationName,\n      };\n      // block any animations/transitions so the element renders at its full dimensions\n      node.style.transitionDuration = '0s';\n      node.style.animationName = 'none';\n\n      // get width and height from full dimensions\n      const rect = node.getBoundingClientRect();\n      heightRef.current = rect.height;\n      widthRef.current = rect.width;\n\n      // kick off any animations/transitions that were originally set up if it isn't the initial mount\n      if (!isMountAnimationPreventedRef.current) {\n        node.style.transitionDuration = originalStylesRef.current.transitionDuration;\n        node.style.animationName = originalStylesRef.current.animationName;\n      }\n\n      setIsPresent(present);\n    }\n    /**\n     * depends on `context.open` because it will change to `false`\n     * when a close is triggered but `present` will be `false` on\n     * animation end (so when close finishes). This allows us to\n     * retrieve the dimensions *before* closing.\n     */\n  }, [context.open, present]);\n\n  return (\n    <Primitive.div\n      data-state={getState(context.open)}\n      data-disabled={context.disabled ? '' : undefined}\n      id={context.contentId}\n      hidden={!isOpen}\n      {...contentProps}\n      ref={composedRefs}\n      style={{\n        [`--radix-collapsible-content-height` as any]: height ? `${height}px` : undefined,\n        [`--radix-collapsible-content-width` as any]: width ? `${width}px` : undefined,\n        ...props.style,\n      }}\n    >\n      {isOpen && children}\n    </Primitive.div>\n  );\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction getState(open?: boolean) {\n  return open ? 'open' : 'closed';\n}\n\nconst Root = Collapsible;\nconst Trigger = CollapsibleTrigger;\nconst Content = CollapsibleContent;\n\nexport {\n  createCollapsibleScope,\n  //\n  Collapsible,\n  CollapsibleTrigger,\n  CollapsibleContent,\n  //\n  Root,\n  Trigger,\n  Content,\n};\nexport type { CollapsibleProps, CollapsibleTriggerProps, CollapsibleContentProps };\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","import React from 'react';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { createCollection } from '@radix-ui/react-collection';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { useControllableState } from '@radix-ui/react-use-controllable-state';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport * as CollapsiblePrimitive from '@radix-ui/react-collapsible';\nimport { createCollapsibleScope } from '@radix-ui/react-collapsible';\nimport { useId } from '@radix-ui/react-id';\n\nimport type * as Radix from '@radix-ui/react-primitive';\nimport type { Scope } from '@radix-ui/react-context';\nimport { useDirection } from '@radix-ui/react-direction';\n\ntype Direction = 'ltr' | 'rtl';\n\n/* -------------------------------------------------------------------------------------------------\n * Accordion\n * -----------------------------------------------------------------------------------------------*/\n\nconst ACCORDION_NAME = 'Accordion';\nconst ACCORDION_KEYS = ['Home', 'End', 'ArrowDown', 'ArrowUp', 'ArrowLeft', 'ArrowRight'];\n\nconst [Collection, useCollection, createCollectionScope] =\n  createCollection<AccordionTriggerElement>(ACCORDION_NAME);\n\ntype ScopedProps<P> = P & { __scopeAccordion?: Scope };\nconst [createAccordionContext, createAccordionScope] = createContextScope(ACCORDION_NAME, [\n  createCollectionScope,\n  createCollapsibleScope,\n]);\nconst useCollapsibleScope = createCollapsibleScope();\n\ntype AccordionElement = AccordionImplMultipleElement | AccordionImplSingleElement;\ninterface AccordionSingleProps extends AccordionImplSingleProps {\n  type: 'single';\n}\ninterface AccordionMultipleProps extends AccordionImplMultipleProps {\n  type: 'multiple';\n}\n\nconst Accordion = React.forwardRef<AccordionElement, AccordionSingleProps | AccordionMultipleProps>(\n  (props: ScopedProps<AccordionSingleProps | AccordionMultipleProps>, forwardedRef) => {\n    const { type, ...accordionProps } = props;\n    const singleProps = accordionProps as AccordionImplSingleProps;\n    const multipleProps = accordionProps as AccordionImplMultipleProps;\n    return (\n      <Collection.Provider scope={props.__scopeAccordion}>\n        {type === 'multiple' ? (\n          <AccordionImplMultiple {...multipleProps} ref={forwardedRef} />\n        ) : (\n          <AccordionImplSingle {...singleProps} ref={forwardedRef} />\n        )}\n      </Collection.Provider>\n    );\n  }\n);\n\nAccordion.displayName = ACCORDION_NAME;\n\nAccordion.propTypes = {\n  type(props) {\n    const value = props.value || props.defaultValue;\n    if (props.type && !['single', 'multiple'].includes(props.type)) {\n      return new Error(\n        'Invalid prop `type` supplied to `Accordion`. Expected one of `single | multiple`.'\n      );\n    }\n    if (props.type === 'multiple' && typeof value === 'string') {\n      return new Error(\n        'Invalid prop `type` supplied to `Accordion`. Expected `single` when `defaultValue` or `value` is type `string`.'\n      );\n    }\n    if (props.type === 'single' && Array.isArray(value)) {\n      return new Error(\n        'Invalid prop `type` supplied to `Accordion`. Expected `multiple` when `defaultValue` or `value` is type `string[]`.'\n      );\n    }\n    return null;\n  },\n};\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype AccordionValueContextValue = {\n  value: string[];\n  onItemOpen(value: string): void;\n  onItemClose(value: string): void;\n};\n\nconst [AccordionValueProvider, useAccordionValueContext] =\n  createAccordionContext<AccordionValueContextValue>(ACCORDION_NAME);\n\nconst [AccordionCollapsibleProvider, useAccordionCollapsibleContext] = createAccordionContext(\n  ACCORDION_NAME,\n  { collapsible: false }\n);\n\ntype AccordionImplSingleElement = AccordionImplElement;\ninterface AccordionImplSingleProps extends AccordionImplProps {\n  /**\n   * The controlled stateful value of the accordion item whose content is expanded.\n   */\n  value?: string;\n  /**\n   * The value of the item whose content is expanded when the accordion is initially rendered. Use\n   * `defaultValue` if you do not need to control the state of an accordion.\n   */\n  defaultValue?: string;\n  /**\n   * The callback that fires when the state of the accordion changes.\n   */\n  onValueChange?(value: string): void;\n  /**\n   * Whether an accordion item can be collapsed after it has been opened.\n   * @default false\n   */\n  collapsible?: boolean;\n}\n\nconst AccordionImplSingle = React.forwardRef<AccordionImplSingleElement, AccordionImplSingleProps>(\n  (props: ScopedProps<AccordionImplSingleProps>, forwardedRef) => {\n    const {\n      value: valueProp,\n      defaultValue,\n      onValueChange = () => {},\n      collapsible = false,\n      ...accordionSingleProps\n    } = props;\n\n    const [value, setValue] = useControllableState({\n      prop: valueProp,\n      defaultProp: defaultValue,\n      onChange: onValueChange,\n    });\n\n    return (\n      <AccordionValueProvider\n        scope={props.__scopeAccordion}\n        value={value ? [value] : []}\n        onItemOpen={setValue}\n        onItemClose={React.useCallback(() => collapsible && setValue(''), [collapsible, setValue])}\n      >\n        <AccordionCollapsibleProvider scope={props.__scopeAccordion} collapsible={collapsible}>\n          <AccordionImpl {...accordionSingleProps} ref={forwardedRef} />\n        </AccordionCollapsibleProvider>\n      </AccordionValueProvider>\n    );\n  }\n);\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype AccordionImplMultipleElement = AccordionImplElement;\ninterface AccordionImplMultipleProps extends AccordionImplProps {\n  /**\n   * The controlled stateful value of the accordion items whose contents are expanded.\n   */\n  value?: string[];\n  /**\n   * The value of the items whose contents are expanded when the accordion is initially rendered. Use\n   * `defaultValue` if you do not need to control the state of an accordion.\n   */\n  defaultValue?: string[];\n  /**\n   * The callback that fires when the state of the accordion changes.\n   */\n  onValueChange?(value: string[]): void;\n}\n\nconst AccordionImplMultiple = React.forwardRef<\n  AccordionImplMultipleElement,\n  AccordionImplMultipleProps\n>((props: ScopedProps<AccordionImplMultipleProps>, forwardedRef) => {\n  const {\n    value: valueProp,\n    defaultValue,\n    onValueChange = () => {},\n    ...accordionMultipleProps\n  } = props;\n\n  const [value = [], setValue] = useControllableState({\n    prop: valueProp,\n    defaultProp: defaultValue,\n    onChange: onValueChange,\n  });\n\n  const handleItemOpen = React.useCallback(\n    (itemValue: string) => setValue((prevValue = []) => [...prevValue, itemValue]),\n    [setValue]\n  );\n\n  const handleItemClose = React.useCallback(\n    (itemValue: string) =>\n      setValue((prevValue = []) => prevValue.filter((value) => value !== itemValue)),\n    [setValue]\n  );\n\n  return (\n    <AccordionValueProvider\n      scope={props.__scopeAccordion}\n      value={value}\n      onItemOpen={handleItemOpen}\n      onItemClose={handleItemClose}\n    >\n      <AccordionCollapsibleProvider scope={props.__scopeAccordion} collapsible={true}>\n        <AccordionImpl {...accordionMultipleProps} ref={forwardedRef} />\n      </AccordionCollapsibleProvider>\n    </AccordionValueProvider>\n  );\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype AccordionImplContextValue = {\n  disabled?: boolean;\n  direction: AccordionImplProps['dir'];\n  orientation: AccordionImplProps['orientation'];\n};\n\nconst [AccordionImplProvider, useAccordionContext] =\n  createAccordionContext<AccordionImplContextValue>(ACCORDION_NAME);\n\ntype AccordionImplElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = Radix.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface AccordionImplProps extends PrimitiveDivProps {\n  /**\n   * Whether or not an accordion is disabled from user interaction.\n   *\n   * @defaultValue false\n   */\n  disabled?: boolean;\n  /**\n   * The layout in which the Accordion operates.\n   * @default vertical\n   */\n  orientation?: React.AriaAttributes['aria-orientation'];\n  /**\n   * The language read direction.\n   */\n  dir?: Direction;\n}\n\nconst AccordionImpl = React.forwardRef<AccordionImplElement, AccordionImplProps>(\n  (props: ScopedProps<AccordionImplProps>, forwardedRef) => {\n    const { __scopeAccordion, disabled, dir, orientation = 'vertical', ...accordionProps } = props;\n    const accordionRef = React.useRef<AccordionImplElement>(null);\n    const composedRefs = useComposedRefs(accordionRef, forwardedRef);\n    const getItems = useCollection(__scopeAccordion);\n    const direction = useDirection(dir);\n    const isDirectionLTR = direction === 'ltr';\n\n    const handleKeyDown = composeEventHandlers(props.onKeyDown, (event) => {\n      if (!ACCORDION_KEYS.includes(event.key)) return;\n      const target = event.target as HTMLElement;\n      const triggerCollection = getItems().filter((item) => !item.ref.current?.disabled);\n      const triggerIndex = triggerCollection.findIndex((item) => item.ref.current === target);\n      const triggerCount = triggerCollection.length;\n\n      if (triggerIndex === -1) return;\n\n      // Prevents page scroll while user is navigating\n      event.preventDefault();\n\n      let nextIndex = triggerIndex;\n      const homeIndex = 0;\n      const endIndex = triggerCount - 1;\n\n      const moveNext = () => {\n        nextIndex = triggerIndex + 1;\n        if (nextIndex > endIndex) {\n          nextIndex = homeIndex;\n        }\n      };\n\n      const movePrev = () => {\n        nextIndex = triggerIndex - 1;\n        if (nextIndex < homeIndex) {\n          nextIndex = endIndex;\n        }\n      };\n\n      switch (event.key) {\n        case 'Home':\n          nextIndex = homeIndex;\n          break;\n        case 'End':\n          nextIndex = endIndex;\n          break;\n        case 'ArrowRight':\n          if (orientation === 'horizontal') {\n            if (isDirectionLTR) {\n              moveNext();\n            } else {\n              movePrev();\n            }\n          }\n          break;\n        case 'ArrowDown':\n          if (orientation === 'vertical') {\n            moveNext();\n          }\n          break;\n        case 'ArrowLeft':\n          if (orientation === 'horizontal') {\n            if (isDirectionLTR) {\n              movePrev();\n            } else {\n              moveNext();\n            }\n          }\n          break;\n        case 'ArrowUp':\n          if (orientation === 'vertical') {\n            movePrev();\n          }\n          break;\n      }\n\n      const clampedIndex = nextIndex % triggerCount;\n      triggerCollection[clampedIndex].ref.current?.focus();\n    });\n\n    return (\n      <AccordionImplProvider\n        scope={__scopeAccordion}\n        disabled={disabled}\n        direction={dir}\n        orientation={orientation}\n      >\n        <Collection.Slot scope={__scopeAccordion}>\n          <Primitive.div\n            {...accordionProps}\n            data-orientation={orientation}\n            ref={composedRefs}\n            onKeyDown={disabled ? undefined : handleKeyDown}\n          />\n        </Collection.Slot>\n      </AccordionImplProvider>\n    );\n  }\n);\n\n/* -------------------------------------------------------------------------------------------------\n * AccordionItem\n * -----------------------------------------------------------------------------------------------*/\n\nconst ITEM_NAME = 'AccordionItem';\n\ntype AccordionItemContextValue = { open?: boolean; disabled?: boolean; triggerId: string };\nconst [AccordionItemProvider, useAccordionItemContext] =\n  createAccordionContext<AccordionItemContextValue>(ITEM_NAME);\n\ntype AccordionItemElement = React.ElementRef<typeof CollapsiblePrimitive.Root>;\ntype CollapsibleProps = Radix.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Root>;\ninterface AccordionItemProps\n  extends Omit<CollapsibleProps, 'open' | 'defaultOpen' | 'onOpenChange'> {\n  /**\n   * Whether or not an accordion item is disabled from user interaction.\n   *\n   * @defaultValue false\n   */\n  disabled?: boolean;\n  /**\n   * A string value for the accordion item. All items within an accordion should use a unique value.\n   */\n  value: string;\n}\n\n/**\n * `AccordionItem` contains all of the parts of a collapsible section inside of an `Accordion`.\n */\nconst AccordionItem = React.forwardRef<AccordionItemElement, AccordionItemProps>(\n  (props: ScopedProps<AccordionItemProps>, forwardedRef) => {\n    const { __scopeAccordion, value, ...accordionItemProps } = props;\n    const accordionContext = useAccordionContext(ITEM_NAME, __scopeAccordion);\n    const valueContext = useAccordionValueContext(ITEM_NAME, __scopeAccordion);\n    const collapsibleScope = useCollapsibleScope(__scopeAccordion);\n    const triggerId = useId();\n    const open = (value && valueContext.value.includes(value)) || false;\n    const disabled = accordionContext.disabled || props.disabled;\n\n    return (\n      <AccordionItemProvider\n        scope={__scopeAccordion}\n        open={open}\n        disabled={disabled}\n        triggerId={triggerId}\n      >\n        <CollapsiblePrimitive.Root\n          data-orientation={accordionContext.orientation}\n          data-state={getState(open)}\n          {...collapsibleScope}\n          {...accordionItemProps}\n          ref={forwardedRef}\n          disabled={disabled}\n          open={open}\n          onOpenChange={(open) => {\n            if (open) {\n              valueContext.onItemOpen(value);\n            } else {\n              valueContext.onItemClose(value);\n            }\n          }}\n        />\n      </AccordionItemProvider>\n    );\n  }\n);\n\nAccordionItem.displayName = ITEM_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * AccordionHeader\n * -----------------------------------------------------------------------------------------------*/\n\nconst HEADER_NAME = 'AccordionHeader';\n\ntype AccordionHeaderElement = React.ElementRef<typeof Primitive.h3>;\ntype PrimitiveHeading3Props = Radix.ComponentPropsWithoutRef<typeof Primitive.h3>;\ninterface AccordionHeaderProps extends PrimitiveHeading3Props {}\n\n/**\n * `AccordionHeader` contains the content for the parts of an `AccordionItem` that will be visible\n * whether or not its content is collapsed.\n */\nconst AccordionHeader = React.forwardRef<AccordionHeaderElement, AccordionHeaderProps>(\n  (props: ScopedProps<AccordionHeaderProps>, forwardedRef) => {\n    const { __scopeAccordion, ...headerProps } = props;\n    const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion);\n    const itemContext = useAccordionItemContext(HEADER_NAME, __scopeAccordion);\n    return (\n      <Primitive.h3\n        data-orientation={accordionContext.orientation}\n        data-state={getState(itemContext.open)}\n        data-disabled={itemContext.disabled ? '' : undefined}\n        {...headerProps}\n        ref={forwardedRef}\n      />\n    );\n  }\n);\n\nAccordionHeader.displayName = HEADER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * AccordionTrigger\n * -----------------------------------------------------------------------------------------------*/\n\nconst TRIGGER_NAME = 'AccordionTrigger';\n\ntype AccordionTriggerElement = React.ElementRef<typeof CollapsiblePrimitive.Trigger>;\ntype CollapsibleTriggerProps = Radix.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Trigger>;\ninterface AccordionTriggerProps extends CollapsibleTriggerProps {}\n\n/**\n * `AccordionTrigger` is the trigger that toggles the collapsed state of an `AccordionItem`. It\n * should always be nested inside of an `AccordionHeader`.\n */\nconst AccordionTrigger = React.forwardRef<AccordionTriggerElement, AccordionTriggerProps>(\n  (props: ScopedProps<AccordionTriggerProps>, forwardedRef) => {\n    const { __scopeAccordion, ...triggerProps } = props;\n    const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion);\n    const itemContext = useAccordionItemContext(TRIGGER_NAME, __scopeAccordion);\n    const collapsibleContext = useAccordionCollapsibleContext(TRIGGER_NAME, __scopeAccordion);\n    const collapsibleScope = useCollapsibleScope(__scopeAccordion);\n    return (\n      <Collection.ItemSlot scope={__scopeAccordion}>\n        <CollapsiblePrimitive.Trigger\n          aria-disabled={(itemContext.open && !collapsibleContext.collapsible) || undefined}\n          data-orientation={accordionContext.orientation}\n          id={itemContext.triggerId}\n          {...collapsibleScope}\n          {...triggerProps}\n          ref={forwardedRef}\n        />\n      </Collection.ItemSlot>\n    );\n  }\n);\n\nAccordionTrigger.displayName = TRIGGER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * AccordionContent\n * -----------------------------------------------------------------------------------------------*/\n\nconst CONTENT_NAME = 'AccordionContent';\n\ntype AccordionContentElement = React.ElementRef<typeof CollapsiblePrimitive.Content>;\ntype CollapsibleContentProps = Radix.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Content>;\ninterface AccordionContentProps extends CollapsibleContentProps {}\n\n/**\n * `AccordionContent` contains the collapsible content for an `AccordionItem`.\n */\nconst AccordionContent = React.forwardRef<AccordionContentElement, AccordionContentProps>(\n  (props: ScopedProps<AccordionContentProps>, forwardedRef) => {\n    const { __scopeAccordion, ...contentProps } = props;\n    const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion);\n    const itemContext = useAccordionItemContext(CONTENT_NAME, __scopeAccordion);\n    const collapsibleScope = useCollapsibleScope(__scopeAccordion);\n    return (\n      <CollapsiblePrimitive.Content\n        role=\"region\"\n        aria-labelledby={itemContext.triggerId}\n        data-orientation={accordionContext.orientation}\n        {...collapsibleScope}\n        {...contentProps}\n        ref={forwardedRef}\n        style={{\n          ['--radix-accordion-content-height' as any]: 'var(--radix-collapsible-content-height)',\n          ['--radix-accordion-content-width' as any]: 'var(--radix-collapsible-content-width)',\n          ...props.style,\n        }}\n      />\n    );\n  }\n);\n\nAccordionContent.displayName = CONTENT_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction getState(open?: boolean) {\n  return open ? 'open' : 'closed';\n}\n\nconst Root = Accordion;\nconst Item = AccordionItem;\nconst Header = AccordionHeader;\nconst Trigger = AccordionTrigger;\nconst Content = AccordionContent;\n\nexport {\n  createAccordionScope,\n  //\n  Accordion,\n  AccordionItem,\n  AccordionHeader,\n  AccordionTrigger,\n  AccordionContent,\n  //\n  Root,\n  Item,\n  Header,\n  Trigger,\n  Content,\n};\nexport type {\n  AccordionSingleProps,\n  AccordionMultipleProps,\n  AccordionItemProps,\n  AccordionHeaderProps,\n  AccordionTriggerProps,\n  AccordionContentProps,\n};\n","import * as React from 'react';\nimport { IconProps } from './types';\n\nexport const ChevronDownIcon = React.forwardRef<SVGSVGElement, IconProps>(\n  ({ color = 'currentColor', ...props }, forwardedRef) => {\n    return (\n      <svg\n        width=\"15\"\n        height=\"15\"\n        viewBox=\"0 0 15 15\"\n        fill=\"none\"\n        xmlns=\"http://www.w3.org/2000/svg\"\n        {...props}\n        ref={forwardedRef}\n      >\n        <path\n          d=\"M3.13523 6.15803C3.3241 5.95657 3.64052 5.94637 3.84197 6.13523L7.5 9.56464L11.158 6.13523C11.3595 5.94637 11.6759 5.95657 11.8648 6.15803C12.0536 6.35949 12.0434 6.67591 11.842 6.86477L7.84197 10.6148C7.64964 10.7951 7.35036 10.7951 7.15803 10.6148L3.15803 6.86477C2.95657 6.67591 2.94637 6.35949 3.13523 6.15803Z\"\n          fill={color}\n          fillRule=\"evenodd\"\n          clipRule=\"evenodd\"\n        />\n      </svg>\n    );\n  }\n);\n\nexport default ChevronDownIcon;\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"]}