{"version":3,"file":"static/chunks/3694-09dd5a795e84d2df.js","mappings":"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","sources":["webpack://_N_E/../src/accordion.tsx","webpack://_N_E/../src/collapsible.tsx","webpack://_N_E/../src/collection.tsx","webpack://_N_E/../../node_modules/@radix-ui/react-direction/dist/index.mjs"],"sourcesContent":["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 { 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\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 = React.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 = React.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 = React.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 = React.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 = React.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 { 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 { 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 = React.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 = React.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>>(undefined);\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 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\ntype SlotProps = React.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 | null>;\n    itemMap: Map<\n      React.RefObject<ItemElement | null>,\n      { ref: React.RefObject<ItemElement | null> } & ItemData\n    >;\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","// packages/react/direction/src/Direction.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar DirectionContext = React.createContext(void 0);\nvar DirectionProvider = (props) => {\n  const { dir, children } = props;\n  return /* @__PURE__ */ jsx(DirectionContext.Provider, { value: dir, children });\n};\nfunction useDirection(localDir) {\n  const globalDir = React.useContext(DirectionContext);\n  return localDir || globalDir || \"ltr\";\n}\nvar Provider = DirectionProvider;\nexport {\n  DirectionProvider,\n  Provider,\n  useDirection\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["ACCORDION_NAME","ACCORDION_KEYS","Collection","useCollection","createCollectionScope","createCollection","createAccordionContext","createAccordionScope","createContextScope","createCollapsibleScope","useCollapsibleScope","Accordion","React","props","forwardedRef","type","accordionProps","jsx","Provider","scope","__scopeAccordion","children","AccordionImplMultiple","ref","AccordionImplSingle","displayName","AccordionValueProvider","useAccordionValueContext","AccordionCollapsibleProvider","useAccordionCollapsibleContext","collapsible","value","valueProp","defaultValue","onValueChange","accordionSingleProps","setValue","useControllableState","prop","defaultProp","onChange","onItemOpen","onItemClose","AccordionImpl","accordionMultipleProps","handleItemOpen","prevValue","itemValue","handleItemClose","filter","AccordionImplProvider","useAccordionContext","disabled","dir","orientation","accordionRef","composedRefs","useComposedRefs","getItems","isDirectionLTR","direction","useDirection","handleKeyDown","composeEventHandlers","onKeyDown","triggerCollection","includes","event","key","target","item","current","triggerIndex","findIndex","triggerCount","length","preventDefault","nextIndex","endIndex","moveNext","homeIndex","movePrev","focus","Slot","Primitive","div","ITEM_NAME","AccordionItemProvider","useAccordionItemContext","AccordionItem","accordionItemProps","accordionContext","valueContext","collapsibleScope","triggerId","useId","open","CollapsiblePrimitive","getState","onOpenChange","HEADER_NAME","AccordionHeader","headerProps","itemContext","h3","TRIGGER_NAME","AccordionTrigger","triggerProps","collapsibleContext","ItemSlot","id","CONTENT_NAME","AccordionContent","contentProps","role","style","Root","Item","Header","Trigger","Content","COLLAPSIBLE_NAME","createCollapsibleContext","CollapsibleProvider","useCollapsibleContext","Collapsible","__scopeCollapsible","openProp","defaultOpen","collapsibleProps","setOpen","contentId","onOpenToggle","prevOpen","CollapsibleTrigger","context","button","onClick","CollapsibleContent","forceMount","Presence","present","param","CollapsibleContentImpl","isPresent","setIsPresent","heightRef","height","widthRef","width","isOpen","isMountAnimationPreventedRef","originalStylesRef","rAF","requestAnimationFrame","cancelAnimationFrame","useLayoutEffect","node","transitionDuration","animationName","rect","getBoundingClientRect","hidden","concat","name","PROVIDER_NAME","createCollectionContext","CollectionProviderImpl","useCollectionContext","collectionRef","itemMap","Map","CollectionProvider","COLLECTION_SLOT_NAME","CollectionSlot","ITEM_SLOT_NAME","ITEM_DATA_ATTR","CollectionItemSlot","itemData","set","delete","collectionNode","orderedNodes","Array","from","querySelectorAll","items","values","sort","a","b","indexOf","DirectionContext","react__WEBPACK_IMPORTED_MODULE_0__","createContext","localDir","globalDir","useContext"],"sourceRoot":""}