{"version":3,"file":"static/js/8316.844254bf2bb8004edce6.js","mappings":"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","sources":["../node_modules/@mui/system/Stack/createStack.js","../node_modules/@mui/material/Stack/Stack.js","../node_modules/@base-ui-components/react/esm/dialog/close/useDialogClose.js","../node_modules/@base-ui-components/react/esm/dialog/root/DialogRootContext.js","../node_modules/@base-ui-components/react/esm/dialog/backdrop/DialogBackdrop.js","../node_modules/@base-ui-components/react/esm/dialog/close/DialogClose.js","../node_modules/@base-ui-components/react/esm/dialog/description/DialogDescription.js","../node_modules/@base-ui-components/react/esm/dialog/popup/DialogPopupCssVars.js","../node_modules/@base-ui-components/react/esm/dialog/popup/DialogPopupDataAttributes.js","../node_modules/@base-ui-components/react/esm/dialog/portal/DialogPortalContext.js","../node_modules/@base-ui-components/react/esm/dialog/popup/DialogPopup.js","../node_modules/@base-ui-components/react/esm/dialog/portal/DialogPortal.js","../node_modules/@base-ui-components/react/esm/dialog/root/DialogRoot.js","../node_modules/@base-ui-components/react/esm/dialog/title/DialogTitle.js","../node_modules/@base-ui-components/react/esm/dialog/trigger/DialogTrigger.js","../node_modules/@base-ui-components/react/esm/dialog/popup/useDialogPopup.js","../node_modules/@base-ui-components/react/esm/dialog/root/useDialogRoot.js","../node_modules/@base-ui-components/react/esm/utils/translateOpenChangeReason.js","../node_modules/@base-ui-components/react/esm/dialog/utils/DialogContext.js","../node_modules/@base-ui-components/react/esm/accordion/root/useAccordionRoot.js","../node_modules/@base-ui-components/react/esm/accordion/root/AccordionRootContext.js","../node_modules/@base-ui-components/react/esm/accordion/root/AccordionRoot.js","../node_modules/@base-ui-components/react/esm/collapsible/root/useCollapsibleRoot.js","../node_modules/@base-ui-components/react/esm/collapsible/root/CollapsibleRootContext.js","../node_modules/@base-ui-components/react/esm/accordion/item/AccordionItemContext.js","../node_modules/@base-ui-components/react/esm/utils/collapsibleOpenStateMapping.js","../node_modules/@base-ui-components/react/esm/accordion/item/styleHooks.js","../node_modules/@base-ui-components/react/esm/accordion/item/AccordionItem.js","../node_modules/@base-ui-components/react/esm/accordion/header/AccordionHeader.js","../node_modules/@base-ui-components/react/esm/collapsible/trigger/useCollapsibleTrigger.js","../node_modules/@base-ui-components/react/esm/accordion/trigger/AccordionTrigger.js","../node_modules/@base-ui-components/react/esm/collapsible/panel/useCollapsiblePanel.js","../node_modules/@base-ui-components/react/esm/accordion/panel/AccordionPanelCssVars.js","../node_modules/@base-ui-components/react/esm/accordion/panel/AccordionPanel.js","../node_modules/@base-ui-components/react/esm/alert-dialog/backdrop/AlertDialogBackdrop.js","../node_modules/@base-ui-components/react/esm/alert-dialog/popup/AlertDialogPopupDataAttributes.js","../node_modules/@base-ui-components/react/esm/alert-dialog/popup/AlertDialogPopup.js","../node_modules/@base-ui-components/react/esm/field/control/FieldControlDataAttributes.js","../node_modules/@base-ui-components/react/esm/field/utils/constants.js","../node_modules/@base-ui-components/react/esm/field/root/FieldRootContext.js","../node_modules/@base-ui-components/react/esm/utils/visuallyHidden.js","../node_modules/@base-ui-components/react/esm/form/FormContext.js","../node_modules/@base-ui-components/react/esm/field/utils/getCombinedFieldValidityData.js","../node_modules/@base-ui-components/react/esm/field/control/useFieldControlValidation.js","../node_modules/@base-ui-components/react/esm/checkbox-group/CheckboxGroup.js","../node_modules/@base-ui-components/react/esm/collapsible/root/styleHooks.js","../node_modules/@base-ui-components/react/esm/collapsible/root/CollapsibleRoot.js","../node_modules/@base-ui-components/react/esm/collapsible/trigger/CollapsibleTrigger.js","../node_modules/@base-ui-components/react/esm/collapsible/panel/CollapsiblePanelCssVars.js","../node_modules/@base-ui-components/react/esm/collapsible/panel/CollapsiblePanel.js","../node_modules/@base-ui-components/react/esm/menu/backdrop/MenuBackdrop.js","../node_modules/@base-ui-components/react/esm/menu/utils/styleHookMapping.js","../node_modules/@base-ui-components/react/esm/menu/popup/MenuPopup.js","../node_modules/@base-ui-components/react/esm/utils/useAnchorPositioning.js","../node_modules/@base-ui-components/react/esm/utils/formatNumber.js","../node_modules/@base-ui-components/react/esm/number-field/utils/parse.js","../node_modules/@base-ui-components/react/esm/popover/popup/PopoverPopup.js","../node_modules/@base-ui-components/react/esm/popover/backdrop/PopoverBackdrop.js","../node_modules/@base-ui-components/react/esm/preview-card/popup/PreviewCardPopup.js","../node_modules/@base-ui-components/react/esm/preview-card/backdrop/PreviewCardBackdrop.js","../node_modules/@base-ui-components/react/esm/radio-group/RadioGroupContext.js","../node_modules/@base-ui-components/react/esm/radio/utils/customStyleHookMapping.js","../node_modules/@base-ui-components/react/esm/select/root/useSelectRoot.js","../node_modules/@base-ui-components/react/esm/select/root/SelectRootContext.js","../node_modules/@base-ui-components/react/esm/select/root/SelectIndexContext.js","../node_modules/@base-ui-components/react/esm/select/root/SelectRoot.js","../node_modules/@base-ui-components/react/esm/select/trigger/useSelectTrigger.js","../node_modules/@base-ui-components/react/esm/utils/getPseudoElementBounds.js","../node_modules/@base-ui-components/react/esm/select/trigger/SelectTrigger.js","../node_modules/@base-ui-components/react/esm/select/portal/SelectPortalContext.js","../node_modules/@base-ui-components/react/esm/select/portal/SelectPortal.js","../node_modules/@base-ui-components/react/esm/select/backdrop/SelectBackdrop.js","../node_modules/@base-ui-components/react/esm/select/positioner/useSelectPositioner.js","../node_modules/@base-ui-components/react/esm/select/positioner/SelectPositionerContext.js","../node_modules/@base-ui-components/react/esm/select/positioner/SelectPositioner.js","../node_modules/@base-ui-components/react/esm/select/popup/utils.js","../node_modules/@base-ui-components/react/esm/select/popup/SelectPopup.js","../node_modules/@base-ui-components/react/esm/select/popup/useSelectPopup.js","../node_modules/@base-ui-components/react/esm/select/item/SelectItemContext.js","../node_modules/@base-ui-components/react/esm/select/item/SelectItem.js","../node_modules/@base-ui-components/react/esm/select/item/useSelectItem.js","../node_modules/@base-ui-components/react/esm/select/item-indicator/SelectItemIndicator.js","../node_modules/@base-ui-components/react/esm/tooltip/popup/TooltipPopup.js","../node_modules/@base-ui-components/react/esm/utils/InternalBackdrop.js","../node_modules/@base-ui-components/react/esm/utils/detectBrowser.js","../node_modules/@base-ui-components/react/esm/utils/popupStateMapping.js","../node_modules/@base-ui-components/react/esm/utils/styleHookMapping.js","../node_modules/@base-ui-components/react/esm/utils/useAnimationsFinished.js","../node_modules/@base-ui-components/react/esm/utils/useLatestRef.js","../node_modules/@base-ui-components/react/esm/utils/useOpenChangeComplete.js","../node_modules/@base-ui-components/react/esm/utils/useOpenInteractionType.js","../node_modules/@base-ui-components/react/esm/utils/useEnhancedClickHandler.js","../packages/@react-aria/utils/src/useLayoutEffect.ts","../packages/@react-aria/utils/src/platform.ts","../packages/@react-aria/utils/src/chain.ts","../packages/@react-aria/utils/src/isScrollable.ts","../packages/@react-aria/utils/src/getScrollParent.ts","../packages/@react-aria/overlays/src/usePreventScroll.ts","../node_modules/@base-ui-components/react/esm/utils/useScrollLock.js","../node_modules/@base-ui-components/react/esm/utils/useTransitionStatus.js","../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","../../src/index.js","../node_modules/@floating-ui/react/dist/floating-ui.react.mjs","../node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs","../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"],"sourcesContent":["import * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport deepmerge from '@mui/utils/deepmerge';\nimport generateUtilityClass from '@mui/utils/generateUtilityClass';\nimport composeClasses from '@mui/utils/composeClasses';\nimport systemStyled from \"../styled/index.js\";\nimport useThemePropsSystem from \"../useThemeProps/index.js\";\nimport { extendSxProp } from \"../styleFunctionSx/index.js\";\nimport createTheme from \"../createTheme/index.js\";\nimport { handleBreakpoints, mergeBreakpointsInOrder, resolveBreakpointValues } from \"../breakpoints/index.js\";\nimport { createUnarySpacing, getValue } from \"../spacing/index.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst defaultTheme = createTheme();\n// widening Theme to any so that the consumer can own the theme structure.\nconst defaultCreateStyledComponent = systemStyled('div', {\n  name: 'MuiStack',\n  slot: 'Root',\n  overridesResolver: (props, styles) => styles.root\n});\nfunction useThemePropsDefault(props) {\n  return useThemePropsSystem({\n    props,\n    name: 'MuiStack',\n    defaultTheme\n  });\n}\n\n/**\n * Return an array with the separator React element interspersed between\n * each React node of the input children.\n *\n * > joinChildren([1,2,3], 0)\n * [1,0,2,0,3]\n */\nfunction joinChildren(children, separator) {\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n  return childrenArray.reduce((output, child, index) => {\n    output.push(child);\n    if (index < childrenArray.length - 1) {\n      output.push(/*#__PURE__*/React.cloneElement(separator, {\n        key: `separator-${index}`\n      }));\n    }\n    return output;\n  }, []);\n}\nconst getSideFromDirection = direction => {\n  return {\n    row: 'Left',\n    'row-reverse': 'Right',\n    column: 'Top',\n    'column-reverse': 'Bottom'\n  }[direction];\n};\nexport const style = ({\n  ownerState,\n  theme\n}) => {\n  let styles = {\n    display: 'flex',\n    flexDirection: 'column',\n    ...handleBreakpoints({\n      theme\n    }, resolveBreakpointValues({\n      values: ownerState.direction,\n      breakpoints: theme.breakpoints.values\n    }), propValue => ({\n      flexDirection: propValue\n    }))\n  };\n  if (ownerState.spacing) {\n    const transformer = createUnarySpacing(theme);\n    const base = Object.keys(theme.breakpoints.values).reduce((acc, breakpoint) => {\n      if (typeof ownerState.spacing === 'object' && ownerState.spacing[breakpoint] != null || typeof ownerState.direction === 'object' && ownerState.direction[breakpoint] != null) {\n        acc[breakpoint] = true;\n      }\n      return acc;\n    }, {});\n    const directionValues = resolveBreakpointValues({\n      values: ownerState.direction,\n      base\n    });\n    const spacingValues = resolveBreakpointValues({\n      values: ownerState.spacing,\n      base\n    });\n    if (typeof directionValues === 'object') {\n      Object.keys(directionValues).forEach((breakpoint, index, breakpoints) => {\n        const directionValue = directionValues[breakpoint];\n        if (!directionValue) {\n          const previousDirectionValue = index > 0 ? directionValues[breakpoints[index - 1]] : 'column';\n          directionValues[breakpoint] = previousDirectionValue;\n        }\n      });\n    }\n    const styleFromPropValue = (propValue, breakpoint) => {\n      if (ownerState.useFlexGap) {\n        return {\n          gap: getValue(transformer, propValue)\n        };\n      }\n      return {\n        // The useFlexGap={false} implement relies on each child to give up control of the margin.\n        // We need to reset the margin to avoid double spacing.\n        '& > :not(style):not(style)': {\n          margin: 0\n        },\n        '& > :not(style) ~ :not(style)': {\n          [`margin${getSideFromDirection(breakpoint ? directionValues[breakpoint] : ownerState.direction)}`]: getValue(transformer, propValue)\n        }\n      };\n    };\n    styles = deepmerge(styles, handleBreakpoints({\n      theme\n    }, spacingValues, styleFromPropValue));\n  }\n  styles = mergeBreakpointsInOrder(theme.breakpoints, styles);\n  return styles;\n};\nexport default function createStack(options = {}) {\n  const {\n    // This will allow adding custom styled fn (for example for custom sx style function)\n    createStyledComponent = defaultCreateStyledComponent,\n    useThemeProps = useThemePropsDefault,\n    componentName = 'MuiStack'\n  } = options;\n  const useUtilityClasses = () => {\n    const slots = {\n      root: ['root']\n    };\n    return composeClasses(slots, slot => generateUtilityClass(componentName, slot), {});\n  };\n  const StackRoot = createStyledComponent(style);\n  const Stack = /*#__PURE__*/React.forwardRef(function Grid(inProps, ref) {\n    const themeProps = useThemeProps(inProps);\n    const props = extendSxProp(themeProps); // `color` type conflicts with html color attribute.\n    const {\n      component = 'div',\n      direction = 'column',\n      spacing = 0,\n      divider,\n      children,\n      className,\n      useFlexGap = false,\n      ...other\n    } = props;\n    const ownerState = {\n      direction,\n      spacing,\n      useFlexGap\n    };\n    const classes = useUtilityClasses();\n    return /*#__PURE__*/_jsx(StackRoot, {\n      as: component,\n      ownerState: ownerState,\n      ref: ref,\n      className: clsx(classes.root, className),\n      ...other,\n      children: divider ? joinChildren(children, divider) : children\n    });\n  });\n  process.env.NODE_ENV !== \"production\" ? Stack.propTypes /* remove-proptypes */ = {\n    children: PropTypes.node,\n    direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),\n    divider: PropTypes.node,\n    spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),\n    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n  } : void 0;\n  return Stack;\n}","'use client';\n\nimport PropTypes from 'prop-types';\nimport { createStack } from '@mui/system';\nimport styled from \"../styles/styled.js\";\nimport useThemeProps from \"../styles/useThemeProps.js\";\nconst Stack = createStack({\n  createStyledComponent: styled('div', {\n    name: 'MuiStack',\n    slot: 'Root',\n    overridesResolver: (props, styles) => styles.root\n  }),\n  useThemeProps: inProps => useThemeProps({\n    props: inProps,\n    name: 'MuiStack'\n  })\n});\nprocess.env.NODE_ENV !== \"production\" ? Stack.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n  /**\n   * Defines the `flex-direction` style property.\n   * It is applied for all screen sizes.\n   * @default 'column'\n   */\n  direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),\n  /**\n   * Add an element between each child.\n   */\n  divider: PropTypes.node,\n  /**\n   * Defines the space between immediate children.\n   * @default 0\n   */\n  spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),\n  /**\n   * The system prop, which allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n  /**\n   * If `true`, the CSS flexbox `gap` is used instead of applying `margin` to children.\n   *\n   * While CSS `gap` removes the [known limitations](https://mui.com/joy-ui/react-stack/#limitations),\n   * it is not fully supported in some browsers. We recommend checking https://caniuse.com/?search=flex%20gap before using this flag.\n   *\n   * To enable this flag globally, follow the [theme's default props](https://mui.com/material-ui/customization/theme-components/#default-props) configuration.\n   * @default false\n   */\n  useFlexGap: PropTypes.bool\n} : void 0;\nexport default Stack;","'use client';\n\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nexport function useDialogClose(params) {\n  const {\n    open,\n    setOpen\n  } = params;\n  const handleClick = useEventCallback(event => {\n    if (open) {\n      setOpen(false, event.nativeEvent, 'click');\n    }\n  });\n  const getRootProps = externalProps => mergeReactProps(externalProps, {\n    onClick: handleClick\n  });\n  return {\n    getRootProps\n  };\n}","'use client';\n\nimport * as React from 'react';\nimport { DialogContext } from '../utils/DialogContext.js';\nexport const DialogRootContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== 'production') {\n  DialogRootContext.displayName = 'DialogRootContext';\n}\nexport function useOptionalDialogRootContext() {\n  const dialogRootContext = React.useContext(DialogRootContext);\n  const dialogContext = React.useContext(DialogContext);\n  if (dialogContext === undefined && dialogRootContext === undefined) {\n    return undefined;\n  }\n  return {\n    ...dialogRootContext,\n    ...dialogContext\n  };\n}\nexport function useDialogRootContext() {\n  const dialogRootContext = React.useContext(DialogRootContext);\n  const dialogContext = React.useContext(DialogContext);\n  if (dialogContext === undefined) {\n    throw new Error('Base UI: DialogRootContext is missing. Dialog parts must be placed within <Dialog.Root>.');\n  }\n  return {\n    ...dialogRootContext,\n    ...dialogContext\n  };\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * An overlay displayed beneath the popup.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nconst DialogBackdrop = /*#__PURE__*/React.forwardRef(function DialogBackdrop(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    open,\n    nested,\n    mounted,\n    transitionStatus,\n    backdropRef\n  } = useDialogRootContext();\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus\n  }), [open, transitionStatus]);\n  const mergedRef = useForkRef(backdropRef, forwardedRef);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: mergedRef,\n    extraProps: {\n      role: 'presentation',\n      hidden: !mounted,\n      ...other\n    },\n    customStyleHookMapping\n  });\n\n  // no need to render nested backdrops\n  const shouldRender = !nested;\n  if (!shouldRender) {\n    return null;\n  }\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { DialogBackdrop };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useDialogClose } from './useDialogClose.js';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nconst state = {};\n\n/**\n * A button that closes the dialog.\n * Renders a `<button>` element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nconst DialogClose = /*#__PURE__*/React.forwardRef(function DialogClose(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    open,\n    setOpen\n  } = useDialogRootContext();\n  const {\n    getRootProps\n  } = useDialogClose({\n    open,\n    setOpen\n  });\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'button',\n    className,\n    state,\n    propGetter: getRootProps,\n    ref: forwardedRef,\n    extraProps: other\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogClose.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { DialogClose };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nconst state = {};\n\n/**\n * A paragraph with additional information about the dialog.\n * Renders a `<p>` element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nconst DialogDescription = /*#__PURE__*/React.forwardRef(function DialogDescription(props, forwardedRef) {\n  const {\n    render,\n    className,\n    id: idProp,\n    ...other\n  } = props;\n  const {\n    setDescriptionElementId\n  } = useDialogRootContext();\n  const id = useBaseUiId(idProp);\n  useEnhancedEffect(() => {\n    setDescriptionElementId(id);\n    return () => {\n      setDescriptionElementId(undefined);\n    };\n  }, [id, setDescriptionElementId]);\n  const getProps = React.useCallback((externalProps = {}) => mergeReactProps(externalProps, {\n    id\n  }), [id]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getProps,\n    render: render ?? 'p',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: other\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogDescription.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { DialogDescription };","export let DialogPopupCssVars = /*#__PURE__*/function (DialogPopupCssVars) {\n  DialogPopupCssVars[\"nestedDialogs\"] = \"--nested-dialogs\";\n  return DialogPopupCssVars;\n}({});","export let DialogPopupDataAttributes = /*#__PURE__*/function (DialogPopupDataAttributes) {\n  DialogPopupDataAttributes[\"open\"] = \"data-open\";\n  DialogPopupDataAttributes[\"closed\"] = \"data-closed\";\n  DialogPopupDataAttributes[\"startingStyle\"] = \"data-starting-style\";\n  DialogPopupDataAttributes[\"endingStyle\"] = \"data-ending-style\";\n  DialogPopupDataAttributes[\"nested\"] = \"data-nested\";\n  DialogPopupDataAttributes[\"hasNestedDialogs\"] = \"data-has-nested-dialogs\";\n  return DialogPopupDataAttributes;\n}({});","import * as React from 'react';\nexport const DialogPortalContext = /*#__PURE__*/React.createContext(undefined);\nexport function useDialogPortalContext() {\n  const value = React.useContext(DialogPortalContext);\n  if (value === undefined) {\n    throw new Error('Base UI: <Dialog.Portal> is missing.');\n  }\n  return value;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingFocusManager } from '@floating-ui/react';\nimport { useDialogPopup } from './useDialogPopup.js';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { refType } from '../../utils/proptypes.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { DialogPopupCssVars } from './DialogPopupCssVars.js';\nimport { DialogPopupDataAttributes } from './DialogPopupDataAttributes.js';\nimport { InternalBackdrop } from '../../utils/InternalBackdrop.js';\nimport { useDialogPortalContext } from '../portal/DialogPortalContext.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping,\n  hasNestedDialogs(value) {\n    return value ? {\n      [DialogPopupDataAttributes.hasNestedDialogs]: ''\n    } : null;\n  }\n};\n\n/**\n * A container for the dialog contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nconst DialogPopup = /*#__PURE__*/React.forwardRef(function DialogPopup(props, forwardedRef) {\n  const {\n    className,\n    finalFocus,\n    id,\n    initialFocus,\n    render,\n    ...other\n  } = props;\n  const {\n    descriptionElementId,\n    dismissible,\n    floatingRootContext,\n    getPopupProps,\n    modal,\n    mounted,\n    nested,\n    nestedOpenDialogCount,\n    setOpen,\n    open,\n    openMethod,\n    popupRef,\n    setPopupElement,\n    setPopupElementId,\n    titleElementId,\n    transitionStatus,\n    onOpenChangeComplete,\n    internalBackdropRef\n  } = useDialogRootContext();\n  useDialogPortalContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const mergedRef = useForkRef(forwardedRef, popupRef);\n  const {\n    getRootProps,\n    resolvedInitialFocus\n  } = useDialogPopup({\n    descriptionElementId,\n    getPopupProps,\n    id,\n    initialFocus,\n    modal,\n    mounted,\n    setOpen,\n    openMethod,\n    ref: mergedRef,\n    setPopupElement,\n    setPopupElementId,\n    titleElementId\n  });\n  const state = {\n    open,\n    nested,\n    transitionStatus,\n    hasNestedDialogs: nestedOpenDialogCount > 0\n  };\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    propGetter: getRootProps,\n    extraProps: {\n      ...other,\n      style: {\n        ...other.style,\n        [DialogPopupCssVars.nestedDialogs]: nestedOpenDialogCount\n      }\n    },\n    customStyleHookMapping\n  });\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [mounted && modal && /*#__PURE__*/_jsx(InternalBackdrop, {\n      ref: internalBackdropRef,\n      inert: !open\n    }), /*#__PURE__*/_jsx(FloatingFocusManager, {\n      context: floatingRootContext,\n      disabled: !mounted,\n      closeOnFocusOut: dismissible,\n      initialFocus: resolvedInitialFocus,\n      returnFocus: finalFocus,\n      children: renderElement()\n    })]\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Determines the element to focus when the dialog is closed.\n   * By default, focus returns to the trigger.\n   */\n  finalFocus: refType,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Determines the element to focus when the dialog is opened.\n   * By default, the first focusable element is focused.\n   */\n  initialFocus: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.func, refType]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * @ignore\n   */\n  style: PropTypes.object\n} : void 0;\nexport { DialogPopup };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingPortal } from '@floating-ui/react';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { DialogPortalContext } from './DialogPortalContext.js';\nimport { HTMLElementType, refType } from '../../utils/proptypes.js';\n\n/**\n * A portal element that moves the popup to a different part of the DOM.\n * By default, the portal element is appended to `<body>`.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction DialogPortal(props) {\n  const {\n    children,\n    keepMounted = false,\n    container\n  } = props;\n  const {\n    mounted\n  } = useDialogRootContext();\n  const shouldRender = mounted || keepMounted;\n  if (!shouldRender) {\n    return null;\n  }\n  return /*#__PURE__*/_jsx(DialogPortalContext.Provider, {\n    value: keepMounted,\n    children: /*#__PURE__*/_jsx(FloatingPortal, {\n      root: container,\n      children: children\n    })\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? DialogPortal.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * A parent element to render the portal element into.\n   */\n  container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, refType]),\n  /**\n   * Whether to keep the portal mounted in the DOM while the popup is hidden.\n   * @default false\n   */\n  keepMounted: PropTypes.bool\n} : void 0;\nexport { DialogPortal };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { DialogRootContext, useOptionalDialogRootContext } from './DialogRootContext.js';\nimport { DialogContext } from '../utils/DialogContext.js';\nimport { useDialogRoot } from './useDialogRoot.js';\n\n/**\n * Groups all parts of the dialog.\n * Doesn’t render its own HTML element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst DialogRoot = function DialogRoot(props) {\n  const {\n    children,\n    defaultOpen = false,\n    dismissible = true,\n    modal = true,\n    onOpenChange,\n    open,\n    onOpenChangeComplete\n  } = props;\n  const parentDialogRootContext = useOptionalDialogRootContext();\n  const dialogRoot = useDialogRoot({\n    open,\n    defaultOpen,\n    onOpenChange,\n    modal,\n    dismissible,\n    onOpenChangeComplete,\n    onNestedDialogClose: parentDialogRootContext?.onNestedDialogClose,\n    onNestedDialogOpen: parentDialogRootContext?.onNestedDialogOpen\n  });\n  const nested = Boolean(parentDialogRootContext);\n  const dialogContextValue = React.useMemo(() => ({\n    ...dialogRoot,\n    nested,\n    onOpenChangeComplete\n  }), [dialogRoot, nested, onOpenChangeComplete]);\n  const dialogRootContextValue = React.useMemo(() => ({\n    dismissible\n  }), [dismissible]);\n  return /*#__PURE__*/_jsx(DialogContext.Provider, {\n    value: dialogContextValue,\n    children: /*#__PURE__*/_jsx(DialogRootContext.Provider, {\n      value: dialogRootContextValue,\n      children: children\n    })\n  });\n};\nprocess.env.NODE_ENV !== \"production\" ? DialogRoot.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * Whether the dialog is initially open.\n   *\n   * To render a controlled dialog, use the `open` prop instead.\n   * @default false\n   */\n  defaultOpen: PropTypes.bool,\n  /**\n   * Determines whether the dialog should close on outside clicks.\n   * @default true\n   */\n  dismissible: PropTypes.bool,\n  /**\n   * Whether the dialog should prevent outside clicks and lock page scroll when open.\n   * @default true\n   */\n  modal: PropTypes.bool,\n  /**\n   * Event handler called when the dialog is opened or closed.\n   */\n  onOpenChange: PropTypes.func,\n  /**\n   * Event handler called after any animations complete when the dialog is opened or closed.\n   */\n  onOpenChangeComplete: PropTypes.func,\n  /**\n   * Whether the dialog is currently open.\n   */\n  open: PropTypes.bool\n} : void 0;\nexport { DialogRoot };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nconst state = {};\n\n/**\n * A heading that labels the dialog.\n * Renders an `<h2>` element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nconst DialogTitle = /*#__PURE__*/React.forwardRef(function DialogTitle(props, forwardedRef) {\n  const {\n    render,\n    className,\n    id: idProp,\n    ...other\n  } = props;\n  const {\n    setTitleElementId\n  } = useDialogRootContext();\n  const id = useBaseUiId(idProp);\n  useEnhancedEffect(() => {\n    setTitleElementId(id);\n    return () => {\n      setTitleElementId(undefined);\n    };\n  }, [id, setTitleElementId]);\n  const getProps = React.useCallback((externalProps = {}) => mergeReactProps(externalProps, {\n    id\n  }), [id]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getProps,\n    render: render ?? 'h2',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: other\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogTitle.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { DialogTitle };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useDialogRootContext } from '../root/DialogRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { triggerOpenStateMapping } from '../../utils/popupStateMapping.js';\n\n/**\n * A button that opens the dialog.\n * Renders a `<button>` element.\n *\n * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)\n */\nconst DialogTrigger = /*#__PURE__*/React.forwardRef(function DialogTrigger(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    open,\n    setTriggerElement,\n    getTriggerProps\n  } = useDialogRootContext();\n  const state = React.useMemo(() => ({\n    open\n  }), [open]);\n  const mergedRef = useForkRef(forwardedRef, setTriggerElement);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'button',\n    className,\n    state,\n    propGetter: getTriggerProps,\n    extraProps: other,\n    customStyleHookMapping: triggerOpenStateMapping,\n    ref: mergedRef\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogTrigger.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { DialogTrigger };","'use client';\n\nimport * as React from 'react';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nexport function useDialogPopup(parameters) {\n  const {\n    descriptionElementId,\n    getPopupProps,\n    id: idParam,\n    initialFocus,\n    modal,\n    mounted,\n    openMethod,\n    ref,\n    setPopupElementId,\n    setPopupElement,\n    titleElementId\n  } = parameters;\n  const popupRef = React.useRef(null);\n  const id = useBaseUiId(idParam);\n  const handleRef = useForkRef(ref, popupRef, setPopupElement);\n\n  // Default initial focus logic:\n  // If opened by touch, focus the popup element to prevent the virtual keyboard from opening\n  // (this is required for Android specifically as iOS handles this automatically).\n  const defaultInitialFocus = React.useCallback(interactionType => {\n    if (interactionType === 'touch') {\n      return popupRef;\n    }\n    return 0;\n  }, []);\n  const resolvedInitialFocus = React.useMemo(() => {\n    if (initialFocus == null) {\n      return defaultInitialFocus(openMethod ?? '');\n    }\n    if (typeof initialFocus === 'function') {\n      return initialFocus(openMethod ?? '');\n    }\n    return initialFocus;\n  }, [defaultInitialFocus, initialFocus, openMethod]);\n  useEnhancedEffect(() => {\n    setPopupElementId(id);\n    return () => {\n      setPopupElementId(undefined);\n    };\n  }, [id, setPopupElementId]);\n  const getRootProps = externalProps => mergeReactProps(externalProps, {\n    'aria-labelledby': titleElementId ?? undefined,\n    'aria-describedby': descriptionElementId ?? undefined,\n    'aria-modal': mounted && modal ? true : undefined,\n    role: 'dialog',\n    tabIndex: -1,\n    ...getPopupProps(),\n    id,\n    ref: handleRef,\n    hidden: !mounted\n  });\n  return {\n    getRootProps,\n    resolvedInitialFocus\n  };\n}","'use client';\n\nimport * as React from 'react';\nimport { useClick, useDismiss, useFloatingRootContext, useInteractions } from '@floating-ui/react';\nimport { getTarget } from '@floating-ui/react/utils';\nimport { useControlled } from '../../utils/useControlled.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { useScrollLock } from '../../utils/useScrollLock.js';\nimport { useTransitionStatus } from '../../utils/useTransitionStatus.js';\nimport { useOpenInteractionType } from '../../utils/useOpenInteractionType.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nimport { translateOpenChangeReason } from '../../utils/translateOpenChangeReason.js';\nexport function useDialogRoot(params) {\n  const {\n    defaultOpen,\n    dismissible,\n    modal,\n    onNestedDialogClose,\n    onNestedDialogOpen,\n    onOpenChange: onOpenChangeParameter,\n    open: openParam,\n    onOpenChangeComplete\n  } = params;\n  const [open, setOpenUnwrapped] = useControlled({\n    controlled: openParam,\n    default: defaultOpen,\n    name: 'DialogRoot',\n    state: 'open'\n  });\n  const popupRef = React.useRef(null);\n  const backdropRef = React.useRef(null);\n  const internalBackdropRef = React.useRef(null);\n  const [titleElementId, setTitleElementId] = React.useState(undefined);\n  const [descriptionElementId, setDescriptionElementId] = React.useState(undefined);\n  const [triggerElement, setTriggerElement] = React.useState(null);\n  const [popupElement, setPopupElement] = React.useState(null);\n  const [popupElementId, setPopupElementId] = React.useState(undefined);\n  const {\n    mounted,\n    setMounted,\n    transitionStatus\n  } = useTransitionStatus(open);\n  const setOpen = useEventCallback((nextOpen, event, reason) => {\n    onOpenChangeParameter?.(nextOpen, event, reason);\n    setOpenUnwrapped(nextOpen);\n  });\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (!open) {\n        onOpenChangeComplete?.(false);\n        setMounted(false);\n      }\n    }\n  });\n  useScrollLock(open && modal, popupElement);\n  const handleFloatingUIOpenChange = (nextOpen, event, reason) => {\n    setOpen(nextOpen, event, translateOpenChangeReason(reason));\n  };\n  const context = useFloatingRootContext({\n    elements: {\n      reference: triggerElement,\n      floating: popupElement\n    },\n    open,\n    onOpenChange: handleFloatingUIOpenChange\n  });\n  const [ownNestedOpenDialogs, setOwnNestedOpenDialogs] = React.useState(0);\n  const isTopmost = ownNestedOpenDialogs === 0;\n  const click = useClick(context);\n  const dismiss = useDismiss(context, {\n    outsidePressEvent: 'mousedown',\n    outsidePress(event) {\n      const target = getTarget(event);\n      if (isTopmost && dismissible) {\n        const backdrop = target;\n        // Only close if the click occurred on the dialog's owning backdrop.\n        // This supports multiple modal dialogs that aren't nested in the React tree:\n        // https://github.com/mui/base-ui/issues/1320\n        if (modal) {\n          return backdrop ? [internalBackdropRef.current, backdropRef.current].includes(backdrop) : false;\n        }\n        return true;\n      }\n      return false;\n    },\n    escapeKey: isTopmost\n  });\n  const {\n    getReferenceProps,\n    getFloatingProps\n  } = useInteractions([click, dismiss]);\n  React.useEffect(() => {\n    if (onNestedDialogOpen && open) {\n      onNestedDialogOpen(ownNestedOpenDialogs);\n    }\n    if (onNestedDialogClose && !open) {\n      onNestedDialogClose();\n    }\n    return () => {\n      if (onNestedDialogClose && open) {\n        onNestedDialogClose();\n      }\n    };\n  }, [open, onNestedDialogClose, onNestedDialogOpen, ownNestedOpenDialogs]);\n  const handleNestedDialogOpen = React.useCallback(ownChildrenCount => {\n    setOwnNestedOpenDialogs(ownChildrenCount + 1);\n  }, []);\n  const handleNestedDialogClose = React.useCallback(() => {\n    setOwnNestedOpenDialogs(0);\n  }, []);\n  const {\n    openMethod,\n    triggerProps\n  } = useOpenInteractionType(open);\n  return React.useMemo(() => {\n    return {\n      modal,\n      setOpen,\n      open,\n      titleElementId,\n      setTitleElementId,\n      descriptionElementId,\n      setDescriptionElementId,\n      popupElementId,\n      setPopupElementId,\n      onNestedDialogOpen: handleNestedDialogOpen,\n      onNestedDialogClose: handleNestedDialogClose,\n      nestedOpenDialogCount: ownNestedOpenDialogs,\n      openMethod,\n      mounted,\n      transitionStatus,\n      getTriggerProps: externalProps => getReferenceProps(mergeReactProps(externalProps, triggerProps)),\n      getPopupProps: getFloatingProps,\n      setTriggerElement,\n      setPopupElement,\n      popupRef,\n      backdropRef,\n      internalBackdropRef,\n      floatingRootContext: context\n    };\n  }, [modal, open, setOpen, titleElementId, descriptionElementId, popupElementId, handleNestedDialogClose, handleNestedDialogOpen, ownNestedOpenDialogs, openMethod, mounted, transitionStatus, getReferenceProps, getFloatingProps, setTriggerElement, setPopupElement, triggerProps, popupRef, context]);\n}","export function translateOpenChangeReason(nativeReason) {\n  if (!nativeReason) {\n    return undefined;\n  }\n  return {\n    // Identical mappings\n    click: 'click',\n    hover: 'hover',\n    focus: 'focus',\n    'focus-out': 'focus-out',\n    'escape-key': 'escape-key',\n    'outside-press': 'outside-press',\n    // New mappings\n    'reference-press': 'trigger-press',\n    'safe-polygon': 'hover',\n    'ancestor-scroll': undefined,\n    // Not supported\n    'list-navigation': undefined // Unnecessary to expose currently\n  }[nativeReason];\n}","'use client';\n\nimport * as React from 'react';\n\n/**\n * Common context for dialog & dialog alert components.\n */\n\nexport const DialogContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== 'production') {\n  DialogContext.displayName = 'DialogContext';\n}\nexport function useDialogContext() {\n  return React.useContext(DialogContext);\n}","'use client';\n\nimport * as React from 'react';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useControlled } from '../../utils/useControlled.js';\nimport { ARROW_DOWN, ARROW_UP, ARROW_RIGHT, ARROW_LEFT } from '../../composite/composite.js';\nconst SUPPORTED_KEYS = [ARROW_DOWN, ARROW_UP, ARROW_RIGHT, ARROW_LEFT, 'Home', 'End'];\nfunction getActiveTriggers(accordionItemRefs) {\n  const {\n    current: accordionItemElements\n  } = accordionItemRefs;\n  const output = [];\n  for (let i = 0; i < accordionItemElements.length; i += 1) {\n    const section = accordionItemElements[i];\n    if (!isDisabled(section)) {\n      const trigger = section?.querySelector('[type=\"button\"]');\n      if (!isDisabled(trigger)) {\n        output.push(trigger);\n      }\n    }\n  }\n  return output;\n}\nfunction isDisabled(element) {\n  return element === null || element.hasAttribute('disabled') || element.hasAttribute('data-disabled');\n}\nexport function useAccordionRoot(parameters) {\n  const {\n    disabled,\n    direction,\n    loop,\n    onValueChange,\n    orientation,\n    openMultiple,\n    value: valueParam,\n    defaultValue\n  } = parameters;\n  const accordionItemRefs = React.useRef([]);\n  const [value, setValue] = useControlled({\n    controlled: valueParam,\n    default: defaultValue,\n    name: 'Accordion',\n    state: 'value'\n  });\n  const handleValueChange = React.useCallback((newValue, nextOpen) => {\n    if (!openMultiple) {\n      const nextValue = value[0] === newValue ? [] : [newValue];\n      setValue(nextValue);\n      onValueChange?.(nextValue);\n    } else if (nextOpen) {\n      const nextOpenValues = value.slice();\n      nextOpenValues.push(newValue);\n      setValue(nextOpenValues);\n      onValueChange?.(nextOpenValues);\n    } else {\n      const nextOpenValues = value.filter(v => v !== newValue);\n      setValue(nextOpenValues);\n      onValueChange?.(nextOpenValues);\n    }\n  }, [onValueChange, openMultiple, setValue, value]);\n  const getRootProps = React.useCallback((externalProps = {}) => {\n    const isRtl = direction === 'rtl';\n    const isHorizontal = orientation === 'horizontal';\n    return mergeReactProps(externalProps, {\n      dir: direction,\n      role: 'region',\n      onKeyDown(event) {\n        if (!SUPPORTED_KEYS.includes(event.key)) {\n          return;\n        }\n        event.preventDefault();\n        const triggers = getActiveTriggers(accordionItemRefs);\n        const numOfEnabledTriggers = triggers.length;\n        const lastIndex = numOfEnabledTriggers - 1;\n        let nextIndex = -1;\n        const thisIndex = triggers.indexOf(event.target);\n        function toNext() {\n          if (loop) {\n            nextIndex = thisIndex + 1 > lastIndex ? 0 : thisIndex + 1;\n          } else {\n            nextIndex = Math.min(thisIndex + 1, lastIndex);\n          }\n        }\n        function toPrev() {\n          if (loop) {\n            nextIndex = thisIndex === 0 ? lastIndex : thisIndex - 1;\n          } else {\n            nextIndex = thisIndex - 1;\n          }\n        }\n        switch (event.key) {\n          case ARROW_DOWN:\n            if (!isHorizontal) {\n              toNext();\n            }\n            break;\n          case ARROW_UP:\n            if (!isHorizontal) {\n              toPrev();\n            }\n            break;\n          case ARROW_RIGHT:\n            if (isHorizontal) {\n              if (isRtl) {\n                toPrev();\n              } else {\n                toNext();\n              }\n            }\n            break;\n          case ARROW_LEFT:\n            if (isHorizontal) {\n              if (isRtl) {\n                toNext();\n              } else {\n                toPrev();\n              }\n            }\n            break;\n          case 'Home':\n            nextIndex = 0;\n            break;\n          case 'End':\n            nextIndex = lastIndex;\n            break;\n          default:\n            break;\n        }\n        if (nextIndex > -1) {\n          triggers[nextIndex].focus();\n        }\n      }\n    });\n  }, [direction, loop, orientation]);\n  return React.useMemo(() => ({\n    getRootProps,\n    accordionItemRefs,\n    direction,\n    disabled,\n    handleValueChange,\n    orientation,\n    value\n  }), [getRootProps, accordionItemRefs, direction, disabled, handleValueChange, orientation, value]);\n}","'use client';\n\nimport * as React from 'react';\nexport const AccordionRootContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== 'production') {\n  AccordionRootContext.displayName = 'AccordionRootContext';\n}\nexport function useAccordionRootContext() {\n  const context = React.useContext(AccordionRootContext);\n  if (context === undefined) {\n    throw new Error('Base UI: AccordionRootContext is missing. Accordion parts must be placed within <Accordion.Root>.');\n  }\n  return context;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { NOOP } from '../../utils/noop.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { warn } from '../../utils/warn.js';\nimport { CompositeList } from '../../composite/list/CompositeList.js';\nimport { useDirection } from '../../direction-provider/DirectionContext.js';\nimport { useAccordionRoot } from './useAccordionRoot.js';\nimport { AccordionRootContext } from './AccordionRootContext.js';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst rootStyleHookMapping = {\n  value: () => null\n};\n\n/**\n * Groups all parts of the accordion.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Accordion](https://base-ui.com/react/components/accordion)\n */\nconst AccordionRoot = /*#__PURE__*/React.forwardRef(function AccordionRoot(props, forwardedRef) {\n  const {\n    className,\n    disabled = false,\n    hiddenUntilFound: hiddenUntilFoundProp,\n    keepMounted: keepMountedProp,\n    loop = true,\n    onValueChange: onValueChangeProp,\n    openMultiple = true,\n    orientation = 'vertical',\n    value,\n    defaultValue: defaultValueProp,\n    render,\n    ...otherProps\n  } = props;\n  const direction = useDirection();\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEnhancedEffect(() => {\n      if (hiddenUntilFoundProp && keepMountedProp === false) {\n        warn('The `keepMounted={false}` prop on a Accordion.Root will be ignored when using `hiddenUntilFound` since it requires Panels to remain mounted when closed.');\n      }\n    }, [hiddenUntilFoundProp, keepMountedProp]);\n  }\n\n  // memoized to allow omitting both defaultValue and value\n  // which would otherwise trigger a warning in useControlled\n  const defaultValue = React.useMemo(() => {\n    if (value === undefined) {\n      return defaultValueProp ?? [];\n    }\n    return undefined;\n  }, [value, defaultValueProp]);\n  const {\n    getRootProps,\n    ...accordion\n  } = useAccordionRoot({\n    direction,\n    disabled,\n    defaultValue,\n    loop,\n    orientation,\n    onValueChange: onValueChangeProp ?? NOOP,\n    openMultiple,\n    value\n  });\n  const state = React.useMemo(() => ({\n    value: accordion.value,\n    disabled: accordion.disabled,\n    orientation: accordion.orientation\n  }), [accordion.value, accordion.disabled, accordion.orientation]);\n  const contextValue = React.useMemo(() => ({\n    ...accordion,\n    hiddenUntilFound: hiddenUntilFoundProp ?? false,\n    keepMounted: keepMountedProp ?? false,\n    state\n  }), [accordion, hiddenUntilFoundProp, keepMountedProp, state]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootProps,\n    render: render ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: otherProps,\n    customStyleHookMapping: rootStyleHookMapping\n  });\n  return /*#__PURE__*/_jsx(AccordionRootContext.Provider, {\n    value: contextValue,\n    children: /*#__PURE__*/_jsx(CompositeList, {\n      elementsRef: accordion.accordionItemRefs,\n      children: renderElement()\n    })\n  });\n});\nexport { AccordionRoot };\nprocess.env.NODE_ENV !== \"production\" ? AccordionRoot.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * The uncontrolled value of the item(s) that should be initially expanded.\n   *\n   * To render a controlled accordion, use the `value` prop instead.\n   */\n  defaultValue: PropTypes.array,\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Allows the browser’s built-in page search to find and expand the panel contents.\n   *\n   * Overrides the `keepMounted` prop and uses `hidden=\"until-found\"`\n   * to hide the element without removing it from the DOM.\n   * @default false\n   */\n  hiddenUntilFound: PropTypes.bool,\n  /**\n   * Whether to keep the element in the DOM while the panel is closed.\n   * This prop is ignored when `hiddenUntilFound` is used.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Whether to loop keyboard focus back to the first item\n   * when the end of the list is reached while using the arrow keys.\n   * @default true\n   */\n  loop: PropTypes.bool,\n  /**\n   * Event handler called when an accordion item is expanded or collapsed.\n   * Provides the new value as an argument.\n   */\n  onValueChange: PropTypes.func,\n  /**\n   * Whether multiple items can be open at the same time.\n   * @default true\n   */\n  openMultiple: PropTypes.bool,\n  /**\n   * The visual orientation of the accordion.\n   * Controls whether roving focus uses left/right or up/down arrow keys.\n   * @default 'vertical'\n   */\n  orientation: PropTypes.oneOf(['horizontal', 'vertical']),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * The controlled value of the item(s) that should be expanded.\n   *\n   * To render an uncontrolled accordion, use the `defaultValue` prop instead.\n   */\n  value: PropTypes.array\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport { useControlled } from '../../utils/useControlled.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { useTransitionStatus } from '../../utils/useTransitionStatus.js';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nexport function useCollapsibleRoot(parameters) {\n  const {\n    open: openParam,\n    defaultOpen,\n    onOpenChange,\n    disabled\n  } = parameters;\n  const [open, setOpenState] = useControlled({\n    controlled: openParam,\n    default: defaultOpen,\n    name: 'Collapsible',\n    state: 'open'\n  });\n  const {\n    mounted,\n    setMounted,\n    transitionStatus\n  } = useTransitionStatus(open, true);\n  const [panelId, setPanelId] = React.useState(useBaseUiId());\n  const setOpen = useEventCallback(nextOpen => {\n    onOpenChange?.(nextOpen);\n    setOpenState(nextOpen);\n  });\n  return React.useMemo(() => ({\n    panelId,\n    disabled,\n    mounted,\n    open,\n    setPanelId,\n    setMounted,\n    setOpen,\n    transitionStatus\n  }), [panelId, disabled, mounted, open, setPanelId, setMounted, setOpen, transitionStatus]);\n}","'use client';\n\nimport * as React from 'react';\nexport const CollapsibleRootContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== 'production') {\n  CollapsibleRootContext.displayName = 'CollapsibleRootContext';\n}\nexport function useCollapsibleRootContext() {\n  const context = React.useContext(CollapsibleRootContext);\n  if (context === undefined) {\n    throw new Error('Base UI: CollapsibleRootContext is missing. Collapsible parts must be placed within <Collapsible.Root>.');\n  }\n  return context;\n}","'use client';\n\nimport * as React from 'react';\nexport const AccordionItemContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== 'production') {\n  AccordionItemContext.displayName = 'AccordionItemContext';\n}\nexport function useAccordionItemContext() {\n  const context = React.useContext(AccordionItemContext);\n  if (context === undefined) {\n    throw new Error('Base UI: AccordionItemContext is missing. Accordion parts must be placed within <Accordion.Item>.');\n  }\n  return context;\n}","const PANEL_OPEN_HOOK = {\n  'data-open': ''\n};\nconst PANEL_CLOSED_HOOK = {\n  'data-closed': ''\n};\nexport const triggerOpenStateMapping = {\n  open(value) {\n    if (value) {\n      return {\n        'data-panel-open': ''\n      };\n    }\n    return null;\n  }\n};\nexport const collapsibleOpenStateMapping = {\n  open(value) {\n    if (value) {\n      return PANEL_OPEN_HOOK;\n    }\n    return PANEL_CLOSED_HOOK;\n  }\n};","import { collapsibleOpenStateMapping as baseMapping } from '../../utils/collapsibleOpenStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nexport const accordionStyleHookMapping = {\n  ...baseMapping,\n  index: value => {\n    return Number.isInteger(value) ? {\n      'data-index': String(value)\n    } : null;\n  },\n  ...transitionStatusMapping,\n  value: () => null\n};","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nimport { useCollapsibleRoot } from '../../collapsible/root/useCollapsibleRoot.js';\nimport { CollapsibleRootContext } from '../../collapsible/root/CollapsibleRootContext.js';\nimport { useCompositeListItem } from '../../composite/list/useCompositeListItem.js';\nimport { useAccordionRootContext } from '../root/AccordionRootContext.js';\nimport { AccordionItemContext } from './AccordionItemContext.js';\nimport { accordionStyleHookMapping } from './styleHooks.js';\n\n/**\n * Groups an accordion header with the corresponding panel.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Accordion](https://base-ui.com/react/components/accordion)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst AccordionItem = /*#__PURE__*/React.forwardRef(function AccordionItem(props, forwardedRef) {\n  const {\n    className,\n    disabled: disabledProp = false,\n    onOpenChange: onOpenChangeProp,\n    render,\n    value: valueProp,\n    ...other\n  } = props;\n  const {\n    ref: listItemRef,\n    index\n  } = useCompositeListItem();\n  const mergedRef = useForkRef(forwardedRef, listItemRef);\n  const {\n    disabled: contextDisabled,\n    handleValueChange,\n    state: rootState,\n    value: openValues\n  } = useAccordionRootContext();\n  const value = valueProp ?? index;\n  const disabled = disabledProp || contextDisabled;\n  const isOpen = React.useMemo(() => {\n    if (!openValues) {\n      return false;\n    }\n    for (let i = 0; i < openValues.length; i += 1) {\n      if (openValues[i] === value) {\n        return true;\n      }\n    }\n    return false;\n  }, [openValues, value]);\n  const onOpenChange = useEventCallback(nextOpen => {\n    handleValueChange(value, nextOpen);\n    onOpenChangeProp?.(nextOpen);\n  });\n  const collapsible = useCollapsibleRoot({\n    open: isOpen,\n    onOpenChange,\n    disabled\n  });\n  const collapsibleState = React.useMemo(() => ({\n    open: collapsible.open,\n    disabled: collapsible.disabled,\n    hidden: !collapsible.mounted,\n    transitionStatus: collapsible.transitionStatus\n  }), [collapsible.open, collapsible.disabled, collapsible.mounted, collapsible.transitionStatus]);\n  const collapsibleContext = React.useMemo(() => ({\n    ...collapsible,\n    state: collapsibleState\n  }), [collapsible, collapsibleState]);\n  const state = React.useMemo(() => ({\n    ...rootState,\n    index,\n    disabled,\n    open: isOpen,\n    transitionStatus: collapsible.transitionStatus\n  }), [collapsible.transitionStatus, disabled, index, isOpen, rootState]);\n  const [triggerId, setTriggerId] = React.useState(useBaseUiId());\n  const accordionItemContext = React.useMemo(() => ({\n    open: isOpen,\n    state,\n    setTriggerId,\n    triggerId\n  }), [isOpen, state, setTriggerId, triggerId]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: mergedRef,\n    extraProps: other,\n    customStyleHookMapping: accordionStyleHookMapping\n  });\n  return /*#__PURE__*/_jsx(CollapsibleRootContext.Provider, {\n    value: collapsibleContext,\n    children: /*#__PURE__*/_jsx(AccordionItemContext.Provider, {\n      value: accordionItemContext,\n      children: renderElement()\n    })\n  });\n});\nexport { AccordionItem };\nprocess.env.NODE_ENV !== \"production\" ? AccordionItem.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Event handler called when the panel is opened or closed.\n   */\n  onOpenChange: PropTypes.func,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * @ignore\n   */\n  value: PropTypes.any\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useAccordionItemContext } from '../item/AccordionItemContext.js';\nimport { accordionStyleHookMapping } from '../item/styleHooks.js';\n\n/**\n * A heading that labels the corresponding panel.\n * Renders an `<h3>` element.\n *\n * Documentation: [Base UI Accordion](https://base-ui.com/react/components/accordion)\n */\nconst AccordionHeader = /*#__PURE__*/React.forwardRef(function AccordionHeader(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    state\n  } = useAccordionItemContext();\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'h3',\n    state,\n    className,\n    ref: forwardedRef,\n    extraProps: other,\n    customStyleHookMapping: accordionStyleHookMapping\n  });\n  return renderElement();\n});\nexport { AccordionHeader };\nprocess.env.NODE_ENV !== \"production\" ? AccordionHeader.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useButton } from '../../use-button/index.js';\nexport function useCollapsibleTrigger(parameters) {\n  const {\n    panelId,\n    disabled,\n    open,\n    rootRef: externalRef,\n    setOpen\n  } = parameters;\n  const {\n    getButtonProps,\n    buttonRef\n  } = useButton({\n    disabled,\n    focusableWhenDisabled: true,\n    type: 'button'\n  });\n  const handleRef = useForkRef(externalRef, buttonRef);\n  const getRootProps = React.useCallback((externalProps = {}) => getButtonProps(mergeReactProps(externalProps, {\n    type: 'button',\n    'aria-controls': panelId,\n    'aria-expanded': open,\n    disabled,\n    onClick() {\n      setOpen(!open);\n    },\n    ref: handleRef\n  })), [panelId, disabled, getButtonProps, handleRef, open, setOpen]);\n  return {\n    getRootProps\n  };\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { triggerOpenStateMapping } from '../../utils/collapsibleOpenStateMapping.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { useCollapsibleRootContext } from '../../collapsible/root/CollapsibleRootContext.js';\nimport { useCollapsibleTrigger } from '../../collapsible/trigger/useCollapsibleTrigger.js';\nimport { useAccordionItemContext } from '../item/AccordionItemContext.js';\n\n/**\n * A button that opens and closes the corresponding panel.\n * Renders a `<button>` element.\n *\n * Documentation: [Base UI Accordion](https://base-ui.com/react/components/accordion)\n */\n\nconst AccordionTrigger = /*#__PURE__*/React.forwardRef(function AccordionTrigger(props, forwardedRef) {\n  const {\n    disabled: disabledProp,\n    className,\n    id,\n    render,\n    ...otherProps\n  } = props;\n  const {\n    panelId,\n    disabled: contextDisabled,\n    open,\n    setOpen\n  } = useCollapsibleRootContext();\n  const {\n    getRootProps\n  } = useCollapsibleTrigger({\n    panelId,\n    disabled: disabledProp || contextDisabled,\n    open,\n    rootRef: forwardedRef,\n    setOpen\n  });\n  const {\n    state,\n    setTriggerId,\n    triggerId\n  } = useAccordionItemContext();\n  useEnhancedEffect(() => {\n    setTriggerId(id);\n    return () => {\n      setTriggerId(undefined);\n    };\n  }, [id, setTriggerId]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootProps,\n    render: render ?? 'button',\n    state,\n    className,\n    extraProps: {\n      ...otherProps,\n      // the `id` prop doesn't go here directly, it updates a context\n      // and becomes `triggerId`\n      id: triggerId\n    },\n    customStyleHookMapping: triggerOpenStateMapping\n  });\n  return renderElement();\n});\nexport { AccordionTrigger };\nprocess.env.NODE_ENV !== \"production\" ? AccordionTrigger.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  disabled: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport { hasComputedStyleMapSupport } from '../../utils/hasComputedStyleMapSupport.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { ownerWindow } from '../../utils/owner.js';\nimport { useAnimationsFinished } from '../../utils/useAnimationsFinished.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useOnMount } from '../../utils/useOnMount.js';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nfunction getAnimationNameFromComputedStyles(element) {\n  if (hasComputedStyleMapSupport()) {\n    const styleMap = element.computedStyleMap();\n    const animationName = styleMap.get('animation-name');\n    return animationName?.value ?? undefined;\n  }\n  const containerWindow = ownerWindow(element);\n  const computedStyles = containerWindow.getComputedStyle(element);\n  return computedStyles.animationName;\n}\nlet cachedSupportsHiddenUntilFound;\nfunction supportsHiddenUntilFound(element) {\n  // detect support for onbeforematch event and content-visibility\n  if (cachedSupportsHiddenUntilFound === undefined) {\n    const supportsCssContentVisibility = typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('content-visibility', 'hidden');\n    const supportsOnBeforeMatch = 'onbeforematch' in ownerWindow(element);\n    cachedSupportsHiddenUntilFound = process.env.NODE_ENV === 'test' ? supportsOnBeforeMatch : supportsCssContentVisibility && supportsOnBeforeMatch;\n  }\n  return cachedSupportsHiddenUntilFound;\n}\nexport function useCollapsiblePanel(parameters) {\n  const {\n    hiddenUntilFound,\n    panelId,\n    keepMounted,\n    open,\n    mounted,\n    ref,\n    setPanelId,\n    setMounted: setContextMounted,\n    setOpen\n  } = parameters;\n  const id = useBaseUiId(panelId);\n  const panelRef = React.useRef(null);\n  const [{\n    height,\n    width\n  }, setDimensions] = React.useState({\n    height: 0,\n    width: 0\n  });\n  const latestAnimationNameRef = React.useRef('none');\n  const originalTransitionDurationStyleRef = React.useRef(null);\n  const isTransitioningRef = React.useRef(false);\n  useEnhancedEffect(() => {\n    if (!keepMounted && !open) {\n      setPanelId(undefined);\n    } else {\n      setPanelId(id);\n    }\n    return () => {\n      setPanelId(undefined);\n    };\n  }, [id, setPanelId, keepMounted, open]);\n  const handlePanelRef = useEventCallback(element => {\n    if (!element) {\n      return;\n    }\n    panelRef.current = element;\n    const computedAnimationName = getAnimationNameFromComputedStyles(element);\n    latestAnimationNameRef.current = computedAnimationName ?? 'none';\n    originalTransitionDurationStyleRef.current = element.style.transitionDuration;\n  });\n  const mergedRef = useForkRef(ref, handlePanelRef);\n  const runOnceAnimationsFinish = useAnimationsFinished(panelRef);\n  const isOpen = open || mounted;\n  const isBeforeMatchRef = React.useRef(false);\n  const isInitialOpenAnimationRef = React.useRef(isOpen);\n  const registerCssTransitionListeners = React.useCallback(() => {\n    const element = panelRef.current;\n    if (!element) {\n      return undefined;\n    }\n    function handleTransitionRun() {\n      isTransitioningRef.current = true;\n    }\n    function handleTransitionEnd() {\n      isTransitioningRef.current = false;\n    }\n    function handleTransitionCancel() {\n      isTransitioningRef.current = false;\n    }\n    element.addEventListener('transitioncancel', handleTransitionCancel);\n    element.addEventListener('transitionend', handleTransitionEnd);\n    element.addEventListener('transitionrun', handleTransitionRun);\n    return () => {\n      element.removeEventListener('transitioncancel', handleTransitionCancel);\n      element.removeEventListener('transitionend', handleTransitionEnd);\n      element.removeEventListener('transitionrun', handleTransitionRun);\n    };\n  }, []);\n  useEnhancedEffect(() => {\n    const {\n      current: element\n    } = panelRef;\n    let frame1 = -1;\n    let frame2 = -1;\n    if (element) {\n      const isBeforeMatch = isBeforeMatchRef.current;\n      const isInitialOpenAnimation = isInitialOpenAnimationRef.current;\n      const isTransitioning = isTransitioningRef.current;\n      const originalAnimationName = element.style.animationName === 'none' ? '' : element.style.animationName;\n      const originalTransitionDuration = originalTransitionDurationStyleRef.current;\n\n      // cancel animation/transitions for these specific instances:\n      // 1. when initially open, on mount/load, it should just appear fully open\n      //    but remain animated per styles afterwards\n      // 2. when using `hidden='until-found'` and is opened by find-in-page, it\n      //    should open instantly but remain animated //    as styled afterwards\n      const shouldCancelAnimation = isBeforeMatch || isInitialOpenAnimation;\n      element.style.animationName = 'none';\n      const isClosed = !open && !mounted;\n      if (!isTransitioning || isClosed) {\n        if (!keepMounted) {\n          // when keepMounted is false the panel does not exist in the DOM so transition\n          // listeners need to be eagerly registered here before any state change\n          registerCssTransitionListeners();\n        }\n        const rect = isClosed ? {\n          height: 0,\n          width: 0\n        } : element.getBoundingClientRect();\n        setDimensions({\n          height: rect.height,\n          width: rect.width\n        });\n      }\n      element.style.animationName = shouldCancelAnimation ? 'none' : originalAnimationName;\n      element.style.transitionDuration = shouldCancelAnimation ? '0s' : originalTransitionDuration ?? '';\n      runOnceAnimationsFinish(() => {\n        setContextMounted(open);\n        if (isBeforeMatch) {\n          isBeforeMatchRef.current = false;\n          frame1 = requestAnimationFrame(() => {\n            frame2 = requestAnimationFrame(() => {\n              element.style.transitionDuration = originalTransitionDurationStyleRef.current ?? '';\n            });\n          });\n        }\n      });\n    }\n    return () => {\n      cancelAnimationFrame(frame1);\n      cancelAnimationFrame(frame2);\n    };\n  }, [mounted, keepMounted, open, registerCssTransitionListeners, runOnceAnimationsFinish, setContextMounted, setPanelId]);\n  useOnMount(() => {\n    const element = panelRef.current;\n    let frame2 = -1;\n    let frame3 = -1;\n    const frame = requestAnimationFrame(() => {\n      isInitialOpenAnimationRef.current = false;\n      if (element) {\n        frame2 = requestAnimationFrame(() => {\n          frame3 = requestAnimationFrame(() => {\n            // it takes 3 frames to unset `'0s'` from the initial open state correctly\n            element.style.transitionDuration = originalTransitionDurationStyleRef.current ?? '';\n          });\n        });\n      }\n    });\n    return () => {\n      cancelAnimationFrame(frame);\n      cancelAnimationFrame(frame2);\n      cancelAnimationFrame(frame3);\n    };\n  });\n  useOnMount(registerCssTransitionListeners);\n\n  // if `hidden=\"until-found\"` content is revealed by browser's in-page search\n  // we need to manually sync the open state\n  React.useEffect(function registerBeforeMatchListener() {\n    const {\n      current: element\n    } = panelRef;\n    if (!element || !supportsHiddenUntilFound(element)) {\n      return undefined;\n    }\n    function handleOnBeforeMatch(event) {\n      event.preventDefault();\n      isBeforeMatchRef.current = true;\n\n      // beforematch only fires if the matching content is initially hidden\n      setOpen(true);\n    }\n    element.addEventListener('beforematch', handleOnBeforeMatch);\n    return () => {\n      element.removeEventListener('beforematch', handleOnBeforeMatch);\n    };\n  }, [setOpen]);\n\n  // There is a bug in react that forces string values for the `hidden` attribute to a boolean\n  // so we have to force it back to `'until-found'` in the DOM when applicable\n  // https://github.com/facebook/react/issues/24740\n  useEnhancedEffect(() => {\n    const {\n      current: element\n    } = panelRef;\n    if (element && supportsHiddenUntilFound(element) && element?.hidden && !isOpen && hiddenUntilFound === true) {\n      // @ts-ignore\n      element.hidden = 'until-found';\n    }\n  }, [hiddenUntilFound, isOpen]);\n  const hidden = hiddenUntilFound ? 'until-found' : 'hidden';\n  const getRootProps = React.useCallback((externalProps = {}) => mergeReactProps(externalProps, {\n    id,\n    hidden: isOpen ? undefined : hidden,\n    ref: mergedRef\n  }), [hidden, id, isOpen, mergedRef]);\n  return React.useMemo(() => ({\n    getRootProps,\n    height,\n    width,\n    isOpen\n  }), [getRootProps, height, width, isOpen]);\n}","export let AccordionPanelCssVars = /*#__PURE__*/function (AccordionPanelCssVars) {\n  AccordionPanelCssVars[\"accordionPanelHeight\"] = \"--accordion-panel-height\";\n  AccordionPanelCssVars[\"accordionPanelWidth\"] = \"--accordion-panel-width\";\n  return AccordionPanelCssVars;\n}({});","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { warn } from '../../utils/warn.js';\nimport { useCollapsibleRootContext } from '../../collapsible/root/CollapsibleRootContext.js';\nimport { useCollapsiblePanel } from '../../collapsible/panel/useCollapsiblePanel.js';\nimport { useAccordionRootContext } from '../root/AccordionRootContext.js';\nimport { useAccordionItemContext } from '../item/AccordionItemContext.js';\nimport { accordionStyleHookMapping } from '../item/styleHooks.js';\nimport { AccordionPanelCssVars } from './AccordionPanelCssVars.js';\n\n/**\n * A collapsible panel with the accordion item contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Accordion](https://base-ui.com/react/components/accordion)\n */\nconst AccordionPanel = /*#__PURE__*/React.forwardRef(function AccordionPanel(props, forwardedRef) {\n  const {\n    className,\n    hiddenUntilFound: hiddenUntilFoundProp,\n    keepMounted: keepMountedProp,\n    id: idProp,\n    render,\n    style: styleProp,\n    ...otherProps\n  } = props;\n  const {\n    hiddenUntilFound: contextHiddenUntilFound,\n    keepMounted: contextKeepMounted\n  } = useAccordionRootContext();\n  const hiddenUntilFound = hiddenUntilFoundProp ?? contextHiddenUntilFound;\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEnhancedEffect(() => {\n      if (keepMountedProp === false && hiddenUntilFound) {\n        warn('The `keepMounted={false}` prop on a Accordion.Panel will be ignored when using `contextHiddenUntilFound` on the Panel or the Root since it requires the panel to remain mounted when closed.');\n      }\n    }, [hiddenUntilFound, keepMountedProp]);\n  }\n  const {\n    mounted,\n    open,\n    panelId,\n    setPanelId,\n    setMounted,\n    setOpen\n  } = useCollapsibleRootContext();\n  const keepMounted = keepMountedProp ?? contextKeepMounted;\n  const {\n    getRootProps,\n    height,\n    width,\n    isOpen\n  } = useCollapsiblePanel({\n    hiddenUntilFound,\n    panelId: idProp ?? panelId,\n    keepMounted,\n    mounted,\n    open,\n    ref: forwardedRef,\n    setPanelId,\n    setMounted,\n    setOpen\n  });\n  const {\n    state,\n    triggerId\n  } = useAccordionItemContext();\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootProps,\n    render: render ?? 'div',\n    state,\n    className,\n    extraProps: {\n      ...otherProps,\n      'aria-labelledby': triggerId,\n      role: 'region',\n      style: {\n        [AccordionPanelCssVars.accordionPanelHeight]: height ? `${height}px` : undefined,\n        [AccordionPanelCssVars.accordionPanelWidth]: width ? `${width}px` : undefined,\n        ...styleProp\n      }\n    },\n    customStyleHookMapping: accordionStyleHookMapping\n  });\n  if (!isOpen && !keepMounted && !hiddenUntilFound) {\n    return null;\n  }\n  return renderElement();\n});\nexport { AccordionPanel };\nprocess.env.NODE_ENV !== \"production\" ? AccordionPanel.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows the browser’s built-in page search to find and expand the panel contents.\n   *\n   * Overrides the `keepMounted` prop and uses `hidden=\"until-found\"`\n   * to hide the element without removing it from the DOM.\n   * @default false\n   */\n  hiddenUntilFound: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Whether to keep the element in the DOM while the panel is closed.\n   * This prop is ignored when `hiddenUntilFound` is used.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * @ignore\n   */\n  style: PropTypes.object\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useAlertDialogRootContext } from '../root/AlertDialogRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * An overlay displayed beneath the popup.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Alert Dialog](https://base-ui.com/react/components/alert-dialog)\n */\nconst AlertDialogBackdrop = /*#__PURE__*/React.forwardRef(function AlertDialogBackdrop(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    open,\n    nested,\n    mounted,\n    transitionStatus,\n    backdropRef\n  } = useAlertDialogRootContext();\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus\n  }), [open, transitionStatus]);\n  const mergedRef = useForkRef(backdropRef, forwardedRef);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: mergedRef,\n    extraProps: {\n      role: 'presentation',\n      hidden: !mounted,\n      ...other\n    },\n    customStyleHookMapping\n  });\n\n  // no need to render nested backdrops\n  const shouldRender = !nested;\n  if (!shouldRender) {\n    return null;\n  }\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? AlertDialogBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { AlertDialogBackdrop };","export let AlertDialogPopupDataAttributes = /*#__PURE__*/function (AlertDialogPopupDataAttributes) {\n  AlertDialogPopupDataAttributes[\"open\"] = \"data-open\";\n  AlertDialogPopupDataAttributes[\"closed\"] = \"data-closed\";\n  AlertDialogPopupDataAttributes[\"startingStyle\"] = \"data-starting-style\";\n  AlertDialogPopupDataAttributes[\"endingStyle\"] = \"data-ending-style\";\n  AlertDialogPopupDataAttributes[\"nested\"] = \"data-nested\";\n  AlertDialogPopupDataAttributes[\"hasNestedDialogs\"] = \"data-has-nested-dialogs\";\n  return AlertDialogPopupDataAttributes;\n}({});","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingFocusManager } from '@floating-ui/react';\nimport { useDialogPopup } from '../../dialog/popup/useDialogPopup.js';\nimport { useAlertDialogRootContext } from '../root/AlertDialogRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { refType } from '../../utils/proptypes.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { AlertDialogPopupDataAttributes } from './AlertDialogPopupDataAttributes.js';\nimport { InternalBackdrop } from '../../utils/InternalBackdrop.js';\nimport { useAlertDialogPortalContext } from '../portal/AlertDialogPortalContext.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping,\n  hasNestedDialogs(value) {\n    return value ? {\n      [AlertDialogPopupDataAttributes.hasNestedDialogs]: ''\n    } : null;\n  }\n};\n\n/**\n * A container for the alert dialog contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Alert Dialog](https://base-ui.com/react/components/alert-dialog)\n */\nconst AlertDialogPopup = /*#__PURE__*/React.forwardRef(function AlertDialogPopup(props, forwardedRef) {\n  const {\n    className,\n    id,\n    render,\n    initialFocus,\n    finalFocus,\n    ...other\n  } = props;\n  const {\n    descriptionElementId,\n    floatingRootContext,\n    getPopupProps,\n    mounted,\n    nested,\n    nestedOpenDialogCount,\n    setOpen,\n    open,\n    openMethod,\n    popupRef,\n    setPopupElement,\n    setPopupElementId,\n    titleElementId,\n    transitionStatus,\n    modal,\n    onOpenChangeComplete,\n    internalBackdropRef\n  } = useAlertDialogRootContext();\n  useAlertDialogPortalContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const mergedRef = useForkRef(forwardedRef, popupRef);\n  const {\n    getRootProps,\n    resolvedInitialFocus\n  } = useDialogPopup({\n    descriptionElementId,\n    getPopupProps,\n    id,\n    initialFocus,\n    modal: true,\n    mounted,\n    setOpen,\n    openMethod,\n    ref: mergedRef,\n    setPopupElement,\n    setPopupElementId,\n    titleElementId\n  });\n  const hasNestedDialogs = nestedOpenDialogCount > 0;\n  const state = React.useMemo(() => ({\n    open,\n    nested,\n    transitionStatus,\n    hasNestedDialogs\n  }), [open, nested, transitionStatus, hasNestedDialogs]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    propGetter: getRootProps,\n    extraProps: {\n      ...other,\n      style: {\n        ...other.style,\n        '--nested-dialogs': nestedOpenDialogCount\n      },\n      role: 'alertdialog'\n    },\n    customStyleHookMapping\n  });\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [mounted && modal && /*#__PURE__*/_jsx(InternalBackdrop, {\n      ref: internalBackdropRef,\n      inert: !open\n    }), /*#__PURE__*/_jsx(FloatingFocusManager, {\n      context: floatingRootContext,\n      disabled: !mounted,\n      initialFocus: resolvedInitialFocus,\n      returnFocus: finalFocus,\n      children: renderElement()\n    })]\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? AlertDialogPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Determines the element to focus when the dialog is closed.\n   * By default, focus returns to the trigger.\n   */\n  finalFocus: refType,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Determines the element to focus when the dialog is opened.\n   * By default, the first focusable element is focused.\n   */\n  initialFocus: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.func, refType]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * @ignore\n   */\n  style: PropTypes.object\n} : void 0;\nexport { AlertDialogPopup };","export let FieldControlDataAttributes = /*#__PURE__*/function (FieldControlDataAttributes) {\n  FieldControlDataAttributes[\"disabled\"] = \"data-disabled\";\n  FieldControlDataAttributes[\"valid\"] = \"data-valid\";\n  FieldControlDataAttributes[\"invalid\"] = \"data-invalid\";\n  FieldControlDataAttributes[\"touched\"] = \"data-touched\";\n  FieldControlDataAttributes[\"dirty\"] = \"data-dirty\";\n  FieldControlDataAttributes[\"filled\"] = \"data-filled\";\n  FieldControlDataAttributes[\"focused\"] = \"data-focused\";\n  return FieldControlDataAttributes;\n}({});","import { FieldControlDataAttributes } from '../control/FieldControlDataAttributes.js';\nexport const DEFAULT_VALIDITY_STATE = {\n  badInput: false,\n  customError: false,\n  patternMismatch: false,\n  rangeOverflow: false,\n  rangeUnderflow: false,\n  stepMismatch: false,\n  tooLong: false,\n  tooShort: false,\n  typeMismatch: false,\n  valid: null,\n  valueMissing: false\n};\nexport const fieldValidityMapping = {\n  valid(value) {\n    if (value === null) {\n      return null;\n    }\n    if (value) {\n      return {\n        [FieldControlDataAttributes.valid]: ''\n      };\n    }\n    return {\n      [FieldControlDataAttributes.invalid]: ''\n    };\n  }\n};","'use client';\n\nimport * as React from 'react';\nimport { DEFAULT_VALIDITY_STATE } from '../utils/constants.js';\nconst NOOP = () => {};\nexport const FieldRootContext = /*#__PURE__*/React.createContext({\n  invalid: undefined,\n  controlId: undefined,\n  setControlId: NOOP,\n  labelId: undefined,\n  setLabelId: NOOP,\n  messageIds: [],\n  setMessageIds: NOOP,\n  name: undefined,\n  validityData: {\n    state: DEFAULT_VALIDITY_STATE,\n    errors: [],\n    error: '',\n    value: '',\n    initialValue: null\n  },\n  setValidityData: NOOP,\n  disabled: undefined,\n  touched: false,\n  setTouched: NOOP,\n  dirty: false,\n  setDirty: NOOP,\n  filled: false,\n  setFilled: NOOP,\n  focused: false,\n  setFocused: NOOP,\n  validate: () => null,\n  validationMode: 'onBlur',\n  validationDebounceTime: 0,\n  state: {\n    disabled: false,\n    valid: null,\n    touched: false,\n    dirty: false,\n    filled: false,\n    focused: false\n  },\n  markedDirtyRef: {\n    current: false\n  }\n});\nif (process.env.NODE_ENV !== 'production') {\n  FieldRootContext.displayName = 'FieldRootContext';\n}\nexport function useFieldRootContext(optional = true) {\n  const context = React.useContext(FieldRootContext);\n  if (context.setControlId === NOOP && !optional) {\n    throw new Error('Base UI: FieldRootContext is missing. Field parts must be placed within <Field.Root>.');\n  }\n  return context;\n}","export const visuallyHidden = {\n  clip: 'rect(0 0 0 0)',\n  overflow: 'hidden',\n  whiteSpace: 'nowrap',\n  position: 'fixed',\n  top: 0,\n  left: 0,\n  border: 0,\n  padding: 0,\n  width: 1,\n  height: 1,\n  margin: -1\n};","'use client';\n\nimport * as React from 'react';\nexport const FormContext = /*#__PURE__*/React.createContext({\n  formRef: {\n    current: {\n      fields: new Map()\n    }\n  },\n  errors: {},\n  onClearErrors: () => {}\n});\nif (process.env.NODE_ENV !== 'production') {\n  FormContext.displayName = 'FormContext';\n}\nexport function useFormContext() {\n  return React.useContext(FormContext);\n}","/**\n * Combines the field's client-side, stateful validity data with the external invalid state to\n * determine the field's true validity.\n */\nexport function getCombinedFieldValidityData(validityData, invalid) {\n  return {\n    ...validityData,\n    state: {\n      ...validityData.state,\n      valid: !invalid && validityData.state.valid\n    }\n  };\n}","'use client';\n\nimport * as React from 'react';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { useFieldRootContext } from '../root/FieldRootContext.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { DEFAULT_VALIDITY_STATE } from '../utils/constants.js';\nimport { useFormContext } from '../../form/FormContext.js';\nimport { getCombinedFieldValidityData } from '../utils/getCombinedFieldValidityData.js';\nconst validityKeys = Object.keys(DEFAULT_VALIDITY_STATE);\nexport function useFieldControlValidation() {\n  const {\n    setValidityData,\n    validate,\n    messageIds,\n    validityData,\n    validationMode,\n    validationDebounceTime,\n    invalid,\n    markedDirtyRef,\n    controlId,\n    state\n  } = useFieldRootContext();\n  const {\n    formRef\n  } = useFormContext();\n  const timeoutRef = React.useRef(-1);\n  const inputRef = React.useRef(null);\n  React.useEffect(() => {\n    return () => {\n      window.clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  const commitValidation = useEventCallback(async value => {\n    const element = inputRef.current;\n    if (!element) {\n      return;\n    }\n    function getState(el) {\n      return validityKeys.reduce((acc, key) => {\n        acc[key] = el.validity[key];\n        if (!el.validity.customError && !markedDirtyRef.current) {\n          acc[key] = key === 'valid';\n        }\n        return acc;\n      }, {});\n    }\n    window.clearTimeout(timeoutRef.current);\n    const resultOrPromise = validate(value);\n    let result = null;\n    if (typeof resultOrPromise === 'object' && resultOrPromise !== null && 'then' in resultOrPromise) {\n      result = await resultOrPromise;\n    } else {\n      result = resultOrPromise;\n    }\n    let errorMessage = '';\n    if (result !== null) {\n      errorMessage = Array.isArray(result) ? result.join('\\n') : result;\n    }\n    element.setCustomValidity(errorMessage);\n    const nextState = getState(element);\n    let validationErrors = [];\n    if (Array.isArray(result)) {\n      validationErrors = result;\n    } else if (result) {\n      validationErrors = [result];\n    } else if (element.validationMessage) {\n      validationErrors = [element.validationMessage];\n    }\n    const nextValidityData = {\n      value,\n      state: nextState,\n      error: Array.isArray(result) ? result[0] : result ?? element.validationMessage,\n      errors: validationErrors,\n      initialValue: validityData.initialValue\n    };\n    if (controlId) {\n      const currentFieldData = formRef.current.fields.get(controlId);\n      if (currentFieldData) {\n        formRef.current.fields.set(controlId, {\n          ...currentFieldData,\n          ...getCombinedFieldValidityData(nextValidityData, invalid)\n        });\n      }\n    }\n    setValidityData(nextValidityData);\n  });\n  const getValidationProps = React.useCallback((externalProps = {}) => mergeReactProps(externalProps, {\n    ...(messageIds.length && {\n      'aria-describedby': messageIds.join(' ')\n    }),\n    ...(state.valid === false && {\n      'aria-invalid': true\n    })\n  }), [messageIds, state.valid]);\n  const getInputValidationProps = React.useCallback((externalProps = {}) => mergeReactProps(getValidationProps(externalProps), {\n    onChange(event) {\n      // Workaround for https://github.com/facebook/react/issues/9023\n      if (event.nativeEvent.defaultPrevented) {\n        return;\n      }\n      if (invalid || validationMode !== 'onChange') {\n        return;\n      }\n      const element = event.currentTarget;\n      if (element.value === '') {\n        // Ignore the debounce time for empty values.\n        commitValidation(element.value);\n        return;\n      }\n      window.clearTimeout(timeoutRef.current);\n      if (validationDebounceTime) {\n        timeoutRef.current = window.setTimeout(() => {\n          commitValidation(element.value);\n        }, validationDebounceTime);\n      } else {\n        commitValidation(element.value);\n      }\n    }\n  }), [getValidationProps, invalid, validationMode, validationDebounceTime, commitValidation]);\n  return React.useMemo(() => ({\n    getValidationProps,\n    getInputValidationProps,\n    inputRef,\n    commitValidation\n  }), [getValidationProps, getInputValidationProps, commitValidation]);\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../utils/useComponentRenderer.js';\nimport { useCheckboxGroup } from './useCheckboxGroup.js';\nimport { CheckboxGroupContext } from './CheckboxGroupContext.js';\nimport { useFieldRootContext } from '../field/root/FieldRootContext.js';\nimport { fieldValidityMapping } from '../field/utils/constants.js';\n\n/**\n * Provides a shared state to a series of checkboxes.\n *\n * Documentation: [Base UI Checkbox Group](https://base-ui.com/react/components/checkbox-group)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CheckboxGroup = /*#__PURE__*/React.forwardRef(function CheckboxGroup(props, forwardedRef) {\n  const {\n    render,\n    className,\n    value: externalValue,\n    defaultValue,\n    onValueChange,\n    allValues,\n    disabled: disabledProp = false,\n    ...otherProps\n  } = props;\n  const {\n    disabled: fieldDisabled,\n    state: fieldState\n  } = useFieldRootContext();\n  const disabled = fieldDisabled || disabledProp;\n  const {\n    getRootProps,\n    value,\n    setValue,\n    parent\n  } = useCheckboxGroup({\n    value: externalValue,\n    allValues,\n    defaultValue,\n    onValueChange\n  });\n  const state = React.useMemo(() => ({\n    ...fieldState,\n    disabled\n  }), [fieldState, disabled]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootProps,\n    render: render ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: otherProps,\n    customStyleHookMapping: fieldValidityMapping\n  });\n  const contextValue = React.useMemo(() => ({\n    allValues,\n    value,\n    defaultValue,\n    setValue,\n    parent,\n    disabled\n  }), [allValues, value, defaultValue, setValue, parent, disabled]);\n  return /*#__PURE__*/_jsx(CheckboxGroupContext.Provider, {\n    value: contextValue,\n    children: renderElement()\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? CheckboxGroup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * Names of all checkboxes in the group. Use this when creating a parent checkbox.\n   */\n  allValues: PropTypes.arrayOf(PropTypes.string),\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Names of the checkboxes in the group that should be initially ticked.\n   *\n   * To render a controlled checkbox group, use the `value` prop instead.\n   */\n  defaultValue: PropTypes.arrayOf(PropTypes.string),\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Event handler called when a checkbox in the group is ticked or unticked.\n   * Provides the new value as an argument.\n   */\n  onValueChange: PropTypes.func,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * Names of the checkboxes in the group that should be ticked.\n   *\n   * To render an uncontrolled checkbox group, use the `defaultValue` prop instead.\n   */\n  value: PropTypes.arrayOf(PropTypes.string)\n} : void 0;\nexport { CheckboxGroup };","import { collapsibleOpenStateMapping as baseMapping } from '../../utils/collapsibleOpenStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nexport const collapsibleStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { NOOP } from '../../utils/noop.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useCollapsibleRoot } from './useCollapsibleRoot.js';\nimport { CollapsibleRootContext } from './CollapsibleRootContext.js';\nimport { collapsibleStyleHookMapping } from './styleHooks.js';\n\n/**\n * Groups all parts of the collapsible.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Collapsible](https://base-ui.com/react/components/collapsible)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CollapsibleRoot = /*#__PURE__*/React.forwardRef(function CollapsibleRoot(props, forwardedRef) {\n  const {\n    children,\n    className,\n    defaultOpen = false,\n    disabled = false,\n    onOpenChange: onOpenChangeProp,\n    open,\n    render: renderProp,\n    ...otherProps\n  } = props;\n  const collapsible = useCollapsibleRoot({\n    open,\n    defaultOpen,\n    onOpenChange: onOpenChangeProp ?? NOOP,\n    disabled\n  });\n  const state = React.useMemo(() => ({\n    open: collapsible.open,\n    disabled: collapsible.disabled,\n    transitionStatus: collapsible.transitionStatus\n  }), [collapsible.open, collapsible.disabled, collapsible.transitionStatus]);\n  const contextValue = React.useMemo(() => ({\n    ...collapsible,\n    state\n  }), [collapsible, state]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: renderProp ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: {\n      children,\n      ...otherProps\n    },\n    customStyleHookMapping: collapsibleStyleHookMapping\n  });\n  if (renderProp !== null) {\n    return /*#__PURE__*/_jsx(CollapsibleRootContext.Provider, {\n      value: contextValue,\n      children: renderElement()\n    });\n  }\n  return /*#__PURE__*/_jsx(CollapsibleRootContext.Provider, {\n    value: contextValue,\n    children: children\n  });\n});\nexport { CollapsibleRoot };\nprocess.env.NODE_ENV !== \"production\" ? CollapsibleRoot.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Whether the collapsible panel is initially open.\n   *\n   * To render a controlled collapsible, use the `open` prop instead.\n   * @default false\n   */\n  defaultOpen: PropTypes.bool,\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Event handler called when the panel is opened or closed.\n   */\n  onOpenChange: PropTypes.func,\n  /**\n   * Whether the collapsible panel is currently open.\n   *\n   * To render an uncontrolled collapsible, use the `defaultOpen` prop instead.\n   */\n  open: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { triggerOpenStateMapping } from '../../utils/collapsibleOpenStateMapping.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useCollapsibleRootContext } from '../root/CollapsibleRootContext.js';\nimport { useCollapsibleTrigger } from './useCollapsibleTrigger.js';\n\n/**\n * A button that opens and closes the collapsible panel.\n * Renders a `<button>` element.\n *\n * Documentation: [Base UI Collapsible](https://base-ui.com/react/components/collapsible)\n */\nconst CollapsibleTrigger = /*#__PURE__*/React.forwardRef(function CollapsibleTrigger(props, forwardedRef) {\n  const {\n    className,\n    disabled = false,\n    id,\n    render,\n    ...otherProps\n  } = props;\n  const {\n    panelId,\n    open,\n    setOpen,\n    state\n  } = useCollapsibleRootContext();\n  const {\n    getRootProps\n  } = useCollapsibleTrigger({\n    disabled,\n    panelId,\n    open,\n    setOpen,\n    rootRef: forwardedRef\n  });\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootProps,\n    render: render ?? 'button',\n    state,\n    className,\n    extraProps: otherProps,\n    customStyleHookMapping: triggerOpenStateMapping\n  });\n  return renderElement();\n});\nexport { CollapsibleTrigger };\nprocess.env.NODE_ENV !== \"production\" ? CollapsibleTrigger.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  disabled: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;","export let CollapsiblePanelCssVars = /*#__PURE__*/function (CollapsiblePanelCssVars) {\n  CollapsiblePanelCssVars[\"collapsiblePanelHeight\"] = \"--collapsible-panel-height\";\n  CollapsiblePanelCssVars[\"collapsiblePanelWidth\"] = \"--collapsible-panel-width\";\n  return CollapsiblePanelCssVars;\n}({});","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { warn } from '../../utils/warn.js';\nimport { useCollapsibleRootContext } from '../root/CollapsibleRootContext.js';\nimport { collapsibleStyleHookMapping } from '../root/styleHooks.js';\nimport { useCollapsiblePanel } from './useCollapsiblePanel.js';\nimport { CollapsiblePanelCssVars } from './CollapsiblePanelCssVars.js';\n\n/**\n * A panel with the collapsible contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Collapsible](https://base-ui.com/react/components/collapsible)\n */\nconst CollapsiblePanel = /*#__PURE__*/React.forwardRef(function CollapsiblePanel(props, forwardedRef) {\n  const {\n    className,\n    hiddenUntilFound: hiddenUntilFoundProp,\n    id: idProp,\n    keepMounted: keepMountedProp,\n    render,\n    ...otherProps\n  } = props;\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEnhancedEffect(() => {\n      if (hiddenUntilFoundProp && keepMountedProp === false) {\n        warn('The `keepMounted={false}` prop on a Collapsible will be ignored when using `hiddenUntilFound` since it requires the Panel to remain mounted even when closed.');\n      }\n    }, [hiddenUntilFoundProp, keepMountedProp]);\n  }\n  const {\n    mounted,\n    open,\n    panelId,\n    setPanelId,\n    setMounted,\n    setOpen,\n    state\n  } = useCollapsibleRootContext();\n  useEnhancedEffect(() => {\n    if (idProp) {\n      setPanelId(idProp);\n    }\n  }, [idProp, setPanelId]);\n  const hiddenUntilFound = hiddenUntilFoundProp ?? false;\n  const {\n    getRootProps,\n    height,\n    width,\n    isOpen\n  } = useCollapsiblePanel({\n    hiddenUntilFound,\n    panelId,\n    keepMounted: keepMountedProp ?? false,\n    mounted,\n    open,\n    ref: forwardedRef,\n    setPanelId,\n    setMounted,\n    setOpen\n  });\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootProps,\n    render: render ?? 'div',\n    state,\n    className,\n    extraProps: {\n      ...otherProps,\n      style: {\n        ...otherProps.style,\n        [CollapsiblePanelCssVars.collapsiblePanelHeight]: height ? `${height}px` : undefined,\n        [CollapsiblePanelCssVars.collapsiblePanelWidth]: width ? `${width}px` : undefined\n      }\n    },\n    customStyleHookMapping: collapsibleStyleHookMapping\n  });\n  if (!keepMountedProp && !isOpen && !hiddenUntilFound) {\n    return null;\n  }\n  return renderElement();\n});\nexport { CollapsiblePanel };\nprocess.env.NODE_ENV !== \"production\" ? CollapsiblePanel.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows the browser’s built-in page search to find and expand the panel contents.\n   *\n   * Overrides the `keepMounted` prop and uses `hidden=\"until-found\"`\n   * to hide the element without removing it from the DOM.\n   *\n   * @default false\n   */\n  hiddenUntilFound: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Whether to keep the element in the DOM while the panel is hidden.\n   * This prop is ignored when `hiddenUntilFound` is used.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * @ignore\n   */\n  style: PropTypes.object\n} : void 0;","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useMenuRootContext } from '../root/MenuRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * An overlay displayed beneath the menu popup.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)\n */\nconst MenuBackdrop = /*#__PURE__*/React.forwardRef(function MenuBackdrop(props, forwardedRef) {\n  const {\n    className,\n    render,\n    ...other\n  } = props;\n  const {\n    open,\n    mounted,\n    transitionStatus\n  } = useMenuRootContext();\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus\n  }), [open, transitionStatus]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: {\n      role: 'presentation',\n      hidden: !mounted,\n      ...other\n    },\n    customStyleHookMapping\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? MenuBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { MenuBackdrop };","import { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nexport const itemMapping = {\n  checked(value) {\n    if (value) {\n      return {\n        'data-checked': ''\n      };\n    }\n    return {\n      'data-unchecked': ''\n    };\n  },\n  ...transitionStatusMapping\n};","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingFocusManager, useFloatingTree } from '@floating-ui/react';\nimport { useMenuPopup } from './useMenuPopup.js';\nimport { useMenuRootContext } from '../root/MenuRootContext.js';\nimport { useMenuPositionerContext } from '../positioner/MenuPositionerContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * A container for the menu items.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)\n */\nconst MenuPopup = /*#__PURE__*/React.forwardRef(function MenuPopup(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    open,\n    setOpen,\n    popupRef,\n    transitionStatus,\n    nested,\n    getPopupProps,\n    modal,\n    mounted,\n    instantType,\n    onOpenChangeComplete\n  } = useMenuRootContext();\n  const {\n    side,\n    align,\n    floatingContext\n  } = useMenuPositionerContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const {\n    events: menuEvents\n  } = useFloatingTree();\n  useMenuPopup({\n    setOpen,\n    menuEvents\n  });\n  const mergedRef = useForkRef(forwardedRef, popupRef);\n  const state = React.useMemo(() => ({\n    transitionStatus,\n    side,\n    align,\n    open,\n    nested,\n    instant: instantType\n  }), [transitionStatus, side, align, open, nested, instantType]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getPopupProps,\n    render: render || 'div',\n    className,\n    state,\n    extraProps: transitionStatus === 'starting' ? mergeReactProps(other, {\n      style: {\n        transition: 'none'\n      }\n    }) : other,\n    customStyleHookMapping,\n    ref: mergedRef\n  });\n  return /*#__PURE__*/_jsx(FloatingFocusManager, {\n    context: floatingContext,\n    modal: false,\n    disabled: !mounted,\n    visuallyHiddenDismiss: modal ? 'Dismiss popup' : undefined,\n    children: renderElement()\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? MenuPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { MenuPopup };","'use client';\n\nimport * as React from 'react';\nimport { autoUpdate, flip, limitShift, offset, shift, arrow, useFloating, size, hide } from '@floating-ui/react';\nimport { getSide, getAlignment } from '@floating-ui/utils';\nimport { useEnhancedEffect } from './useEnhancedEffect.js';\nimport { useDirection } from '../direction-provider/DirectionContext.js';\nimport { useLatestRef } from './useLatestRef.js';\nfunction getLogicalSide(sideParam, renderedSide, isRtl) {\n  const isLogicalSideParam = sideParam === 'inline-start' || sideParam === 'inline-end';\n  const logicalRight = isRtl ? 'inline-start' : 'inline-end';\n  const logicalLeft = isRtl ? 'inline-end' : 'inline-start';\n  return {\n    top: 'top',\n    right: isLogicalSideParam ? logicalRight : 'right',\n    bottom: 'bottom',\n    left: isLogicalSideParam ? logicalLeft : 'left'\n  }[renderedSide];\n}\n/**\n * Provides standardized anchor positioning behavior for floating elements. Wraps Floating UI's\n * `useFloating` hook.\n * @ignore - internal hook.\n */\nexport function useAnchorPositioning(params) {\n  const {\n    // Public parameters\n    anchor,\n    positionMethod = 'absolute',\n    side: sideParam = 'bottom',\n    sideOffset = 0,\n    align = 'center',\n    alignOffset = 0,\n    collisionBoundary,\n    collisionPadding = 5,\n    sticky = false,\n    arrowPadding = 5,\n    // Private parameters\n    keepMounted = false,\n    floatingRootContext,\n    mounted,\n    trackAnchor = true,\n    nodeId\n  } = params;\n  const direction = useDirection();\n  const isRtl = direction === 'rtl';\n  const side = {\n    top: 'top',\n    right: 'right',\n    bottom: 'bottom',\n    left: 'left',\n    'inline-end': isRtl ? 'left' : 'right',\n    'inline-start': isRtl ? 'right' : 'left'\n  }[sideParam];\n  const placement = align === 'center' ? side : `${side}-${align}`;\n  const commonCollisionProps = {\n    boundary: collisionBoundary === 'clipping-ancestors' ? 'clippingAncestors' : collisionBoundary,\n    padding: collisionPadding\n  };\n\n  // Using a ref assumes that the arrow element is always present in the DOM for the lifetime of the\n  // tooltip. If this assumption ends up being false, we can switch to state to manage the arrow's\n  // presence.\n  const arrowRef = React.useRef(null);\n\n  // Keep these reactive if they're not functions\n  const sideOffsetRef = useLatestRef(sideOffset);\n  const alignOffsetRef = useLatestRef(alignOffset);\n  const sideOffsetDep = typeof sideOffset !== 'function' ? sideOffset : 0;\n  const alignOffsetDep = typeof alignOffset !== 'function' ? alignOffset : 0;\n  const middleware = [offset(({\n    rects,\n    placement: currentPlacement\n  }) => {\n    const data = {\n      side: getLogicalSide(sideParam, getSide(currentPlacement), isRtl),\n      align: getAlignment(currentPlacement) || 'center',\n      anchor: {\n        width: rects.reference.width,\n        height: rects.reference.height\n      },\n      positioner: {\n        width: rects.floating.width,\n        height: rects.floating.height\n      }\n    };\n    const sideAxis = typeof sideOffsetRef.current === 'function' ? sideOffsetRef.current(data) : sideOffsetRef.current;\n    const alignAxis = typeof alignOffsetRef.current === 'function' ? alignOffsetRef.current(data) : alignOffsetRef.current;\n    return {\n      mainAxis: sideAxis,\n      crossAxis: alignAxis,\n      alignmentAxis: alignAxis\n    };\n  }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam])];\n  const flipMiddleware = flip(commonCollisionProps);\n  const shiftMiddleware = shift({\n    ...commonCollisionProps,\n    crossAxis: sticky,\n    limiter: sticky ? undefined : limitShift(() => {\n      if (!arrowRef.current) {\n        return {};\n      }\n      const {\n        height\n      } = arrowRef.current.getBoundingClientRect();\n      return {\n        offset: height / 2 + (typeof collisionPadding === 'number' ? collisionPadding : 0)\n      };\n    })\n  });\n\n  // https://floating-ui.com/docs/flip#combining-with-shift\n  if (align !== 'center') {\n    middleware.push(flipMiddleware, shiftMiddleware);\n  } else {\n    middleware.push(shiftMiddleware, flipMiddleware);\n  }\n  middleware.push(size({\n    ...commonCollisionProps,\n    apply({\n      elements: {\n        floating\n      },\n      rects: {\n        reference\n      },\n      availableWidth,\n      availableHeight\n    }) {\n      Object.entries({\n        '--available-width': `${availableWidth}px`,\n        '--available-height': `${availableHeight}px`,\n        '--anchor-width': `${reference.width}px`,\n        '--anchor-height': `${reference.height}px`\n      }).forEach(([key, value]) => {\n        floating.style.setProperty(key, value);\n      });\n    }\n  }), arrow(() => ({\n    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,\n    // we'll create a fake element.\n    element: arrowRef.current || document.createElement('div'),\n    padding: arrowPadding\n  }), [arrowPadding]), hide(), {\n    name: 'transformOrigin',\n    fn({\n      elements,\n      middlewareData,\n      placement: renderedPlacement\n    }) {\n      const currentRenderedSide = getSide(renderedPlacement);\n      const arrowEl = arrowRef.current;\n      const arrowX = middlewareData.arrow?.x ?? 0;\n      const arrowY = middlewareData.arrow?.y ?? 0;\n      const arrowWidth = arrowEl?.clientWidth ?? 0;\n      const arrowHeight = arrowEl?.clientHeight ?? 0;\n      const transformX = arrowX + arrowWidth / 2;\n      const transformY = arrowY + arrowHeight / 2;\n      const transformOrigin = {\n        top: `${transformX}px calc(100% + ${sideOffset}px)`,\n        bottom: `${transformX}px ${-sideOffset}px`,\n        left: `calc(100% + ${sideOffset}px) ${transformY}px`,\n        right: `${-sideOffset}px ${transformY}px`\n      }[currentRenderedSide];\n      elements.floating.style.setProperty('--transform-origin', transformOrigin);\n      return {};\n    }\n  });\n\n  // Ensure positioning doesn't run initially for `keepMounted` elements that\n  // aren't initially open.\n  let rootContext = floatingRootContext;\n  if (!mounted && floatingRootContext) {\n    rootContext = {\n      ...floatingRootContext,\n      elements: {\n        reference: null,\n        floating: null,\n        domReference: null\n      }\n    };\n  }\n  const autoUpdateOptions = React.useMemo(() => ({\n    elementResize: trackAnchor && typeof ResizeObserver !== 'undefined',\n    layoutShift: trackAnchor && typeof IntersectionObserver !== 'undefined'\n  }), [trackAnchor]);\n  const {\n    refs,\n    elements,\n    floatingStyles,\n    middlewareData,\n    update,\n    placement: renderedPlacement,\n    context,\n    isPositioned\n  } = useFloating({\n    rootContext,\n    placement,\n    middleware,\n    strategy: positionMethod,\n    whileElementsMounted: keepMounted ? undefined : (...args) => autoUpdate(...args, autoUpdateOptions),\n    nodeId\n  });\n  const registeredPositionReferenceRef = React.useRef(null);\n  useEnhancedEffect(() => {\n    if (!mounted) {\n      return;\n    }\n    const resolvedAnchor = typeof anchor === 'function' ? anchor() : anchor;\n    if (resolvedAnchor) {\n      const unwrappedElement = isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor;\n      refs.setPositionReference(unwrappedElement);\n      registeredPositionReferenceRef.current = unwrappedElement;\n    }\n  }, [mounted, refs, anchor]);\n  React.useEffect(() => {\n    if (!mounted) {\n      return;\n    }\n\n    // Refs from parent components are set after useLayoutEffect runs and are available in useEffect.\n    // Therefore, if the anchor is a ref, we need to update the position reference in useEffect.\n    if (typeof anchor === 'function') {\n      return;\n    }\n    if (isRef(anchor) && anchor.current !== registeredPositionReferenceRef.current) {\n      refs.setPositionReference(anchor.current);\n      registeredPositionReferenceRef.current = anchor.current;\n    }\n  }, [mounted, refs, anchor]);\n  React.useEffect(() => {\n    if (keepMounted && mounted && elements.domReference && elements.floating) {\n      return autoUpdate(elements.domReference, elements.floating, update, autoUpdateOptions);\n    }\n    return undefined;\n  }, [keepMounted, mounted, elements, update, autoUpdateOptions]);\n  const renderedSide = getSide(renderedPlacement);\n  const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);\n  const renderedAlign = getAlignment(renderedPlacement) || 'center';\n  const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);\n  const arrowStyles = React.useMemo(() => ({\n    position: 'absolute',\n    top: middlewareData.arrow?.y,\n    left: middlewareData.arrow?.x\n  }), [middlewareData.arrow]);\n  const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;\n  return React.useMemo(() => ({\n    positionerStyles: floatingStyles,\n    arrowStyles,\n    arrowRef,\n    arrowUncentered,\n    side: logicalRenderedSide,\n    align: renderedAlign,\n    anchorHidden,\n    refs,\n    context,\n    isPositioned\n  }), [floatingStyles, arrowStyles, arrowRef, arrowUncentered, logicalRenderedSide, renderedAlign, anchorHidden, refs, context, isPositioned]);\n}\nfunction isRef(param) {\n  return param != null && 'current' in param;\n}","export const cache = new Map();\nexport function getFormatter(locale, options) {\n  const optionsString = JSON.stringify({\n    locale,\n    options\n  });\n  const cachedFormatter = cache.get(optionsString);\n  if (cachedFormatter) {\n    return cachedFormatter;\n  }\n  const formatter = new Intl.NumberFormat(locale, options);\n  cache.set(optionsString, formatter);\n  return formatter;\n}\nexport function formatNumber(value, locale, options) {\n  if (value == null) {\n    return '';\n  }\n  return getFormatter(locale, options).format(value);\n}","import { getFormatter } from '../../utils/formatNumber.js';\nexport const HAN_NUMERALS = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];\nexport const ARABIC_NUMERALS = ['٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩'];\nexport const PERCENTAGES = ['%', '٪'];\nexport const ARABIC_RE = new RegExp(`[${ARABIC_NUMERALS.join('')}]`, 'g');\nexport const HAN_RE = new RegExp(`[${HAN_NUMERALS.join('')}]`, 'g');\nexport const PERCENT_RE = new RegExp(`[${PERCENTAGES.join('')}]`);\nexport function getNumberLocaleDetails(locale, options) {\n  const parts = getFormatter(locale, options).formatToParts(1111.1);\n  const result = {};\n  parts.forEach(part => {\n    result[part.type] = part.value;\n  });\n\n  // The formatting options may result in not returning a decimal.\n  getFormatter(locale).formatToParts(0.1).forEach(part => {\n    if (part.type === 'decimal') {\n      result[part.type] = part.value;\n    }\n  });\n  return result;\n}\nexport function parseNumber(formattedNumber, options) {\n  let locale;\n  if (ARABIC_RE.test(formattedNumber)) {\n    locale = 'ar';\n  } else if (HAN_RE.test(formattedNumber)) {\n    locale = 'zh';\n  }\n  const {\n    group,\n    decimal,\n    currency,\n    unit\n  } = getNumberLocaleDetails(locale, options);\n  const regexesToReplace = [{\n    regex: group ? new RegExp(`\\\\${group}`, 'g') : null,\n    replacement: ''\n  }, {\n    regex: decimal ? new RegExp(`\\\\${decimal}`, 'g') : null,\n    replacement: '.'\n  }, {\n    regex: currency ? new RegExp(`\\\\${currency}`, 'g') : null,\n    replacement: ''\n  }, {\n    regex: unit ? new RegExp(`\\\\${unit}`, 'g') : null,\n    replacement: ''\n  }, {\n    regex: ARABIC_RE,\n    replacement: match => ARABIC_NUMERALS.indexOf(match).toString()\n  }, {\n    regex: HAN_RE,\n    replacement: match => HAN_NUMERALS.indexOf(match).toString()\n  }];\n  const unformattedNumber = regexesToReplace.reduce((acc, {\n    regex,\n    replacement\n  }) => {\n    if (!regex) {\n      return acc;\n    }\n    return acc.replace(regex, replacement);\n  }, formattedNumber);\n  let num = parseFloat(unformattedNumber);\n  if (PERCENT_RE.test(formattedNumber)) {\n    num /= 100;\n  }\n  if (Number.isNaN(num)) {\n    return null;\n  }\n  return num;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingFocusManager } from '@floating-ui/react';\nimport { usePopoverRootContext } from '../root/PopoverRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { usePopoverPositionerContext } from '../positioner/PopoverPositionerContext.js';\nimport { usePopoverPopup } from './usePopoverPopup.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { refType } from '../../utils/proptypes.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * A container for the popover contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)\n */\nconst PopoverPopup = /*#__PURE__*/React.forwardRef(function PopoverPopup(props, forwardedRef) {\n  const {\n    className,\n    render,\n    initialFocus,\n    finalFocus,\n    ...otherProps\n  } = props;\n  const {\n    open,\n    instantType,\n    transitionStatus,\n    getRootPopupProps,\n    titleId,\n    descriptionId,\n    popupRef,\n    mounted,\n    openReason,\n    onOpenChangeComplete\n  } = usePopoverRootContext();\n  const positioner = usePopoverPositionerContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const {\n    getPopupProps,\n    resolvedInitialFocus\n  } = usePopoverPopup({\n    getProps: getRootPopupProps,\n    titleId,\n    descriptionId,\n    initialFocus\n  });\n  const state = React.useMemo(() => ({\n    open,\n    side: positioner.side,\n    align: positioner.align,\n    instant: instantType,\n    transitionStatus\n  }), [open, positioner.side, positioner.align, instantType, transitionStatus]);\n  const mergedRef = useForkRef(popupRef, forwardedRef);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getPopupProps,\n    ref: mergedRef,\n    render: render ?? 'div',\n    className,\n    state,\n    extraProps: transitionStatus === 'starting' ? mergeReactProps(otherProps, {\n      style: {\n        transition: 'none'\n      }\n    }) : otherProps,\n    customStyleHookMapping\n  });\n  return /*#__PURE__*/_jsx(FloatingFocusManager, {\n    context: positioner.context,\n    modal: false,\n    disabled: !mounted || openReason === 'hover',\n    initialFocus: resolvedInitialFocus,\n    returnFocus: finalFocus,\n    children: renderElement()\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? PopoverPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Determines the element to focus when the popover is closed.\n   * By default, focus returns to the trigger.\n   */\n  finalFocus: refType,\n  /**\n   * Determines the element to focus when the popover is opened.\n   * By default, the first focusable element is focused.\n   */\n  initialFocus: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.func, refType]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { PopoverPopup };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { usePopoverRootContext } from '../root/PopoverRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * An overlay displayed beneath the popover.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)\n */\nconst PopoverBackdrop = /*#__PURE__*/React.forwardRef(function PopoverBackdrop(props, forwardedRef) {\n  const {\n    className,\n    render,\n    ...other\n  } = props;\n  const {\n    open,\n    mounted,\n    transitionStatus\n  } = usePopoverRootContext();\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus\n  }), [open, transitionStatus]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: {\n      role: 'presentation',\n      hidden: !mounted,\n      ...other\n    },\n    customStyleHookMapping\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? PopoverBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { PopoverBackdrop };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { usePreviewCardRootContext } from '../root/PreviewCardContext.js';\nimport { usePreviewCardPositionerContext } from '../positioner/PreviewCardPositionerContext.js';\nimport { usePreviewCardPopup } from './usePreviewCardPopup.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * A container for the preview card contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Preview Card](https://base-ui.com/react/components/preview-card)\n */\nconst PreviewCardPopup = /*#__PURE__*/React.forwardRef(function PreviewCardPopup(props, forwardedRef) {\n  const {\n    className,\n    render,\n    ...otherProps\n  } = props;\n  const {\n    open,\n    transitionStatus,\n    getRootPopupProps,\n    popupRef,\n    onOpenChangeComplete\n  } = usePreviewCardRootContext();\n  const {\n    side,\n    align\n  } = usePreviewCardPositionerContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const {\n    getPopupProps\n  } = usePreviewCardPopup({\n    getProps: getRootPopupProps\n  });\n  const state = React.useMemo(() => ({\n    open,\n    side,\n    align,\n    transitionStatus\n  }), [open, side, align, transitionStatus]);\n  const mergedRef = useForkRef(popupRef, forwardedRef);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getPopupProps,\n    ref: mergedRef,\n    render: render ?? 'div',\n    className,\n    state,\n    extraProps: transitionStatus === 'starting' ? mergeReactProps(otherProps, {\n      style: {\n        transition: 'none'\n      }\n    }) : otherProps,\n    customStyleHookMapping\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? PreviewCardPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { PreviewCardPopup };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { usePreviewCardRootContext } from '../root/PreviewCardContext.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * An overlay displayed beneath the popup.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Preview Card](https://base-ui.com/react/components/preview-card)\n */\nconst PreviewCardBackdrop = /*#__PURE__*/React.forwardRef(function PreviewCardBackdrop(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...other\n  } = props;\n  const {\n    open,\n    mounted,\n    transitionStatus\n  } = usePreviewCardRootContext();\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus\n  }), [open, transitionStatus]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: {\n      role: 'presentation',\n      hidden: !mounted,\n      ...other\n    },\n    customStyleHookMapping\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? PreviewCardBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { PreviewCardBackdrop };","'use client';\n\nimport * as React from 'react';\nimport { NOOP } from '../utils/noop.js';\nexport const RadioGroupContext = /*#__PURE__*/React.createContext({\n  disabled: undefined,\n  readOnly: undefined,\n  required: undefined,\n  checkedValue: '',\n  setCheckedValue: NOOP,\n  onValueChange: NOOP,\n  touched: false,\n  setTouched: NOOP\n});\nif (process.env.NODE_ENV !== 'production') {\n  RadioGroupContext.displayName = 'RadioGroupContext';\n}\nexport function useRadioGroupContext() {\n  return React.useContext(RadioGroupContext);\n}","import { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { fieldValidityMapping } from '../../field/utils/constants.js';\nexport const customStyleHookMapping = {\n  checked(value) {\n    if (value) {\n      return {\n        'data-checked': ''\n      };\n    }\n    return {\n      'data-unchecked': ''\n    };\n  },\n  ...transitionStatusMapping,\n  ...fieldValidityMapping\n};","import * as React from 'react';\nimport { useClick, useDismiss, useFloatingRootContext, useInteractions, useListNavigation, useRole, useTypeahead } from '@floating-ui/react';\nimport { useFieldControlValidation } from '../../field/control/useFieldControlValidation.js';\nimport { useFieldRootContext } from '../../field/root/FieldRootContext.js';\nimport { useBaseUiId } from '../../utils/useBaseUiId.js';\nimport { useControlled } from '../../utils/useControlled.js';\nimport { useTransitionStatus } from '../../utils/index.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { warn } from '../../utils/warn.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nconst EMPTY_ARRAY = [];\nfunction isDisabled(element) {\n  return element == null || element.hasAttribute('disabled') || element.hasAttribute('data-disabled');\n}\nexport function useSelectRoot(params) {\n  const {\n    id: idProp,\n    disabled = false,\n    readOnly = false,\n    required = false,\n    alignItemToTrigger: alignItemToTriggerParam = true,\n    modal = false,\n    onOpenChangeComplete\n  } = params;\n  const {\n    setDirty,\n    validityData,\n    validationMode,\n    setControlId,\n    setFilled\n  } = useFieldRootContext();\n  const fieldControlValidation = useFieldControlValidation();\n  const id = useBaseUiId(idProp);\n  useEnhancedEffect(() => {\n    setControlId(id);\n    return () => {\n      setControlId(undefined);\n    };\n  }, [id, setControlId]);\n  const [value, setValueUnwrapped] = useControlled({\n    controlled: params.value,\n    default: params.defaultValue,\n    name: 'Select',\n    state: 'value'\n  });\n  const [open, setOpenUnwrapped] = useControlled({\n    controlled: params.open,\n    default: params.defaultOpen,\n    name: 'Select',\n    state: 'open'\n  });\n  useEnhancedEffect(() => {\n    setFilled(value !== null);\n  }, [setFilled, value]);\n  const [controlledAlignItemToTrigger, setcontrolledAlignItemToTrigger] = React.useState(alignItemToTriggerParam);\n  const listRef = React.useRef([]);\n  const labelsRef = React.useRef([]);\n  const popupRef = React.useRef(null);\n  const valueRef = React.useRef(null);\n  const valuesRef = React.useRef([]);\n  const typingRef = React.useRef(false);\n  const selectedItemTextRef = React.useRef(null);\n  const selectionRef = React.useRef({\n    allowSelectedMouseUp: false,\n    allowUnselectedMouseUp: false,\n    allowSelect: false\n  });\n  const [triggerElement, setTriggerElement] = React.useState(null);\n  const [positionerElement, setPositionerElement] = React.useState(null);\n  const [activeIndex, setActiveIndex] = React.useState(null);\n  const [selectedIndex, setSelectedIndex] = React.useState(null);\n  const [label, setLabel] = React.useState('');\n  const [touchModality, setTouchModality] = React.useState(false);\n  const [scrollUpArrowVisible, setScrollUpArrowVisible] = React.useState(false);\n  const [scrollDownArrowVisible, setScrollDownArrowVisible] = React.useState(false);\n  const {\n    mounted,\n    setMounted,\n    transitionStatus\n  } = useTransitionStatus(open);\n  const alignItemToTrigger = Boolean(mounted && controlledAlignItemToTrigger && !touchModality);\n  if (!mounted && controlledAlignItemToTrigger !== alignItemToTriggerParam) {\n    setcontrolledAlignItemToTrigger(alignItemToTriggerParam);\n  }\n  if (!alignItemToTriggerParam || !mounted) {\n    if (scrollUpArrowVisible) {\n      setScrollUpArrowVisible(false);\n    }\n    if (scrollDownArrowVisible) {\n      setScrollDownArrowVisible(false);\n    }\n  }\n  const setOpen = useEventCallback((nextOpen, event) => {\n    params.onOpenChange?.(nextOpen, event);\n    setOpenUnwrapped(nextOpen);\n\n    // Workaround `enableFocusInside` in Floating UI setting `tabindex=0` of a non-highlighted\n    // option upon close when tabbing out due to `keepMounted=true`:\n    // https://github.com/floating-ui/floating-ui/pull/3004/files#diff-962a7439cdeb09ea98d4b622a45d517bce07ad8c3f866e089bda05f4b0bbd875R194-R199\n    // This otherwise causes options to retain `tabindex=0` incorrectly when the popup is closed\n    // when tabbing outside.\n    if (!nextOpen && activeIndex !== null) {\n      const activeOption = listRef.current[activeIndex];\n      // Wait for Floating UI's focus effect to have fired\n      queueMicrotask(() => {\n        activeOption?.setAttribute('tabindex', '-1');\n      });\n    }\n  });\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (!open) {\n        onOpenChangeComplete?.(false);\n        setMounted(false);\n        setActiveIndex(null);\n      }\n    }\n  });\n  const setValue = useEventCallback((nextValue, event) => {\n    params.onValueChange?.(nextValue, event);\n    setValueUnwrapped(nextValue);\n    setDirty(nextValue !== validityData.initialValue);\n    if (validationMode === 'onChange') {\n      fieldControlValidation.commitValidation(nextValue);\n    }\n    const index = valuesRef.current.indexOf(nextValue);\n    setSelectedIndex(index);\n    setLabel(labelsRef.current[index] ?? '');\n  });\n  const hasRegisteredRef = React.useRef(false);\n  const registerSelectedItem = useEventCallback(suppliedIndex => {\n    if (suppliedIndex !== undefined) {\n      hasRegisteredRef.current = true;\n    }\n    const stringValue = typeof value === 'string' || value === null ? value : JSON.stringify(value);\n    const index = suppliedIndex ?? valuesRef.current.indexOf(stringValue);\n    if (index !== -1) {\n      setSelectedIndex(index);\n      setLabel(labelsRef.current[index] ?? '');\n    } else if (value) {\n      warn(`The value \\`${stringValue}\\` is not present in the select items.`);\n    }\n  });\n  useEnhancedEffect(() => {\n    if (!hasRegisteredRef.current) {\n      return;\n    }\n    registerSelectedItem(undefined);\n  }, [value, registerSelectedItem]);\n  const floatingRootContext = useFloatingRootContext({\n    open,\n    onOpenChange: setOpen,\n    elements: {\n      reference: triggerElement,\n      floating: positionerElement\n    }\n  });\n  const triggerDisabled = isDisabled(triggerElement);\n  const click = useClick(floatingRootContext, {\n    enabled: !readOnly && !disabled && !triggerDisabled,\n    event: 'mousedown'\n  });\n  const dismiss = useDismiss(floatingRootContext, {\n    bubbles: false,\n    outsidePressEvent: 'mousedown'\n  });\n  const role = useRole(floatingRootContext, {\n    role: 'select'\n  });\n  const listNavigation = useListNavigation(floatingRootContext, {\n    enabled: !readOnly && !disabled,\n    listRef,\n    activeIndex,\n    selectedIndex,\n    disabledIndices: EMPTY_ARRAY,\n    onNavigate(nextActiveIndex) {\n      // Retain the highlight while transitioning out.\n      if (nextActiveIndex === null && !open) {\n        return;\n      }\n      setActiveIndex(nextActiveIndex);\n    },\n    // Implement our own listeners since `onPointerLeave` on each option fires while scrolling with\n    // the `alignItemToTrigger` prop enabled, causing a performance issue on Chrome.\n    focusItemOnHover: false\n  });\n  const typeahead = useTypeahead(floatingRootContext, {\n    enabled: !readOnly && !disabled,\n    listRef: labelsRef,\n    activeIndex,\n    selectedIndex,\n    onMatch(index) {\n      if (open) {\n        setActiveIndex(index);\n      } else {\n        setValue(valuesRef.current[index]);\n      }\n    },\n    onTypingChange(typing) {\n      // FIXME: Floating UI doesn't support allowing space to select an item while the popup is\n      // closed and the trigger isn't a native <button>.\n      typingRef.current = typing;\n    }\n  });\n  const {\n    getReferenceProps: getRootTriggerProps,\n    getFloatingProps: getRootPositionerProps,\n    getItemProps\n  } = useInteractions([click, dismiss, role, listNavigation, typeahead]);\n  const rootContext = React.useMemo(() => ({\n    id,\n    name: params.name,\n    required,\n    disabled,\n    readOnly,\n    triggerElement,\n    setTriggerElement,\n    positionerElement,\n    setPositionerElement,\n    scrollUpArrowVisible,\n    setScrollUpArrowVisible,\n    scrollDownArrowVisible,\n    setScrollDownArrowVisible,\n    setcontrolledAlignItemToTrigger,\n    value,\n    setValue,\n    open,\n    setOpen,\n    mounted,\n    setMounted,\n    label,\n    setLabel,\n    valueRef,\n    valuesRef,\n    labelsRef,\n    typingRef,\n    selectionRef,\n    getRootPositionerProps,\n    getRootTriggerProps,\n    getItemProps,\n    listRef,\n    popupRef,\n    selectedItemTextRef,\n    floatingRootContext,\n    touchModality,\n    setTouchModality,\n    alignItemToTrigger,\n    transitionStatus,\n    fieldControlValidation,\n    modal,\n    registerSelectedItem,\n    onOpenChangeComplete\n  }), [id, params.name, required, disabled, readOnly, triggerElement, positionerElement, scrollUpArrowVisible, scrollDownArrowVisible, value, setValue, open, setOpen, mounted, setMounted, label, getRootPositionerProps, getRootTriggerProps, getItemProps, floatingRootContext, touchModality, alignItemToTrigger, transitionStatus, fieldControlValidation, modal, registerSelectedItem, onOpenChangeComplete]);\n  const indexContext = React.useMemo(() => ({\n    activeIndex,\n    setActiveIndex,\n    selectedIndex,\n    setSelectedIndex\n  }), [activeIndex, selectedIndex, setActiveIndex]);\n  return React.useMemo(() => ({\n    rootContext,\n    indexContext\n  }), [rootContext, indexContext]);\n}","import * as React from 'react';\nexport const SelectRootContext = /*#__PURE__*/React.createContext(null);\nexport function useSelectRootContext() {\n  const context = React.useContext(SelectRootContext);\n  if (context === null) {\n    throw new Error('useSelectRootContext must be used within a SelectRoot');\n  }\n  return context;\n}","import * as React from 'react';\nexport const SelectIndexContext = /*#__PURE__*/React.createContext(undefined);\nexport function useSelectIndexContext() {\n  const context = React.useContext(SelectIndexContext);\n  if (context === undefined) {\n    throw new Error('Base UI: SelectIndexContext is missing. Select parts must be placed within <Select.Root>.');\n  }\n  return context;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useSelectRoot } from './useSelectRoot.js';\nimport { SelectRootContext } from './SelectRootContext.js';\nimport { SelectIndexContext } from './SelectIndexContext.js';\nimport { useFieldRootContext } from '../../field/root/FieldRootContext.js';\nimport { visuallyHidden } from '../../utils/visuallyHidden.js';\n\n/**\n * Groups all parts of the select.\n * Doesn’t render its own HTML element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst SelectRoot = function SelectRoot(props) {\n  const {\n    value: valueProp,\n    defaultValue = null,\n    onValueChange,\n    open,\n    defaultOpen = false,\n    onOpenChange,\n    alignItemToTrigger = true,\n    name,\n    disabled = false,\n    readOnly = false,\n    required = false,\n    modal = true,\n    onOpenChangeComplete\n  } = props;\n  const selectRoot = useSelectRoot({\n    value: valueProp,\n    defaultValue,\n    onValueChange,\n    open,\n    defaultOpen,\n    onOpenChange,\n    alignItemToTrigger,\n    name,\n    disabled,\n    readOnly,\n    required,\n    modal,\n    onOpenChangeComplete\n  });\n  const {\n    setDirty,\n    validityData,\n    validationMode\n  } = useFieldRootContext();\n  const {\n    rootContext\n  } = selectRoot;\n  const value = rootContext.value;\n  const serializedValue = React.useMemo(() => {\n    if (value == null) {\n      return ''; // avoid uncontrolled -> controlled error\n    }\n    if (typeof value === 'string') {\n      return value;\n    }\n    return JSON.stringify(value);\n  }, [value]);\n  return /*#__PURE__*/_jsx(SelectRootContext.Provider, {\n    value: selectRoot.rootContext,\n    children: /*#__PURE__*/_jsxs(SelectIndexContext.Provider, {\n      value: selectRoot.indexContext,\n      children: [props.children, /*#__PURE__*/_jsx(\"input\", {\n        ...rootContext.fieldControlValidation.getInputValidationProps({\n          onFocus() {\n            // Move focus to the trigger element when the hidden input is focused.\n            rootContext.triggerElement?.focus();\n          },\n          // Handle browser autofill.\n          onChange(event) {\n            // Workaround for https://github.com/facebook/react/issues/9023\n            if (event.nativeEvent.defaultPrevented) {\n              return;\n            }\n            const nextValue = event.target.value;\n            const exactValue = rootContext.valuesRef.current.find(v => v === nextValue || typeof value === 'string' && nextValue.toLowerCase() === v.toLowerCase());\n            if (exactValue != null) {\n              setDirty(exactValue !== validityData.initialValue);\n              rootContext.setValue?.(exactValue, event.nativeEvent);\n              if (validationMode === 'onChange') {\n                selectRoot.rootContext.fieldControlValidation.commitValidation(exactValue);\n              }\n            }\n          },\n          id: rootContext.id,\n          name: rootContext.name,\n          disabled: rootContext.disabled,\n          required: rootContext.required,\n          readOnly: rootContext.readOnly,\n          value: serializedValue,\n          ref: rootContext.fieldControlValidation.inputRef,\n          style: visuallyHidden,\n          tabIndex: -1,\n          'aria-hidden': true\n        })\n      })]\n    })\n  });\n};\nprocess.env.NODE_ENV !== \"production\" ? SelectRoot.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * Determines if the selected item inside the popup should align to the trigger element.\n   * @default true\n   */\n  alignItemToTrigger: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * Whether the select menu is initially open.\n   *\n   * To render a controlled select menu, use the `open` prop instead.\n   * @default false\n   */\n  defaultOpen: PropTypes.bool,\n  /**\n   * The uncontrolled value of the select when it’s initially rendered.\n   *\n   * To render a controlled select, use the `value` prop instead.\n   * @default null\n   */\n  defaultValue: PropTypes.any,\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Whether the select should prevent outside clicks and lock page scroll when open.\n   * @default true\n   */\n  modal: PropTypes.bool,\n  /**\n   * Identifies the field when a form is submitted.\n   */\n  name: PropTypes.string,\n  /**\n   * Event handler called when the select menu is opened or closed.\n   */\n  onOpenChange: PropTypes.func,\n  /**\n   * Event handler called after any animations complete when the select menu is opened or closed.\n   */\n  onOpenChangeComplete: PropTypes.func,\n  /**\n   * Callback fired when the value of the select changes. Use when controlled.\n   */\n  onValueChange: PropTypes.func,\n  /**\n   * Whether the select menu is currently open.\n   */\n  open: PropTypes.bool,\n  /**\n   * Whether the user should be unable to choose a different option from the select menu.\n   * @default false\n   */\n  readOnly: PropTypes.bool,\n  /**\n   * Whether the user must choose a value before submitting a form.\n   * @default false\n   */\n  required: PropTypes.bool,\n  /**\n   * The value of the select.\n   */\n  value: PropTypes.any\n} : void 0;\nexport { SelectRoot };","import * as React from 'react';\nimport { contains } from '@floating-ui/react/utils';\nimport { useButton } from '../../use-button/useButton.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { ownerDocument } from '../../utils/owner.js';\nimport { useFieldRootContext } from '../../field/root/FieldRootContext.js';\nimport { getPseudoElementBounds } from '../../utils/getPseudoElementBounds.js';\nexport function useSelectTrigger(parameters) {\n  const BOUNDARY_OFFSET = 2;\n  const {\n    disabled = false,\n    rootRef: externalRef\n  } = parameters;\n  const {\n    open,\n    setOpen,\n    setTriggerElement,\n    selectionRef,\n    value,\n    fieldControlValidation,\n    setTouchModality,\n    positionerElement,\n    alignItemToTrigger,\n    readOnly\n  } = useSelectRootContext();\n  const {\n    labelId,\n    setTouched,\n    setFocused,\n    validationMode\n  } = useFieldRootContext();\n  const triggerRef = React.useRef(null);\n  const timeoutRef = React.useRef(-1);\n  const mergedRef = useForkRef(externalRef, triggerRef);\n  const {\n    getButtonProps,\n    buttonRef\n  } = useButton({\n    disabled,\n    buttonRef: mergedRef\n  });\n  const handleRef = useForkRef(buttonRef, setTriggerElement);\n  React.useEffect(() => {\n    if (open) {\n      // mousedown -> mouseup on selected item should not select within 400ms.\n      const timeoutId1 = window.setTimeout(() => {\n        selectionRef.current.allowSelectedMouseUp = true;\n      }, 400);\n      // mousedown -> move to unselected item -> mouseup should not select within 200ms.\n      const timeoutId2 = window.setTimeout(() => {\n        selectionRef.current.allowUnselectedMouseUp = true;\n      }, 200);\n      return () => {\n        clearTimeout(timeoutId1);\n        clearTimeout(timeoutId2);\n      };\n    }\n    selectionRef.current = {\n      allowSelectedMouseUp: false,\n      allowUnselectedMouseUp: false,\n      allowSelect: true\n    };\n    clearTimeout(timeoutRef.current);\n    return undefined;\n  }, [open, selectionRef]);\n  const getTriggerProps = React.useCallback(externalProps => {\n    return getButtonProps(mergeReactProps(fieldControlValidation.getValidationProps(externalProps), {\n      'aria-labelledby': labelId,\n      'aria-readonly': readOnly || undefined,\n      tabIndex: disabled ? -1 : 0,\n      // this is needed to make the button focused after click in Safari\n      ref: handleRef,\n      onFocus() {\n        setFocused(true);\n        // The popup element shouldn't obscure the focused trigger.\n        if (open && alignItemToTrigger) {\n          setOpen(false);\n        }\n      },\n      onBlur() {\n        setTouched(true);\n        setFocused(false);\n        if (validationMode === 'onBlur') {\n          fieldControlValidation.commitValidation(value);\n        }\n      },\n      onPointerMove({\n        pointerType\n      }) {\n        setTouchModality(pointerType === 'touch');\n      },\n      onPointerDown({\n        pointerType\n      }) {\n        setTouchModality(pointerType === 'touch');\n      },\n      onMouseDown(event) {\n        if (open) {\n          return;\n        }\n        const doc = ownerDocument(event.currentTarget);\n        function handleMouseUp(mouseEvent) {\n          if (!triggerRef.current) {\n            return;\n          }\n          const mouseUpTarget = mouseEvent.target;\n\n          // Early return if clicked on trigger element or its children\n          if (contains(triggerRef.current, mouseUpTarget) || contains(positionerElement, mouseUpTarget) || mouseUpTarget === triggerRef.current) {\n            return;\n          }\n          const bounds = getPseudoElementBounds(triggerRef.current);\n          if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) {\n            return;\n          }\n          setOpen(false, mouseEvent);\n        }\n\n        // Firefox can fire this upon mousedown\n        timeoutRef.current = window.setTimeout(() => {\n          doc.addEventListener('mouseup', handleMouseUp, {\n            once: true\n          });\n        });\n      }\n    }));\n  }, [getButtonProps, fieldControlValidation, labelId, readOnly, disabled, handleRef, setFocused, open, alignItemToTrigger, setOpen, setTouched, setTouchModality, validationMode, value, positionerElement]);\n  return React.useMemo(() => ({\n    getTriggerProps,\n    rootRef: handleRef\n  }), [getTriggerProps, handleRef]);\n}","export function getPseudoElementBounds(element) {\n  const elementRect = element.getBoundingClientRect();\n  const beforeStyles = window.getComputedStyle(element, '::before');\n  const afterStyles = window.getComputedStyle(element, '::after');\n  const hasPseudoElements = beforeStyles.content !== 'none' || afterStyles.content !== 'none';\n  if (!hasPseudoElements) {\n    return elementRect;\n  }\n\n  // Get dimensions of pseudo-elements\n  const beforeWidth = parseFloat(beforeStyles.width) || 0;\n  const beforeHeight = parseFloat(beforeStyles.height) || 0;\n  const afterWidth = parseFloat(afterStyles.width) || 0;\n  const afterHeight = parseFloat(afterStyles.height) || 0;\n\n  // Calculate max dimensions including pseudo-elements\n  const totalWidth = Math.max(elementRect.width, beforeWidth, afterWidth);\n  const totalHeight = Math.max(elementRect.height, beforeHeight, afterHeight);\n\n  // Calculate the differences to extend the bounds\n  const widthDiff = totalWidth - elementRect.width;\n  const heightDiff = totalHeight - elementRect.height;\n  return {\n    left: elementRect.left - widthDiff / 2,\n    right: elementRect.right + widthDiff / 2,\n    top: elementRect.top - heightDiff / 2,\n    bottom: elementRect.bottom + heightDiff / 2\n  };\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useSelectTrigger } from './useSelectTrigger.js';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useFieldRootContext } from '../../field/root/FieldRootContext.js';\nimport { pressableTriggerOpenStateMapping } from '../../utils/popupStateMapping.js';\nimport { fieldValidityMapping } from '../../field/utils/constants.js';\n\n/**\n * A button that opens the select menu.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nconst SelectTrigger = /*#__PURE__*/React.forwardRef(function SelectTrigger(props, forwardedRef) {\n  const {\n    render,\n    className,\n    disabled: disabledProp = false,\n    ...otherProps\n  } = props;\n  const {\n    state: fieldState,\n    disabled: fieldDisabled\n  } = useFieldRootContext();\n  const {\n    getRootTriggerProps,\n    disabled: selectDisabled,\n    open\n  } = useSelectRootContext();\n  const disabled = fieldDisabled || selectDisabled || disabledProp;\n  const {\n    getTriggerProps\n  } = useSelectTrigger({\n    disabled,\n    rootRef: forwardedRef\n  });\n  const state = React.useMemo(() => ({\n    ...fieldState,\n    open,\n    disabled\n  }), [fieldState, open, disabled]);\n  const styleHookMapping = React.useMemo(() => ({\n    ...pressableTriggerOpenStateMapping,\n    ...fieldValidityMapping\n  }), []);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    propGetter: externalProps => getTriggerProps(getRootTriggerProps(externalProps)),\n    customStyleHookMapping: styleHookMapping,\n    extraProps: otherProps\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? SelectTrigger.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { SelectTrigger };","import * as React from 'react';\nexport const SelectPortalContext = /*#__PURE__*/React.createContext(undefined);\nexport function useSelectPortalContext() {\n  const value = React.useContext(SelectPortalContext);\n  if (value === undefined) {\n    throw new Error('Base UI: <Select.Portal> is missing.');\n  }\n  return value;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingPortal } from '@floating-ui/react';\nimport { HTMLElementType, refType } from '../../utils/proptypes.js';\nimport { SelectPortalContext } from './SelectPortalContext.js';\n\n/**\n * A portal element that moves the popup to a different part of the DOM.\n * By default, the portal element is appended to `<body>`.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction SelectPortal(props) {\n  const {\n    children,\n    container\n  } = props;\n  return /*#__PURE__*/_jsx(SelectPortalContext.Provider, {\n    value: true,\n    children: /*#__PURE__*/_jsx(FloatingPortal, {\n      root: container,\n      children: children\n    })\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? SelectPortal.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * A parent element to render the portal element into.\n   */\n  container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, refType])\n} : void 0;\nexport { SelectPortal };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { popupStateMapping } from '../../utils/popupStateMapping.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nconst customStyleHookMapping = {\n  ...popupStateMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * An overlay displayed beneath the menu popup.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nconst SelectBackdrop = /*#__PURE__*/React.forwardRef(function SelectBackdrop(props, forwardedRef) {\n  const {\n    className,\n    render,\n    ...other\n  } = props;\n  const {\n    open,\n    mounted,\n    transitionStatus\n  } = useSelectRootContext();\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus\n  }), [open, transitionStatus]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    render: render ?? 'div',\n    className,\n    state,\n    ref: forwardedRef,\n    extraProps: {\n      role: 'presentation',\n      hidden: !mounted,\n      ...other\n    },\n    customStyleHookMapping\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? SelectBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { SelectBackdrop };","import * as React from 'react';\nimport { useAnchorPositioning } from '../../utils/useAnchorPositioning.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { useScrollLock } from '../../utils/useScrollLock.js';\nexport function useSelectPositioner(params) {\n  const {\n    open,\n    alignItemToTrigger,\n    mounted,\n    triggerElement,\n    modal\n  } = useSelectRootContext();\n  useScrollLock((alignItemToTrigger || modal) && open, triggerElement);\n  const positioning = useAnchorPositioning({\n    ...params,\n    trackAnchor: params.trackAnchor ?? !alignItemToTrigger\n  });\n  const positionerStyles = React.useMemo(() => alignItemToTrigger ? {\n    position: 'fixed'\n  } : positioning.positionerStyles, [alignItemToTrigger, positioning.positionerStyles]);\n  const getPositionerProps = React.useCallback((externalProps = {}) => {\n    const hiddenStyles = {};\n    if (!open) {\n      hiddenStyles.pointerEvents = 'none';\n    }\n    return mergeReactProps(externalProps, {\n      role: 'presentation',\n      hidden: !mounted,\n      style: {\n        ...positionerStyles,\n        ...hiddenStyles\n      }\n    });\n  }, [open, mounted, positionerStyles]);\n  return React.useMemo(() => ({\n    ...positioning,\n    side: alignItemToTrigger ? 'none' : positioning.side,\n    getPositionerProps\n  }), [alignItemToTrigger, getPositionerProps, positioning]);\n}","import * as React from 'react';\nexport const SelectPositionerContext = /*#__PURE__*/React.createContext(null);\nexport function useSelectPositionerContext() {\n  const context = React.useContext(SelectPositionerContext);\n  if (context === null) {\n    throw new Error('Base UI: SelectPositionerContext is missing. SelectPositioner parts must be placed within <Select.Positioner>.');\n  }\n  return context;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { CompositeList } from '../../composite/list/CompositeList.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { popupStateMapping } from '../../utils/popupStateMapping.js';\nimport { useSelectPositioner } from './useSelectPositioner.js';\nimport { SelectPositionerContext } from './SelectPositionerContext.js';\nimport { InternalBackdrop } from '../../utils/InternalBackdrop.js';\nimport { HTMLElementType, refType } from '../../utils/proptypes.js';\n\n/**\n * Positions the select menu popup against the trigger.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst SelectPositioner = /*#__PURE__*/React.forwardRef(function SelectPositioner(props, ref) {\n  const {\n    anchor,\n    positionMethod = 'absolute',\n    className,\n    render,\n    side = 'bottom',\n    align = 'center',\n    sideOffset = 0,\n    alignOffset = 0,\n    collisionBoundary = 'clipping-ancestors',\n    collisionPadding,\n    arrowPadding = 5,\n    sticky = false,\n    trackAnchor = true,\n    ...otherProps\n  } = props;\n  const {\n    open,\n    mounted,\n    setPositionerElement,\n    listRef,\n    labelsRef,\n    floatingRootContext,\n    modal\n  } = useSelectRootContext();\n  const positioner = useSelectPositioner({\n    anchor,\n    floatingRootContext,\n    positionMethod,\n    mounted,\n    side,\n    sideOffset,\n    align,\n    alignOffset,\n    arrowPadding,\n    collisionBoundary,\n    collisionPadding,\n    sticky,\n    trackAnchor,\n    keepMounted: true\n  });\n  const mergedRef = useForkRef(ref, setPositionerElement);\n  const state = React.useMemo(() => ({\n    open,\n    side: positioner.side,\n    align: positioner.align,\n    anchorHidden: positioner.anchorHidden\n  }), [open, positioner.side, positioner.align, positioner.anchorHidden]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: positioner.getPositionerProps,\n    render: render ?? 'div',\n    ref: mergedRef,\n    className,\n    state,\n    customStyleHookMapping: popupStateMapping,\n    extraProps: otherProps\n  });\n  return /*#__PURE__*/_jsx(CompositeList, {\n    elementsRef: listRef,\n    labelsRef: labelsRef,\n    children: /*#__PURE__*/_jsxs(SelectPositionerContext.Provider, {\n      value: positioner,\n      children: [mounted && modal && /*#__PURE__*/_jsx(InternalBackdrop, {\n        inert: !open\n      }), renderElement()]\n    })\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? SelectPositioner.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * How to align the popup relative to the specified side.\n   * @default 'center'\n   */\n  align: PropTypes.oneOf(['center', 'end', 'start']),\n  /**\n   * Additional offset along the alignment axis in pixels.\n   * Also accepts a function that returns the offset to read the dimensions of the anchor\n   * and positioner elements, along with its side and alignment.\n   *\n   * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.\n   * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.\n   * - `data.side`: which side of the anchor element the positioner is aligned against.\n   * - `data.align`: how the positioner is aligned relative to the specified side.\n   * @default 0\n   */\n  alignOffset: PropTypes.oneOfType([PropTypes.func, PropTypes.number]),\n  /**\n   * An element to position the popup against.\n   * By default, the popup will be positioned against the trigger.\n   */\n  anchor: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, refType, PropTypes.object, PropTypes.func]),\n  /**\n   * Minimum distance to maintain between the arrow and the edges of the popup.\n   *\n   * Use it to prevent the arrow element from hanging out of the rounded corners of a popup.\n   * @default 5\n   */\n  arrowPadding: PropTypes.number,\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * An element or a rectangle that delimits the area that the popup is confined to.\n   * @default 'clipping-ancestors'\n   */\n  collisionBoundary: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.arrayOf(HTMLElementType), PropTypes.string, PropTypes.shape({\n    height: PropTypes.number,\n    width: PropTypes.number,\n    x: PropTypes.number,\n    y: PropTypes.number\n  })]),\n  /**\n   * Additional space to maintain from the edge of the collision boundary.\n   * @default 5\n   */\n  collisionPadding: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({\n    bottom: PropTypes.number,\n    left: PropTypes.number,\n    right: PropTypes.number,\n    top: PropTypes.number\n  })]),\n  /**\n   * Determines which CSS `position` property to use.\n   * @default 'absolute'\n   */\n  positionMethod: PropTypes.oneOf(['absolute', 'fixed']),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * Which side of the anchor element to align the popup against.\n   * May automatically change to avoid collisions.\n   * @default 'bottom'\n   */\n  side: PropTypes.oneOf(['bottom', 'inline-end', 'inline-start', 'left', 'right', 'top']),\n  /**\n   * Distance between the anchor and the popup in pixels.\n   * Also accepts a function that returns the distance to read the dimensions of the anchor\n   * and positioner elements, along with its side and alignment.\n   *\n   * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.\n   * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.\n   * - `data.side`: which side of the anchor element the positioner is aligned against.\n   * - `data.align`: how the positioner is aligned relative to the specified side.\n   * @default 0\n   */\n  sideOffset: PropTypes.oneOfType([PropTypes.func, PropTypes.number]),\n  /**\n   * Whether to maintain the popup in the viewport after\n   * the anchor element was scrolled out of view.\n   * @default false\n   */\n  sticky: PropTypes.bool,\n  /**\n   * Whether the popup tracks any layout shift of its positioning anchor.\n   * @default true\n   */\n  trackAnchor: PropTypes.bool\n} : void 0;\nexport { SelectPositioner };","export function clearPositionerStyles(positionerElement, originalPositionerStyles) {\n  Object.assign(positionerElement.style, originalPositionerStyles);\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { FloatingFocusManager } from '@floating-ui/react';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { popupStateMapping } from '../../utils/popupStateMapping.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useSelectPopup } from './useSelectPopup.js';\nimport { useSelectPositionerContext } from '../positioner/SelectPositionerContext.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst customStyleHookMapping = {\n  ...popupStateMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * A container for the select items.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nconst SelectPopup = /*#__PURE__*/React.forwardRef(function SelectPopup(props, forwardedRef) {\n  const {\n    render,\n    className,\n    ...otherProps\n  } = props;\n  const {\n    id,\n    open,\n    popupRef,\n    transitionStatus,\n    alignItemToTrigger,\n    mounted,\n    modal,\n    onOpenChangeComplete\n  } = useSelectRootContext();\n  const positioner = useSelectPositionerContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const {\n    getPopupProps\n  } = useSelectPopup();\n  const mergedRef = useForkRef(forwardedRef, popupRef);\n  const state = React.useMemo(() => ({\n    open,\n    transitionStatus,\n    side: positioner.side,\n    align: positioner.align\n  }), [open, transitionStatus, positioner]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getPopupProps,\n    render: render ?? 'div',\n    ref: mergedRef,\n    className,\n    state,\n    customStyleHookMapping,\n    extraProps: transitionStatus === 'starting' ? mergeReactProps(otherProps, {\n      style: {\n        transition: 'none'\n      }\n    }) : otherProps\n  });\n  const popupSelector = `[data-id=\"${id}-popup\"]`;\n  const html = React.useMemo(() => ({\n    __html: `${popupSelector}{scrollbar-width:none}${popupSelector}::-webkit-scrollbar{display:none}`\n  }), [popupSelector]);\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [id && alignItemToTrigger && /*#__PURE__*/_jsx(\"style\", {\n      // eslint-disable-next-line react/no-danger\n      dangerouslySetInnerHTML: html\n    }), /*#__PURE__*/_jsx(FloatingFocusManager, {\n      context: positioner.context,\n      modal: false,\n      disabled: !mounted,\n      visuallyHiddenDismiss: modal ? 'Dismiss popup' : undefined,\n      children: renderElement()\n    })]\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? SelectPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { SelectPopup };","import * as React from 'react';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { ownerDocument, ownerWindow } from '../../utils/owner.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { clearPositionerStyles } from './utils.js';\nimport { isWebKit } from '../../utils/detectBrowser.js';\nexport function useSelectPopup() {\n  const {\n    mounted,\n    id,\n    setOpen,\n    getRootPositionerProps,\n    alignItemToTrigger,\n    triggerElement,\n    positionerElement,\n    valueRef,\n    selectedItemTextRef,\n    popupRef,\n    scrollUpArrowVisible,\n    scrollDownArrowVisible,\n    setScrollUpArrowVisible,\n    setScrollDownArrowVisible,\n    setcontrolledAlignItemToTrigger\n  } = useSelectRootContext();\n  const initialHeightRef = React.useRef(0);\n  const reachedMaxHeightRef = React.useRef(false);\n  const maxHeightRef = React.useRef(0);\n  const initialPlacedRef = React.useRef(false);\n  const originalPositionerStylesRef = React.useRef({});\n  const handleScrollArrowVisibility = useEventCallback(() => {\n    if (!alignItemToTrigger || !popupRef.current) {\n      return;\n    }\n    const isScrolledToTop = popupRef.current.scrollTop < 1;\n    const isScrolledToBottom = popupRef.current.scrollTop + popupRef.current.clientHeight >= popupRef.current.scrollHeight - 1;\n    if (scrollUpArrowVisible !== !isScrolledToTop) {\n      setScrollUpArrowVisible(!isScrolledToTop);\n    }\n    if (scrollDownArrowVisible !== !isScrolledToBottom) {\n      setScrollDownArrowVisible(!isScrolledToBottom);\n    }\n  });\n  useEnhancedEffect(() => {\n    if (alignItemToTrigger || !positionerElement || Object.keys(originalPositionerStylesRef.current).length) {\n      return;\n    }\n    originalPositionerStylesRef.current = {\n      top: positionerElement.style.top || '0',\n      left: positionerElement.style.left || '0',\n      right: positionerElement.style.right,\n      height: positionerElement.style.height,\n      bottom: positionerElement.style.bottom,\n      minHeight: positionerElement.style.minHeight,\n      maxHeight: positionerElement.style.maxHeight,\n      marginTop: positionerElement.style.marginTop,\n      marginBottom: positionerElement.style.marginBottom\n    };\n  }, [alignItemToTrigger, positionerElement]);\n  useEnhancedEffect(() => {\n    if (mounted || alignItemToTrigger) {\n      return;\n    }\n    initialPlacedRef.current = false;\n    reachedMaxHeightRef.current = false;\n    initialHeightRef.current = 0;\n    maxHeightRef.current = 0;\n    if (positionerElement) {\n      clearPositionerStyles(positionerElement, originalPositionerStylesRef.current);\n    }\n  }, [mounted, alignItemToTrigger, positionerElement]);\n  useEnhancedEffect(() => {\n    if (!mounted || !alignItemToTrigger || !triggerElement || !positionerElement || !popupRef.current) {\n      return;\n    }\n    const positionerStyles = getComputedStyle(positionerElement);\n    const popupStyles = getComputedStyle(popupRef.current);\n    const doc = ownerDocument(triggerElement);\n    const win = ownerWindow(positionerElement);\n    const triggerRect = triggerElement.getBoundingClientRect();\n    const positionerRect = positionerElement.getBoundingClientRect();\n    const triggerX = triggerRect.left;\n    const triggerHeight = triggerRect.height;\n    const scrollHeight = popupRef.current.scrollHeight;\n    const borderBottom = parseFloat(popupStyles.borderBottomWidth);\n    const marginTop = parseFloat(positionerStyles.marginTop) || 10;\n    const marginBottom = parseFloat(positionerStyles.marginBottom) || 10;\n    const minHeight = parseFloat(positionerStyles.minHeight) || 100;\n    const paddingLeft = 5;\n    const paddingRight = 5;\n    const triggerCollisionThreshold = 20;\n    const viewportHeight = doc.documentElement.clientHeight - marginTop - marginBottom;\n    const viewportWidth = doc.documentElement.clientWidth;\n    const availableSpaceBeneathTrigger = viewportHeight - triggerRect.bottom + triggerHeight;\n    const textElement = selectedItemTextRef.current;\n    const valueElement = valueRef.current;\n    let offsetX = 0;\n    let offsetY = 0;\n    if (textElement && valueElement) {\n      const valueRect = valueElement.getBoundingClientRect();\n      const textRect = textElement.getBoundingClientRect();\n      const valueLeftFromTriggerLeft = valueRect.left - triggerX;\n      const textLeftFromPositionerLeft = textRect.left - positionerRect.left;\n      const valueCenterFromPositionerTop = valueRect.top - triggerRect.top + valueRect.height / 2;\n      const textCenterFromTriggerTop = textRect.top - positionerRect.top + textRect.height / 2;\n      offsetX = valueLeftFromTriggerLeft - textLeftFromPositionerLeft;\n      offsetY = textCenterFromTriggerTop - valueCenterFromPositionerTop;\n    }\n    const idealHeight = availableSpaceBeneathTrigger + offsetY + marginBottom + borderBottom;\n    let height = Math.min(viewportHeight, idealHeight);\n    const maxHeight = viewportHeight - marginTop - marginBottom;\n    const scrollTop = idealHeight - height;\n    const left = Math.max(paddingLeft, triggerX + offsetX);\n    const maxRight = viewportWidth - paddingRight;\n    const rightOverflow = Math.max(0, left + positionerRect.width - maxRight);\n    positionerElement.style.left = `${left - rightOverflow}px`;\n    positionerElement.style.height = `${height}px`;\n    positionerElement.style.maxHeight = 'auto';\n    positionerElement.style.marginTop = `${marginTop}px`;\n    positionerElement.style.marginBottom = `${marginBottom}px`;\n    const maxScrollTop = popupRef.current.scrollHeight - popupRef.current.clientHeight;\n    const isTopPositioned = scrollTop >= maxScrollTop;\n    if (isTopPositioned) {\n      height = Math.min(viewportHeight, positionerRect.height) - (scrollTop - maxScrollTop);\n    }\n\n    // When the trigger is too close to the top or bottom of the viewport, or the minHeight is\n    // reached, we fallback to aligning the popup to the trigger as the UX is poor otherwise.\n    const fallbackToAlignPopupToTrigger = triggerRect.top < triggerCollisionThreshold || triggerRect.bottom > viewportHeight - triggerCollisionThreshold || height < Math.min(scrollHeight, minHeight);\n\n    // Safari doesn't position the popup correctly when pinch-zoomed.\n    const isPinchZoomed = (win.visualViewport?.scale ?? 1) !== 1 && isWebKit();\n    if (fallbackToAlignPopupToTrigger || isPinchZoomed) {\n      initialPlacedRef.current = true;\n      clearPositionerStyles(positionerElement, originalPositionerStylesRef.current);\n      setcontrolledAlignItemToTrigger(false);\n      return;\n    }\n    if (isTopPositioned) {\n      const topOffset = Math.max(0, viewportHeight - idealHeight);\n      positionerElement.style.top = positionerRect.height >= maxHeight ? '0' : `${topOffset}px`;\n      positionerElement.style.height = `${height}px`;\n      popupRef.current.scrollTop = popupRef.current.scrollHeight - popupRef.current.clientHeight;\n      initialHeightRef.current = Math.max(minHeight, height);\n    } else {\n      positionerElement.style.bottom = '0';\n      initialHeightRef.current = Math.max(minHeight, height);\n      popupRef.current.scrollTop = scrollTop;\n    }\n    if (initialHeightRef.current === viewportHeight) {\n      reachedMaxHeightRef.current = true;\n    }\n    handleScrollArrowVisibility();\n\n    // Avoid the `onScroll` event logic from triggering before the popup is placed.\n    setTimeout(() => {\n      initialPlacedRef.current = true;\n    });\n  }, [mounted, alignItemToTrigger, positionerElement, triggerElement, valueRef, selectedItemTextRef, popupRef, setScrollUpArrowVisible, setScrollDownArrowVisible, handleScrollArrowVisibility, setcontrolledAlignItemToTrigger]);\n  React.useEffect(() => {\n    if (!alignItemToTrigger || !positionerElement || !mounted) {\n      return undefined;\n    }\n    const win = ownerWindow(positionerElement);\n    function handleResize() {\n      setOpen(false);\n    }\n    win.addEventListener('resize', handleResize);\n    return () => {\n      win.removeEventListener('resize', handleResize);\n    };\n  }, [setOpen, alignItemToTrigger, positionerElement, mounted]);\n  const getPopupProps = React.useCallback((externalProps = {}) => {\n    return mergeReactProps(getRootPositionerProps(externalProps), {\n      ['data-id']: `${id}-popup`,\n      onScroll(event) {\n        if (!alignItemToTrigger || !positionerElement || !popupRef.current || !initialPlacedRef.current) {\n          return;\n        }\n        if (reachedMaxHeightRef.current || !alignItemToTrigger) {\n          handleScrollArrowVisibility();\n          return;\n        }\n        const isTopPositioned = positionerElement.style.top === '0px';\n        const isBottomPositioned = positionerElement.style.bottom === '0px';\n        const currentHeight = positionerElement.getBoundingClientRect().height;\n        const doc = ownerDocument(positionerElement);\n        const positionerStyles = getComputedStyle(positionerElement);\n        const marginTop = parseFloat(positionerStyles.marginTop);\n        const marginBottom = parseFloat(positionerStyles.marginBottom);\n        const viewportHeight = doc.documentElement.clientHeight - marginTop - marginBottom;\n        if (isTopPositioned) {\n          const scrollTop = event.currentTarget.scrollTop;\n          const maxScrollTop = event.currentTarget.scrollHeight - event.currentTarget.clientHeight;\n          const diff = maxScrollTop - scrollTop;\n          const nextHeight = Math.min(currentHeight + diff, viewportHeight);\n          positionerElement.style.height = `${Math.min(currentHeight + diff, viewportHeight)}px`;\n          if (nextHeight !== viewportHeight) {\n            event.currentTarget.scrollTop = maxScrollTop;\n          } else {\n            reachedMaxHeightRef.current = true;\n          }\n        } else if (isBottomPositioned) {\n          const scrollTop = event.currentTarget.scrollTop;\n          const minScrollTop = 0;\n          const diff = scrollTop - minScrollTop;\n          const nextHeight = Math.min(currentHeight + diff, viewportHeight);\n          const idealHeight = currentHeight + diff;\n          const overshoot = idealHeight - viewportHeight;\n          positionerElement.style.height = `${Math.min(idealHeight, viewportHeight)}px`;\n          if (nextHeight !== viewportHeight) {\n            event.currentTarget.scrollTop = 0;\n          } else {\n            reachedMaxHeightRef.current = true;\n            if (event.currentTarget.scrollTop < event.currentTarget.scrollHeight - event.currentTarget.clientHeight) {\n              event.currentTarget.scrollTop -= diff - overshoot;\n            }\n          }\n        }\n        handleScrollArrowVisibility();\n      },\n      ...(alignItemToTrigger && {\n        style: {\n          position: 'relative',\n          maxHeight: '100%',\n          overflowX: 'hidden',\n          overflowY: 'auto'\n        }\n      })\n    });\n  }, [getRootPositionerProps, id, alignItemToTrigger, positionerElement, popupRef, handleScrollArrowVisibility]);\n  return React.useMemo(() => ({\n    getPopupProps\n  }), [getPopupProps]);\n}","import * as React from 'react';\nexport const SelectItemContext = /*#__PURE__*/React.createContext(undefined);\nexport function useSelectItemContext() {\n  const context = React.useContext(SelectItemContext);\n  if (context === undefined) {\n    throw new Error('Base UI: SelectItemContext is missing. SelectItem parts must be placed within <Select.Item>.');\n  }\n  return context;\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useSelectRootContext } from '../root/SelectRootContext.js';\nimport { useSelectIndexContext } from '../root/SelectIndexContext.js';\nimport { useCompositeListItem } from '../../composite/list/useCompositeListItem.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useSelectItem } from './useSelectItem.js';\nimport { useEnhancedEffect } from '../../utils/useEnhancedEffect.js';\nimport { useLatestRef } from '../../utils/useLatestRef.js';\nimport { SelectItemContext } from './SelectItemContext.js';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst InnerSelectItem = /*#__PURE__*/React.forwardRef(function InnerSelectItem(props, forwardedRef) {\n  const {\n    className,\n    disabled = false,\n    highlighted,\n    selected,\n    getRootItemProps,\n    render,\n    setOpen,\n    typingRef,\n    selectionRef,\n    open,\n    value,\n    setValue,\n    selectedIndexRef,\n    indexRef,\n    setActiveIndex,\n    popupRef,\n    ...otherProps\n  } = props;\n  const state = React.useMemo(() => ({\n    disabled,\n    open,\n    highlighted,\n    selected\n  }), [disabled, open, highlighted, selected]);\n  const {\n    getItemProps,\n    rootRef\n  } = useSelectItem({\n    open,\n    setOpen,\n    disabled,\n    highlighted,\n    selected,\n    ref: forwardedRef,\n    typingRef,\n    handleSelect: () => setValue(value),\n    selectionRef,\n    selectedIndexRef,\n    indexRef,\n    setActiveIndex,\n    popupRef\n  });\n  const mergedRef = useForkRef(rootRef, forwardedRef);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter(externalProps = {}) {\n      const rootProps = getRootItemProps({\n        ...externalProps,\n        active: highlighted,\n        selected\n      });\n      // With our custom `focusItemOnHover` implementation, this interferes with the logic and can\n      // cause the index state to be stuck when leaving the select popup.\n      delete rootProps.onFocus;\n      return getItemProps(rootProps);\n    },\n    render: render ?? 'div',\n    ref: mergedRef,\n    className,\n    state,\n    extraProps: otherProps\n  });\n  const contextValue = React.useMemo(() => ({\n    selected,\n    indexRef\n  }), [selected, indexRef]);\n  return /*#__PURE__*/_jsx(SelectItemContext.Provider, {\n    value: contextValue,\n    children: renderElement()\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? InnerSelectItem.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  getRootItemProps: PropTypes.func.isRequired,\n  /**\n   * @ignore\n   */\n  highlighted: PropTypes.bool.isRequired,\n  /**\n   * @ignore\n   */\n  indexRef: PropTypes.shape({\n    current: PropTypes.number.isRequired\n  }).isRequired,\n  /**\n   * Overrides the text label to use on the trigger when this item is selected\n   * and when the item is matched during keyboard text navigation.\n   */\n  label: PropTypes.string,\n  /**\n   * @ignore\n   */\n  open: PropTypes.bool.isRequired,\n  /**\n   * @ignore\n   */\n  popupRef: PropTypes.shape({\n    current: PropTypes.object\n  }).isRequired,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * @ignore\n   */\n  selected: PropTypes.bool.isRequired,\n  /**\n   * @ignore\n   */\n  selectedIndexRef: PropTypes.shape({\n    current: PropTypes.number\n  }).isRequired,\n  /**\n   * @ignore\n   */\n  selectionRef: PropTypes.shape({\n    current: PropTypes.shape({\n      allowSelect: PropTypes.bool.isRequired,\n      allowSelectedMouseUp: PropTypes.bool.isRequired,\n      allowUnselectedMouseUp: PropTypes.bool.isRequired\n    }).isRequired\n  }).isRequired,\n  /**\n   * @ignore\n   */\n  setActiveIndex: PropTypes.func.isRequired,\n  /**\n   * @ignore\n   */\n  setOpen: PropTypes.func.isRequired,\n  /**\n   * @ignore\n   */\n  setValue: PropTypes.func.isRequired,\n  /**\n   * @ignore\n   */\n  typingRef: PropTypes.shape({\n    current: PropTypes.bool.isRequired\n  }).isRequired,\n  /**\n   * @ignore\n   */\n  value: PropTypes.any.isRequired\n} : void 0;\nconst MemoizedInnerSelectItem = /*#__PURE__*/React.memo(InnerSelectItem);\n\n/**\n * An individual option in the select menu.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nconst SelectItem = /*#__PURE__*/React.forwardRef(function SelectItem(props, forwardedRef) {\n  const {\n    value: valueProp = null,\n    label,\n    ...otherProps\n  } = props;\n  const listItem = useCompositeListItem({\n    label\n  });\n  const {\n    activeIndex,\n    selectedIndex,\n    setActiveIndex\n  } = useSelectIndexContext();\n  const {\n    getItemProps,\n    setOpen,\n    setValue,\n    open,\n    selectionRef,\n    typingRef,\n    valuesRef,\n    popupRef,\n    registerSelectedItem,\n    value\n  } = useSelectRootContext();\n  const itemRef = React.useRef(null);\n  const selectedIndexRef = useLatestRef(selectedIndex);\n  const indexRef = useLatestRef(listItem.index);\n  const mergedRef = useForkRef(listItem.ref, forwardedRef, itemRef);\n  const hasRegistered = listItem.index !== -1;\n  useEnhancedEffect(() => {\n    if (!hasRegistered) {\n      return undefined;\n    }\n    const values = valuesRef.current;\n    values[listItem.index] = valueProp;\n    return () => {\n      delete values[listItem.index];\n    };\n  }, [hasRegistered, listItem.index, valueProp, valuesRef]);\n  useEnhancedEffect(() => {\n    if (hasRegistered && valueProp === value) {\n      registerSelectedItem(listItem.index);\n    }\n  }, [hasRegistered, listItem.index, registerSelectedItem, valueProp, value]);\n  const highlighted = activeIndex === listItem.index;\n  const selected = selectedIndex === listItem.index;\n  return /*#__PURE__*/_jsx(MemoizedInnerSelectItem, {\n    ref: mergedRef,\n    highlighted: highlighted,\n    selected: selected,\n    getRootItemProps: getItemProps,\n    setOpen: setOpen,\n    open: open,\n    selectionRef: selectionRef,\n    typingRef: typingRef,\n    value: valueProp,\n    setValue: setValue,\n    selectedIndexRef: selectedIndexRef,\n    indexRef: indexRef,\n    setActiveIndex: setActiveIndex,\n    popupRef: popupRef,\n    ...otherProps\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? SelectItem.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Whether the component should ignore user interaction.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * Overrides the text label to use on the trigger when this item is selected\n   * and when the item is matched during keyboard text navigation.\n   */\n  label: PropTypes.string,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n  /**\n   * A unique value that identifies this select item.\n   * @default null\n   */\n  value: PropTypes.any\n} : void 0;\nexport { SelectItem };","import * as React from 'react';\nimport { useButton } from '../../use-button/index.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useEventCallback } from '../../utils/useEventCallback.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nexport function useSelectItem(params) {\n  const {\n    open,\n    disabled = false,\n    highlighted,\n    selected,\n    ref: externalRef,\n    setOpen,\n    typingRef,\n    handleSelect,\n    selectionRef,\n    indexRef,\n    setActiveIndex,\n    popupRef\n  } = params;\n  const ref = React.useRef(null);\n  const mergedRef = useForkRef(externalRef, ref);\n  const {\n    getButtonProps,\n    buttonRef\n  } = useButton({\n    disabled,\n    focusableWhenDisabled: true,\n    buttonRef: mergedRef\n  });\n  const commitSelection = useEventCallback(event => {\n    handleSelect();\n    setOpen(false, event);\n  });\n  const lastKeyRef = React.useRef(null);\n  const pointerTypeRef = React.useRef('mouse');\n  const prevPopupHeightRef = React.useRef(0);\n  const allowFocusSyncRef = React.useRef(true);\n  const getItemProps = React.useCallback(externalProps => {\n    return getButtonProps(mergeReactProps(externalProps, {\n      'aria-disabled': disabled || undefined,\n      tabIndex: highlighted ? 0 : -1,\n      onFocus() {\n        if (allowFocusSyncRef.current) {\n          setActiveIndex(indexRef.current);\n        }\n      },\n      onMouseMove() {\n        setActiveIndex(indexRef.current);\n        if (popupRef.current) {\n          prevPopupHeightRef.current = popupRef.current.offsetHeight;\n        }\n      },\n      onMouseLeave(event) {\n        const popup = popupRef.current;\n        if (!popup || !open) {\n          return;\n        }\n        const targetRect = event.currentTarget.getBoundingClientRect();\n\n        // Safari randomly fires `mouseleave` incorrectly when the item is\n        // aligned to the trigger. This is a workaround to prevent the highlight\n        // from being removed while the cursor is still within the bounds of the item.\n        // https://github.com/mui/base-ui/issues/869\n        const isWithinBounds = targetRect.top + 1 <= event.clientY && event.clientY <= targetRect.bottom - 1 && targetRect.left + 1 <= event.clientX && event.clientX <= targetRect.right - 1;\n        if (isWithinBounds) {\n          return;\n        }\n\n        // With `alignItemToTrigger`, avoid re-rendering the root due to `onMouseLeave`\n        // firing and causing a performance issue when expanding the popup.\n        if (popup.offsetHeight === prevPopupHeightRef.current) {\n          // Prevent `onFocus` from causing the highlight to be stuck when quickly moving\n          // the mouse out of the popup.\n          allowFocusSyncRef.current = false;\n          setActiveIndex(null);\n          requestAnimationFrame(() => {\n            popup.focus({\n              preventScroll: true\n            });\n            allowFocusSyncRef.current = true;\n          });\n        }\n      },\n      onTouchStart() {\n        selectionRef.current = {\n          allowSelectedMouseUp: false,\n          allowUnselectedMouseUp: false,\n          allowSelect: true\n        };\n      },\n      onKeyDown(event) {\n        selectionRef.current.allowSelect = true;\n        lastKeyRef.current = event.key;\n      },\n      onClick(event) {\n        if (disabled || lastKeyRef.current === ' ' && typingRef.current || pointerTypeRef.current !== 'touch' && !highlighted) {\n          return;\n        }\n        if (selectionRef.current.allowSelect) {\n          lastKeyRef.current = null;\n          commitSelection(event.nativeEvent);\n        }\n      },\n      onPointerEnter(event) {\n        pointerTypeRef.current = event.pointerType;\n      },\n      onPointerDown(event) {\n        pointerTypeRef.current = event.pointerType;\n      },\n      onMouseUp(event) {\n        if (disabled) {\n          return;\n        }\n        const disallowSelectedMouseUp = !selectionRef.current.allowSelectedMouseUp && selected;\n        const disallowUnselectedMouseUp = !selectionRef.current.allowUnselectedMouseUp && !selected;\n        if (disallowSelectedMouseUp || disallowUnselectedMouseUp || pointerTypeRef.current !== 'touch' && !highlighted) {\n          return;\n        }\n        if (selectionRef.current.allowSelect || !selected) {\n          commitSelection(event.nativeEvent);\n        }\n        selectionRef.current.allowSelect = true;\n      }\n    }));\n  }, [commitSelection, disabled, getButtonProps, highlighted, indexRef, open, popupRef, selected, selectionRef, setActiveIndex, typingRef]);\n  return React.useMemo(() => ({\n    getItemProps,\n    rootRef: buttonRef\n  }), [getItemProps, buttonRef]);\n}","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useSelectItemContext } from '../item/SelectItemContext.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { useTransitionStatus } from '../../utils/useTransitionStatus.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\n\n/**\n * Indicates whether the select item is selected.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nconst SelectItemIndicator = /*#__PURE__*/React.forwardRef(function SelectItemIndicator(props, forwardedRef) {\n  const {\n    render,\n    className,\n    keepMounted = false,\n    ...otherProps\n  } = props;\n  const {\n    selected\n  } = useSelectItemContext();\n  const indicatorRef = React.useRef(null);\n  const mergedRef = useForkRef(forwardedRef, indicatorRef);\n  const {\n    mounted,\n    transitionStatus,\n    setMounted\n  } = useTransitionStatus(selected);\n  const getItemProps = React.useCallback((externalProps = {}) => mergeReactProps(externalProps, {\n    'aria-hidden': true,\n    children: '✔️'\n  }), []);\n  const state = React.useMemo(() => ({\n    selected,\n    transitionStatus\n  }), [selected, transitionStatus]);\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getItemProps,\n    render: render ?? 'span',\n    ref: mergedRef,\n    className,\n    state,\n    extraProps: {\n      hidden: !mounted,\n      ...otherProps\n    }\n  });\n  useOpenChangeComplete({\n    open: selected,\n    ref: indicatorRef,\n    onComplete() {\n      if (!selected) {\n        setMounted(false);\n      }\n    }\n  });\n  const shouldRender = keepMounted || selected;\n  if (!shouldRender) {\n    return null;\n  }\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? SelectItemIndicator.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Whether to keep the HTML element in the DOM when the item is not selected.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { SelectItemIndicator };","'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useComponentRenderer } from '../../utils/useComponentRenderer.js';\nimport { useTooltipRootContext } from '../root/TooltipRootContext.js';\nimport { useTooltipPositionerContext } from '../positioner/TooltipPositionerContext.js';\nimport { useForkRef } from '../../utils/useForkRef.js';\nimport { popupStateMapping as baseMapping } from '../../utils/popupStateMapping.js';\nimport { mergeReactProps } from '../../utils/mergeReactProps.js';\nimport { transitionStatusMapping } from '../../utils/styleHookMapping.js';\nimport { useOpenChangeComplete } from '../../utils/useOpenChangeComplete.js';\nconst customStyleHookMapping = {\n  ...baseMapping,\n  ...transitionStatusMapping\n};\n\n/**\n * A container for the tooltip contents.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)\n */\nconst TooltipPopup = /*#__PURE__*/React.forwardRef(function TooltipPopup(props, forwardedRef) {\n  const {\n    className,\n    render,\n    ...otherProps\n  } = props;\n  const {\n    open,\n    instantType,\n    transitionStatus,\n    getRootPopupProps,\n    popupRef,\n    onOpenChangeComplete\n  } = useTooltipRootContext();\n  const {\n    side,\n    align\n  } = useTooltipPositionerContext();\n  useOpenChangeComplete({\n    open,\n    ref: popupRef,\n    onComplete() {\n      if (open) {\n        onOpenChangeComplete?.(true);\n      }\n    }\n  });\n  const state = React.useMemo(() => ({\n    open,\n    side,\n    align,\n    instant: instantType,\n    transitionStatus\n  }), [open, side, align, instantType, transitionStatus]);\n  const mergedRef = useForkRef(popupRef, forwardedRef);\n\n  // The content element needs to be a child of a wrapper floating element in order to avoid\n  // conflicts with CSS transitions and the positioning transform.\n  const {\n    renderElement\n  } = useComponentRenderer({\n    propGetter: getRootPopupProps,\n    render: render ?? 'div',\n    className,\n    state,\n    ref: mergedRef,\n    extraProps: transitionStatus === 'starting' ? mergeReactProps(otherProps, {\n      style: {\n        transition: 'none'\n      }\n    }) : otherProps,\n    customStyleHookMapping\n  });\n  return renderElement();\n});\nprocess.env.NODE_ENV !== \"production\" ? TooltipPopup.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * CSS class applied to the element, or a function that\n   * returns a class based on the component’s state.\n   */\n  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  /**\n   * Allows you to replace the component’s HTML element\n   * with a different tag, or compose it with another component.\n   *\n   * Accepts a `ReactElement` or a function that returns the element to render.\n   */\n  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n} : void 0;\nexport { TooltipPopup };","import * as React from 'react';\nimport PropTypes from 'prop-types';\n\n/**\n * @ignore - internal component.\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst InternalBackdrop = /*#__PURE__*/React.forwardRef(function InternalBackdrop(props, ref) {\n  const {\n    inert = false\n  } = props;\n  return /*#__PURE__*/_jsx(\"div\", {\n    ref: ref,\n    role: \"presentation\",\n    style: {\n      position: 'fixed',\n      inset: 0,\n      // Allows `:hover` events immediately after `open` changes to `false`,\n      // preventing a flicker when the cursor rests on the trigger. Flickers occur\n      // because CSS `:hover` is temporarily blocked during an exit animation,\n      // and `[data-popup-open]` is removed.\n      // Keeping the backdrop in the DOM avoids `[data-floating-ui-inert]`, which\n      // blocks outside clicks from closing the popup. This issue arises when\n      // conditionally rendering the backdrop on `open` and using exit animations.\n      // If the popup reopens before the exit animation finishes, the backdrop\n      // receives this attribute, breaking outside click behavior.\n      pointerEvents: inert ? 'none' : undefined\n    }\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? InternalBackdrop.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * Whether the backdrop should be inert (not block pointer events).\n   * @default false\n   */\n  inert: PropTypes.bool\n} : void 0;\nexport { InternalBackdrop };","import { getUserAgent } from '@floating-ui/react/utils';\n// Avoid Chrome DevTools blue warning.\nexport function getNavigatorData() {\n  if (typeof navigator === 'undefined') {\n    return {\n      platform: '',\n      maxTouchPoints: -1\n    };\n  }\n  const uaData = navigator.userAgentData;\n  if (uaData?.platform) {\n    return {\n      platform: uaData.platform,\n      maxTouchPoints: navigator.maxTouchPoints\n    };\n  }\n  return {\n    platform: navigator.platform,\n    maxTouchPoints: navigator.maxTouchPoints\n  };\n}\nexport function isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) {\n    return false;\n  }\n  return CSS.supports('-webkit-backdrop-filter:none');\n}\nexport function isIOS() {\n  const nav = getNavigatorData();\n\n  // iPads can claim to be MacIntel\n  // https://github.com/getsentry/sentry-javascript/issues/12127\n  if (nav.platform === 'MacIntel' && nav.maxTouchPoints > 1) {\n    return true;\n  }\n  return /iP(hone|ad|od)|iOS/.test(nav.platform);\n}\nexport function isFirefox() {\n  return /firefox/i.test(getUserAgent());\n}","const TRIGGER_HOOK = {\n  'data-popup-open': ''\n};\nconst PRESSABLE_TRIGGER_HOOK = {\n  'data-popup-open': '',\n  'data-pressed': ''\n};\nconst POPUP_OPEN_HOOK = {\n  'data-open': ''\n};\nconst POPUP_CLOSED_HOOK = {\n  'data-closed': ''\n};\nconst ANCHOR_HIDDEN_HOOK = {\n  'data-anchor-hidden': ''\n};\nexport const triggerOpenStateMapping = {\n  open(value) {\n    if (value) {\n      return TRIGGER_HOOK;\n    }\n    return null;\n  }\n};\nexport const pressableTriggerOpenStateMapping = {\n  open(value) {\n    if (value) {\n      return PRESSABLE_TRIGGER_HOOK;\n    }\n    return null;\n  }\n};\nexport const popupStateMapping = {\n  open(value) {\n    if (value) {\n      return POPUP_OPEN_HOOK;\n    }\n    return POPUP_CLOSED_HOOK;\n  },\n  anchorHidden(value) {\n    if (value) {\n      return ANCHOR_HIDDEN_HOOK;\n    }\n    return null;\n  }\n};","const STARTING_HOOK = {\n  'data-starting-style': ''\n};\nconst ENDING_HOOK = {\n  'data-ending-style': ''\n};\nexport const transitionStatusMapping = {\n  transitionStatus(value) {\n    if (value === 'starting') {\n      return STARTING_HOOK;\n    }\n    if (value === 'ending') {\n      return ENDING_HOOK;\n    }\n    return null;\n  }\n};","'use client';\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { useEventCallback } from './useEventCallback.js';\n\n/**\n * Executes a function once all animations have finished on the provided element.\n * @param ref - The element to watch for animations.\n * @param waitForNextTick - Whether to wait for the next tick before checking for animations.\n * @ignore - internal hook.\n */\nexport function useAnimationsFinished(ref, waitForNextTick = false) {\n  const frameRef = React.useRef(-1);\n  const timeoutRef = React.useRef(-1);\n  const cancelTasks = useEventCallback(() => {\n    cancelAnimationFrame(frameRef.current);\n    clearTimeout(timeoutRef.current);\n  });\n  React.useEffect(() => cancelTasks, [cancelTasks]);\n  return useEventCallback(fnToExecute => {\n    cancelTasks();\n    const element = ref.current;\n    if (!element) {\n      return;\n    }\n    if (typeof element.getAnimations !== 'function' || globalThis.BASE_UI_ANIMATIONS_DISABLED) {\n      fnToExecute();\n    } else {\n      frameRef.current = requestAnimationFrame(() => {\n        function exec() {\n          if (!element) {\n            return;\n          }\n          Promise.allSettled(element.getAnimations().map(anim => anim.finished)).then(() => {\n            // Synchronously flush the unmounting of the component so that the browser doesn't\n            // paint: https://github.com/mui/base-ui/issues/979\n            ReactDOM.flushSync(fnToExecute);\n          });\n        }\n\n        // `open: true` animations need to wait for the next tick to be detected\n        if (waitForNextTick) {\n          timeoutRef.current = window.setTimeout(exec);\n        } else {\n          exec();\n        }\n      });\n    }\n  });\n}","'use client';\n\nimport * as React from 'react';\nimport { useEnhancedEffect } from './useEnhancedEffect.js';\n\n/**\n * @ignore - internal hook.\n */\nexport function useLatestRef(value) {\n  const ref = React.useRef(value);\n  useEnhancedEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n}","import { useAnimationsFinished } from './useAnimationsFinished.js';\nimport { useEnhancedEffect } from './useEnhancedEffect.js';\nimport { useEventCallback } from './useEventCallback.js';\nimport { useLatestRef } from './useLatestRef.js';\n\n/**\n * Calls the provided function when the CSS open/close animation or transition completes.\n */\nexport function useOpenChangeComplete(parameters) {\n  const {\n    open,\n    ref,\n    onComplete: onCompleteParam\n  } = parameters;\n  const openRef = useLatestRef(open);\n  const onComplete = useEventCallback(onCompleteParam);\n  const runOnceAnimationsFinish = useAnimationsFinished(ref, open);\n  useEnhancedEffect(() => {\n    runOnceAnimationsFinish(() => {\n      if (open === openRef.current) {\n        onComplete();\n      }\n    });\n  }, [open, onComplete, runOnceAnimationsFinish, openRef]);\n}","'use client';\n\nimport * as React from 'react';\nimport { useEnhancedClickHandler } from './useEnhancedClickHandler.js';\n\n/**\n * Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.\n *\n * @param open The open state of the component.\n */\nexport function useOpenInteractionType(open) {\n  const [openMethod, setOpenMethod] = React.useState(null);\n  if (!open && openMethod !== null) {\n    setOpenMethod(null);\n  }\n  const handleTriggerClick = React.useCallback((_, interactionType) => {\n    if (!open) {\n      setOpenMethod(interactionType);\n    }\n  }, [open, setOpenMethod]);\n  const {\n    onClick,\n    onPointerDown\n  } = useEnhancedClickHandler(handleTriggerClick);\n  return React.useMemo(() => ({\n    openMethod,\n    triggerProps: {\n      onClick,\n      onPointerDown\n    }\n  }), [openMethod, onClick, onPointerDown]);\n}","import * as React from 'react';\n/**\n * Provides a cross-browser way to determine the type of the pointer used to click.\n * Safari and Firefox do not provide the PointerEvent to the click handler (they use MouseEvent) yet.\n * Additionally, this implementation detects if the click was triggered by the keyboard.\n *\n * @param handler The function to be called when the button is clicked. The first parameter is the original event and the second parameter is the pointer type.\n */\nexport function useEnhancedClickHandler(handler) {\n  const lastClickInteractionTypeRef = React.useRef('');\n  const handlePointerDown = React.useCallback(event => {\n    if (event.defaultPrevented) {\n      return;\n    }\n    lastClickInteractionTypeRef.current = event.pointerType;\n  }, []);\n  const handleClick = React.useCallback(event => {\n    // event.detail has the number of clicks performed on the element. 0 means it was triggered by the keyboard.\n    if (event.detail === 0) {\n      handler(event, 'keyboard');\n      return;\n    }\n    if ('pointerType' in event) {\n      // Chrome and Edge correctly use PointerEvent\n      handler(event, event.pointerType);\n    }\n    handler(event, lastClickInteractionTypeRef.current);\n    lastClickInteractionTypeRef.current = '';\n  }, [handler]);\n  return {\n    onClick: handleClick,\n    onPointerDown: handlePointerDown\n  };\n}","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport React from 'react';\n\n// During SSR, React emits a warning when calling useLayoutEffect.\n// Since neither useLayoutEffect nor useEffect run on the server,\n// we can suppress this by replace it with a noop on the server.\nexport const useLayoutEffect = typeof document !== 'undefined'\n  ? React.useLayoutEffect\n  : () => {};\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nfunction testUserAgent(re: RegExp) {\n  if (typeof window === 'undefined' || window.navigator == null) {\n    return false;\n  }\n  return (\n    window.navigator['userAgentData']?.brands.some((brand: {brand: string, version: string}) => re.test(brand.brand))\n  ) ||\n  re.test(window.navigator.userAgent);\n}\n\nfunction testPlatform(re: RegExp) {\n  return typeof window !== 'undefined' && window.navigator != null\n    ? re.test(window.navigator['userAgentData']?.platform || window.navigator.platform)\n    : false;\n}\n\nfunction cached(fn: () => boolean) {\n  if (process.env.NODE_ENV === 'test') {\n    return fn;\n  }\n  \n  let res: boolean | null = null;\n  return () => {\n    if (res == null) {\n      res = fn();\n    }\n    return res;\n  };\n}\n\nexport const isMac = cached(function () {\n  return testPlatform(/^Mac/i);\n});\n\nexport const isIPhone = cached(function () {\n  return testPlatform(/^iPhone/i);\n});\n\nexport const isIPad = cached(function () {\n  return testPlatform(/^iPad/i) ||\n    // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.\n    (isMac() && navigator.maxTouchPoints > 1);\n});\n\nexport const isIOS = cached(function () {\n  return isIPhone() || isIPad();\n});\n\nexport const isAppleDevice = cached(function () {\n  return isMac() || isIOS();\n});\n\nexport const isWebKit = cached(function () {\n  return testUserAgent(/AppleWebKit/i) && !isChrome();\n});\n\nexport const isChrome = cached(function () {\n  return testUserAgent(/Chrome/i);\n});\n\nexport const isAndroid = cached(function () {\n  return testUserAgent(/Android/i);\n});\n\nexport const isFirefox = cached(function () {\n  return testUserAgent(/Firefox/i);\n});\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\n/**\n * Calls all functions in the order they were chained with the same arguments.\n */\nexport function chain(...callbacks: any[]): (...args: any[]) => void {\n  return (...args: any[]) => {\n    for (let callback of callbacks) {\n      if (typeof callback === 'function') {\n        callback(...args);\n      }\n    }\n  };\n}\n","/*\n * Copyright 2024 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nexport function isScrollable(node: Element | null, checkForOverflow?: boolean): boolean {\n  if (!node) {\n    return false;\n  }\n  let style = window.getComputedStyle(node);\n  let isScrollable = /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);\n\n  if (isScrollable && checkForOverflow) {\n    isScrollable = node.scrollHeight !== node.clientHeight || node.scrollWidth !== node.clientWidth;\n  }\n\n  return isScrollable;\n}\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {isScrollable} from './isScrollable';\n\nexport function getScrollParent(node: Element, checkForOverflow?: boolean): Element {\n  let scrollableNode: Element | null = node;\n  if (isScrollable(scrollableNode, checkForOverflow)) {\n    scrollableNode = scrollableNode.parentElement;\n  }\n\n  while (scrollableNode && !isScrollable(scrollableNode, checkForOverflow)) {\n    scrollableNode = scrollableNode.parentElement;\n  }\n\n  return scrollableNode || document.scrollingElement || document.documentElement;\n}\n\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {chain, getScrollParent, isIOS, useLayoutEffect} from '@react-aria/utils';\n\ninterface PreventScrollOptions {\n  /** Whether the scroll lock is disabled. */\n  isDisabled?: boolean\n}\n\nconst visualViewport = typeof document !== 'undefined' && window.visualViewport;\n\n// HTML input types that do not cause the software keyboard to appear.\nconst nonTextInputTypes = new Set([\n  'checkbox',\n  'radio',\n  'range',\n  'color',\n  'file',\n  'image',\n  'button',\n  'submit',\n  'reset'\n]);\n\n// The number of active usePreventScroll calls. Used to determine whether to revert back to the original page style/scroll position\nlet preventScrollCount = 0;\nlet restore;\n\n/**\n * Prevents scrolling on the document body on mount, and\n * restores it on unmount. Also ensures that content does not\n * shift due to the scrollbars disappearing.\n */\nexport function usePreventScroll(options: PreventScrollOptions = {}) {\n  let {isDisabled} = options;\n\n  useLayoutEffect(() => {\n    if (isDisabled) {\n      return;\n    }\n\n    preventScrollCount++;\n    if (preventScrollCount === 1) {\n      if (isIOS()) {\n        restore = preventScrollMobileSafari();\n      } else {\n        restore = preventScrollStandard();\n      }\n    }\n\n    return () => {\n      preventScrollCount--;\n      if (preventScrollCount === 0) {\n        restore();\n      }\n    };\n  }, [isDisabled]);\n}\n\n// For most browsers, all we need to do is set `overflow: hidden` on the root element, and\n// add some padding to prevent the page from shifting when the scrollbar is hidden.\nfunction preventScrollStandard() {\n  return chain(\n    setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`),\n    setStyle(document.documentElement, 'overflow', 'hidden')\n  );\n}\n\n// Mobile Safari is a whole different beast. Even with overflow: hidden,\n// it still scrolls the page in many situations:\n//\n// 1. When the bottom toolbar and address bar are collapsed, page scrolling is always allowed.\n// 2. When the keyboard is visible, the viewport does not resize. Instead, the keyboard covers part of\n//    it, so it becomes scrollable.\n// 3. When tapping on an input, the page always scrolls so that the input is centered in the visual viewport.\n//    This may cause even fixed position elements to scroll off the screen.\n// 4. When using the next/previous buttons in the keyboard to navigate between inputs, the whole page always\n//    scrolls, even if the input is inside a nested scrollable element that could be scrolled instead.\n//\n// In order to work around these cases, and prevent scrolling without jankiness, we do a few things:\n//\n// 1. Prevent default on `touchmove` events that are not in a scrollable element. This prevents touch scrolling\n//    on the window.\n// 2. Set `overscroll-behavior: contain` on nested scrollable regions so they do not scroll the page when at\n//    the top or bottom. Work around a bug where this does not work when the element does not actually overflow\n//    by preventing default in a `touchmove` event.\n// 3. Prevent default on `touchend` events on input elements and handle focusing the element ourselves.\n// 4. When focusing an input, apply a transform to trick Safari into thinking the input is at the top\n//    of the page, which prevents it from scrolling the page. After the input is focused, scroll the element\n//    into view ourselves, without scrolling the whole page.\n// 5. Offset the body by the scroll position using a negative margin and scroll to the top. This should appear the\n//    same visually, but makes the actual scroll position always zero. This is required to make all of the\n//    above work or Safari will still try to scroll the page when focusing an input.\n// 6. As a last resort, handle window scroll events, and scroll back to the top. This can happen when attempting\n//    to navigate to an input with the next/previous buttons that's outside a modal.\nfunction preventScrollMobileSafari() {\n  let scrollable: Element;\n  let restoreScrollableStyles;\n  let onTouchStart = (e: TouchEvent) => {\n    // Store the nearest scrollable parent element from the element that the user touched.\n    scrollable = getScrollParent(e.target as Element, true);\n    if (scrollable === document.documentElement && scrollable === document.body) {\n      return;\n    }\n\n    // Prevent scrolling up when at the top and scrolling down when at the bottom\n    // of a nested scrollable area, otherwise mobile Safari will start scrolling\n    // the window instead.\n    if (scrollable instanceof HTMLElement && window.getComputedStyle(scrollable).overscrollBehavior === 'auto') {\n      restoreScrollableStyles = setStyle(scrollable, 'overscrollBehavior', 'contain');\n    }\n  };\n\n  let onTouchMove = (e: TouchEvent) => {\n    // Prevent scrolling the window.\n    if (!scrollable || scrollable === document.documentElement || scrollable === document.body) {\n      e.preventDefault();\n      return;\n    }\n\n    // overscroll-behavior should prevent scroll chaining, but currently does not\n    // if the element doesn't actually overflow. https://bugs.webkit.org/show_bug.cgi?id=243452\n    // This checks that both the width and height do not overflow, otherwise we might\n    // block horizontal scrolling too. In that case, adding `touch-action: pan-x` to\n    // the element will prevent vertical page scrolling. We can't add that automatically\n    // because it must be set before the touchstart event.\n    if (scrollable.scrollHeight === scrollable.clientHeight && scrollable.scrollWidth === scrollable.clientWidth) {\n      e.preventDefault();\n    }\n  };\n\n  let onTouchEnd = () => {\n    if (restoreScrollableStyles) {\n      restoreScrollableStyles();\n    }\n  };\n\n  let onFocus = (e: FocusEvent) => {\n    let target = e.target as HTMLElement;\n    if (willOpenKeyboard(target)) {\n      setupStyles();\n\n      // Apply a transform to trick Safari into thinking the input is at the top of the page\n      // so it doesn't try to scroll it into view.\n      target.style.transform = 'translateY(-2000px)';\n      requestAnimationFrame(() => {\n        target.style.transform = '';\n\n        // This will have prevented the browser from scrolling the focused element into view,\n        // so we need to do this ourselves in a way that doesn't cause the whole page to scroll.\n        if (visualViewport) {\n          if (visualViewport.height < window.innerHeight) {\n            // If the keyboard is already visible, do this after one additional frame\n            // to wait for the transform to be removed.\n            requestAnimationFrame(() => {\n              scrollIntoView(target);\n            });\n          } else {\n            // Otherwise, wait for the visual viewport to resize before scrolling so we can\n            // measure the correct position to scroll to.\n            visualViewport.addEventListener('resize', () => scrollIntoView(target), {once: true});\n          }\n        }\n      });\n    }\n  };\n\n  let restoreStyles: null | (() => void) = null;\n  let setupStyles = () => {\n    if (restoreStyles) {\n      return;\n    }\n\n    let onWindowScroll = () => {\n      // Last resort. If the window scrolled, scroll it back to the top.\n      // It should always be at the top because the body will have a negative margin (see below).\n      window.scrollTo(0, 0);\n    };\n\n    // Record the original scroll position so we can restore it.\n    // Then apply a negative margin to the body to offset it by the scroll position. This will\n    // enable us to scroll the window to the top, which is required for the rest of this to work.\n    let scrollX = window.pageXOffset;\n    let scrollY = window.pageYOffset;\n\n    restoreStyles = chain(\n      addEvent(window, 'scroll', onWindowScroll),\n      setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`),\n      setStyle(document.documentElement, 'overflow', 'hidden'),\n      setStyle(document.body, 'marginTop', `-${scrollY}px`),\n      () => {\n        window.scrollTo(scrollX, scrollY);\n      }\n    );\n\n    // Scroll to the top. The negative margin on the body will make this appear the same.\n    window.scrollTo(0, 0);\n  };\n\n  let removeEvents = chain(\n    addEvent(document, 'touchstart', onTouchStart, {passive: false, capture: true}),\n    addEvent(document, 'touchmove', onTouchMove, {passive: false, capture: true}),\n    addEvent(document, 'touchend', onTouchEnd, {passive: false, capture: true}),\n    addEvent(document, 'focus', onFocus, true)\n  );\n\n  return () => {\n    // Restore styles and scroll the page back to where it was.\n    restoreScrollableStyles?.();\n    restoreStyles?.();\n    removeEvents();\n  };\n}\n\n// Sets a CSS property on an element, and returns a function to revert it to the previous value.\nfunction setStyle(element: HTMLElement, style: string, value: string) {\n  let cur = element.style[style];\n  element.style[style] = value;\n\n  return () => {\n    element.style[style] = cur;\n  };\n}\n\n// Adds an event listener to an element, and returns a function to remove it.\nfunction addEvent<K extends keyof GlobalEventHandlersEventMap>(\n  target: Document | Window,\n  event: K,\n  handler: (this: Document | Window, ev: GlobalEventHandlersEventMap[K]) => any,\n  options?: boolean | AddEventListenerOptions\n) {\n  // internal function, so it's ok to ignore the difficult to fix type error\n  // @ts-ignore\n  target.addEventListener(event, handler, options);\n  return () => {\n    // @ts-ignore\n    target.removeEventListener(event, handler, options);\n  };\n}\n\nfunction scrollIntoView(target: Element) {\n  let root = document.scrollingElement || document.documentElement;\n  let nextTarget: Element | null = target;\n  while (nextTarget && nextTarget !== root) {\n    // Find the parent scrollable element and adjust the scroll position if the target is not already in view.\n    let scrollable = getScrollParent(nextTarget);\n    if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== nextTarget) {\n      let scrollableTop = scrollable.getBoundingClientRect().top;\n      let targetTop = nextTarget.getBoundingClientRect().top;\n      if (targetTop > scrollableTop + nextTarget.clientHeight) {\n        scrollable.scrollTop += targetTop - scrollableTop;\n      }\n    }\n\n    nextTarget = scrollable.parentElement;\n  }\n}\n\nfunction willOpenKeyboard(target: Element) {\n  return (\n    (target instanceof HTMLInputElement && !nonTextInputTypes.has(target.type)) ||\n    target instanceof HTMLTextAreaElement ||\n    (target instanceof HTMLElement && target.isContentEditable)\n  );\n}\n","import * as React from 'react';\nimport { usePreventScroll } from '@react-aria/overlays';\nimport { isFirefox, isIOS, isWebKit } from './detectBrowser.js';\nimport { ownerDocument, ownerWindow } from './owner.js';\nimport { useEnhancedEffect } from './useEnhancedEffect.js';\nlet originalHtmlStyles = {};\nlet originalBodyStyles = {};\nlet originalHtmlScrollBehavior = '';\nlet preventScrollCount = 0;\nlet restore = () => {};\nfunction supportsDvh() {\n  return typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('height', '1dvh');\n}\nfunction hasInsetScrollbars(referenceElement) {\n  if (typeof document === 'undefined') {\n    return false;\n  }\n  const doc = ownerDocument(referenceElement);\n  const win = ownerWindow(doc);\n  return win.innerWidth - doc.documentElement.clientWidth > 0;\n}\nfunction preventScrollStandard(referenceElement) {\n  const doc = ownerDocument(referenceElement);\n  const html = doc.documentElement;\n  const body = doc.body;\n  const win = ownerWindow(html);\n  let scrollTop = 0;\n  let scrollLeft = 0;\n  let resizeRaf = -1;\n\n  // Pinch-zoom in Safari causes a shift. Just don't lock scroll if there's any pinch-zoom.\n  if (isWebKit() && (win.visualViewport?.scale ?? 1) !== 1) {\n    return () => {};\n  }\n  function lockScroll() {\n    const htmlStyles = win.getComputedStyle(html);\n    const bodyStyles = win.getComputedStyle(body);\n    scrollTop = html.scrollTop;\n    scrollLeft = html.scrollLeft;\n    originalHtmlStyles = {\n      overflowY: html.style.overflowY,\n      overflowX: html.style.overflowX\n    };\n    originalHtmlScrollBehavior = html.style.scrollBehavior;\n    originalBodyStyles = {\n      position: body.style.position,\n      height: body.style.height,\n      width: body.style.width,\n      boxSizing: body.style.boxSizing,\n      overflowY: body.style.overflowY,\n      overflowX: body.style.overflowX,\n      scrollBehavior: body.style.scrollBehavior\n    };\n\n    // Handle `scrollbar-gutter` in Chrome when there is no scrollable content.\n    const hasScrollbarGutterStable = htmlStyles.scrollbarGutter?.includes('stable');\n    const isScrollableY = html.scrollHeight > html.clientHeight;\n    const isScrollableX = html.scrollWidth > html.clientWidth;\n    const hasConstantOverflowY = htmlStyles.overflowY === 'scroll' || bodyStyles.overflowY === 'scroll';\n    const hasConstantOverflowX = htmlStyles.overflowX === 'scroll' || bodyStyles.overflowX === 'scroll';\n\n    // Values can be negative in Firefox\n    const scrollbarWidth = Math.max(0, win.innerWidth - html.clientWidth);\n    const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);\n    Object.assign(html.style, {\n      overflowY: !hasScrollbarGutterStable && (isScrollableY || hasConstantOverflowY) ? 'scroll' : 'hidden',\n      overflowX: !hasScrollbarGutterStable && (isScrollableX || hasConstantOverflowX) ? 'scroll' : 'hidden'\n    });\n\n    // Avoid shift due to the default <body> margin. This does cause elements to be clipped\n    // with whitespace. Warn if <body> has margins?\n    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);\n    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);\n    Object.assign(body.style, {\n      position: 'relative',\n      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',\n      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',\n      boxSizing: 'border-box',\n      overflow: 'hidden',\n      scrollBehavior: 'unset'\n    });\n    body.scrollTop = scrollTop;\n    body.scrollLeft = scrollLeft;\n    html.setAttribute('data-base-ui-scroll-locked', '');\n    html.style.scrollBehavior = 'unset';\n  }\n  function cleanup() {\n    Object.assign(html.style, originalHtmlStyles);\n    Object.assign(body.style, originalBodyStyles);\n    html.scrollTop = scrollTop;\n    html.scrollLeft = scrollLeft;\n    html.removeAttribute('data-base-ui-scroll-locked');\n    html.style.scrollBehavior = originalHtmlScrollBehavior;\n  }\n  function handleResize() {\n    cleanup();\n    cancelAnimationFrame(resizeRaf);\n    resizeRaf = requestAnimationFrame(lockScroll);\n  }\n  lockScroll();\n  win.addEventListener('resize', handleResize);\n  return () => {\n    cancelAnimationFrame(resizeRaf);\n    cleanup();\n    win.removeEventListener('resize', handleResize);\n  };\n}\n\n/**\n * Locks the scroll of the document when enabled.\n *\n * @param enabled - Whether to enable the scroll lock.\n */\nexport function useScrollLock(enabled = true, referenceElement) {\n  const isReactAriaHook = React.useMemo(() => enabled && (isIOS() || !supportsDvh() ||\n  // macOS Firefox \"pops\" scroll containers' scrollbars with our standard scroll lock\n  isFirefox() && !hasInsetScrollbars(referenceElement)), [enabled, referenceElement]);\n  usePreventScroll({\n    // react-aria will remove the scrollbar offset immediately upon close, since we use `open`,\n    // not `mounted`, to disable/enable the scroll lock. However since there are no inset\n    // scrollbars, no layouting issues occur.\n    isDisabled: !isReactAriaHook\n  });\n  useEnhancedEffect(() => {\n    if (!enabled || isReactAriaHook) {\n      return undefined;\n    }\n    preventScrollCount += 1;\n    if (preventScrollCount === 1) {\n      restore = preventScrollStandard(referenceElement);\n    }\n    return () => {\n      preventScrollCount -= 1;\n      if (preventScrollCount === 0) {\n        restore();\n      }\n    };\n  }, [enabled, isReactAriaHook, referenceElement]);\n}","'use client';\n\nimport * as React from 'react';\nimport { useEnhancedEffect } from './useEnhancedEffect.js';\n/**\n * Provides a status string for CSS animations.\n * @param open - a boolean that determines if the element is open.\n * @param delayStartingStatus - a boolean that set the `starting` status one\n *     tick later. Example use-case: collapsible needs an extra frame in order\n *     to measure the panel contents.\n * @ignore - internal hook.\n */\nexport function useTransitionStatus(open, delayStartingStatus = false) {\n  const [transitionStatus, setTransitionStatus] = React.useState();\n  const [mounted, setMounted] = React.useState(open);\n  if (open && !mounted) {\n    setMounted(true);\n    if (transitionStatus !== 'starting' && !delayStartingStatus) {\n      setTransitionStatus('starting');\n    }\n  }\n  if (!open && mounted && transitionStatus !== 'ending') {\n    setTransitionStatus('ending');\n  }\n  if (!open && !mounted && transitionStatus === 'ending') {\n    setTransitionStatus(undefined);\n  }\n  useEnhancedEffect(() => {\n    if (!open) {\n      return undefined;\n    }\n    if (delayStartingStatus) {\n      setTransitionStatus('starting');\n    }\n    const frame = requestAnimationFrame(() => {\n      setTransitionStatus(undefined);\n    });\n    return () => {\n      cancelAnimationFrame(frame);\n    };\n  }, [open, delayStartingStatus]);\n  return React.useMemo(() => ({\n    mounted,\n    setMounted,\n    transitionStatus\n  }), [mounted, transitionStatus]);\n}","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y,\n          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      var _state$middlewareData, _state$middlewareData2;\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\n// If <html> has a CSS width greater than the viewport, then this will be\n// incorrect for RTL.\nfunction getWindowScrollBarX(element, rect) {\n  const leftScroll = getNodeScroll(element).scrollLeft;\n  if (!rect) {\n    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;\n  }\n  return rect.left + leftScroll;\n}\n\nfunction getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {\n  if (ignoreScrollbarX === void 0) {\n    ignoreScrollbarX = false;\n  }\n  const htmlRect = documentElement.getBoundingClientRect();\n  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :\n  // RTL <body> scrollbar.\n  getWindowScrollBarX(documentElement, htmlRect));\n  const y = htmlRect.top + scroll.scrollTop;\n  return {\n    x,\n    y\n  };\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y,\n      width: clippingAncestor.width,\n      height: clippingAncestor.height\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use\n      // Firefox with layout.scrollbar.side = 3 in about:config to test this.\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  let rawOffsetParent = element.offsetParent;\n\n  // Firefox returns the <html> element as the offsetParent if it's non-static,\n  // while Chrome and Safari return the <body> element. The <body> element must\n  // be used to perform the correct calculations even if the <html> element is\n  // non-static.\n  if (getDocumentElement(element) === rawOffsetParent) {\n    rawOffsetParent = rawOffsetParent.ownerDocument.body;\n  }\n  return rawOffsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\nfunction rectsAreEqual(a, b) {\n  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n}\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const elementRectForRootMargin = element.getBoundingClientRect();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = elementRectForRootMargin;\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {\n        // It's possible that even though the ratio is reported as 1, the\n        // element is not actually fully within the IntersectionObserver's root\n        // area anymore. This can happen under performance constraints. This may\n        // be a bug in the browser's IntersectionObserver implementation. To\n        // work around this, we compare the element's bounding rect now with\n        // what it was at the time we created the IntersectionObserver. If they\n        // are not equal then the element moved, so we refresh.\n        refresh();\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","import { computePosition, arrow as arrow$2, offset as offset$1, shift as shift$1, limitShift as limitShift$1, flip as flip$1, size as size$1, autoPlacement as autoPlacement$1, hide as hide$1, inline as inline$1 } from '@floating-ui/dom';\nexport { autoUpdate, computePosition, detectOverflow, getOverflowAncestors, platform } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const openRef = useLatestRef(open);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        // The floating element's position may be recomputed while it's closed\n        // but still mounted (such as when transitioning out). To ensure\n        // `isPositioned` will be `false` initially on the next open, avoid\n        // setting it to `true` when `open === false` (must be specified).\n        isPositioned: openRef.current !== false\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef, openRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow$1 = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$2({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$2({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = (options, deps) => ({\n  ...offset$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = (options, deps) => ({\n  ...shift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = (options, deps) => ({\n  ...limitShift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = (options, deps) => ({\n  ...flip$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = (options, deps) => ({\n  ...size$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = (options, deps) => ({\n  ...autoPlacement$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = (options, deps) => ({\n  ...hide$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = (options, deps) => ({\n  ...inline$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = (options, deps) => ({\n  ...arrow$1(options),\n  options: [options, deps]\n});\n\nexport { arrow, autoPlacement, flip, hide, inline, limitShift, offset, shift, size, useFloating };\n","// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nconst candidateSelectors = [\n  'input:not([inert])',\n  'select:not([inert])',\n  'textarea:not([inert])',\n  'a[href]:not([inert])',\n  'button:not([inert])',\n  '[tabindex]:not(slot):not([inert])',\n  'audio[controls]:not([inert])',\n  'video[controls]:not([inert])',\n  '[contenteditable]:not([contenteditable=\"false\"]):not([inert])',\n  'details>summary:first-of-type:not([inert])',\n  'details:not([inert])',\n];\nconst candidateSelector = /* #__PURE__ */ candidateSelectors.join(',');\n\nconst NoElement = typeof Element === 'undefined';\n\nconst matches = NoElement\n  ? function () {}\n  : Element.prototype.matches ||\n    Element.prototype.msMatchesSelector ||\n    Element.prototype.webkitMatchesSelector;\n\nconst getRootNode =\n  !NoElement && Element.prototype.getRootNode\n    ? (element) => element?.getRootNode?.()\n    : (element) => element?.ownerDocument;\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nconst isInert = function (node, lookUp = true) {\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  const inertAtt = node?.getAttribute?.('inert');\n  const inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  const result = inert || (lookUp && node && isInert(node.parentNode)); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nconst isContentEditable = function (node) {\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  const attValue = node?.getAttribute?.('contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nconst getCandidates = function (el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n\n  let candidates = Array.prototype.slice.apply(\n    el.querySelectorAll(candidateSelector)\n  );\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nconst getCandidatesIteratively = function (\n  elements,\n  includeContainer,\n  options\n) {\n  const candidates = [];\n  const elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    const element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      const assigned = element.assignedElements();\n      const content = assigned.length ? assigned : element.children;\n      const nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push(...nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates,\n        });\n      }\n    } else {\n      // check candidate element\n      const validCandidate = matches.call(element, candidateSelector);\n      if (\n        validCandidate &&\n        options.filter(element) &&\n        (includeContainer || !elements.includes(element))\n      ) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      const shadowRoot =\n        element.shadowRoot ||\n        // check for an undisclosed shadow\n        (typeof options.getShadowRoot === 'function' &&\n          options.getShadowRoot(element));\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      const validShadowRoot =\n        !isInert(shadowRoot, false) &&\n        (!options.shadowRootFilter || options.shadowRootFilter(element));\n\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        const nestedCandidates = getCandidatesIteratively(\n          shadowRoot === true ? element.children : shadowRoot.children,\n          true,\n          options\n        );\n\n        if (options.flatten) {\n          candidates.push(...nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: nestedCandidates,\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift(...element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nconst hasTabIndex = function (node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nconst getTabIndex = function (node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if (\n      (/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) ||\n        isContentEditable(node)) &&\n      !hasTabIndex(node)\n    ) {\n      return 0;\n    }\n  }\n\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nconst getSortOrderTabIndex = function (node, isScope) {\n  const tabIndex = getTabIndex(node);\n\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n\n  return tabIndex;\n};\n\nconst sortOrderedTabbables = function (a, b) {\n  return a.tabIndex === b.tabIndex\n    ? a.documentOrder - b.documentOrder\n    : a.tabIndex - b.tabIndex;\n};\n\nconst isInput = function (node) {\n  return node.tagName === 'INPUT';\n};\n\nconst isHiddenInput = function (node) {\n  return isInput(node) && node.type === 'hidden';\n};\n\nconst isDetailsWithSummary = function (node) {\n  const r =\n    node.tagName === 'DETAILS' &&\n    Array.prototype.slice\n      .apply(node.children)\n      .some((child) => child.tagName === 'SUMMARY');\n  return r;\n};\n\nconst getCheckedRadio = function (nodes, form) {\n  for (let i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\n\nconst isTabbableRadio = function (node) {\n  if (!node.name) {\n    return true;\n  }\n  const radioScope = node.form || getRootNode(node);\n  const queryRadios = function (name) {\n    return radioScope.querySelectorAll(\n      'input[type=\"radio\"][name=\"' + name + '\"]'\n    );\n  };\n\n  let radioSet;\n  if (\n    typeof window !== 'undefined' &&\n    typeof window.CSS !== 'undefined' &&\n    typeof window.CSS.escape === 'function'\n  ) {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error(\n        'Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s',\n        err.message\n      );\n      return false;\n    }\n  }\n\n  const checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\n\nconst isRadio = function (node) {\n  return isInput(node) && node.type === 'radio';\n};\n\nconst isNonTabbableRadio = function (node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nconst isNodeAttached = function (node) {\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  let nodeRoot = node && getRootNode(node);\n  let nodeRootHost = nodeRoot?.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  let attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    attached = !!(\n      nodeRootHost?.ownerDocument?.contains(nodeRootHost) ||\n      node?.ownerDocument?.contains(node)\n    );\n\n    while (!attached && nodeRootHost) {\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = nodeRoot?.host;\n      attached = !!nodeRootHost?.ownerDocument?.contains(nodeRootHost);\n    }\n  }\n\n  return attached;\n};\n\nconst isZeroArea = function (node) {\n  const { width, height } = node.getBoundingClientRect();\n  return width === 0 && height === 0;\n};\nconst isHidden = function (node, { displayCheck, getShadowRoot }) {\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n\n  const isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  const nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n\n  if (\n    !displayCheck ||\n    displayCheck === 'full' ||\n    displayCheck === 'legacy-full'\n  ) {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      const originalNode = node;\n      while (node) {\n        const parentElement = node.parentElement;\n        const rootNode = getRootNode(node);\n        if (\n          parentElement &&\n          !parentElement.shadowRoot &&\n          getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nconst isDisabledFromFieldset = function (node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    let parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (let i = 0; i < parentNode.children.length; i++) {\n          const child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *')\n              ? true\n              : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\n\nconst isNodeMatchingSelectorFocusable = function (options, node) {\n  if (\n    node.disabled ||\n    // we must do an inert look up to filter out any elements inside an inert ancestor\n    //  because we're limited in the type of selectors we can use in JSDom (see related\n    //  note related to `candidateSelectors`)\n    isInert(node) ||\n    isHiddenInput(node) ||\n    isHidden(node, options) ||\n    // For a details element with a summary, the summary element gets the focus\n    isDetailsWithSummary(node) ||\n    isDisabledFromFieldset(node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isNodeMatchingSelectorTabbable = function (options, node) {\n  if (\n    isNonTabbableRadio(node) ||\n    getTabIndex(node) < 0 ||\n    !isNodeMatchingSelectorFocusable(options, node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isValidShadowRootTabbable = function (shadowHostNode) {\n  const tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nconst sortByOrder = function (candidates) {\n  const regularTabbables = [];\n  const orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    const isScope = !!item.scopeParent;\n    const element = isScope ? item.scopeParent : item;\n    const candidateTabindex = getSortOrderTabIndex(element, isScope);\n    const elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope\n        ? regularTabbables.push(...elements)\n        : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements,\n      });\n    }\n  });\n\n  return orderedTabbables\n    .sort(sortOrderedTabbables)\n    .reduce((acc, sortable) => {\n      sortable.isScope\n        ? acc.push(...sortable.content)\n        : acc.push(sortable.content);\n      return acc;\n    }, [])\n    .concat(regularTabbables);\n};\n\nconst tabbable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorTabbable.bind(null, options),\n        flatten: false,\n        getShadowRoot: options.getShadowRoot,\n        shadowRootFilter: isValidShadowRootTabbable,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorTabbable.bind(null, options)\n    );\n  }\n  return sortByOrder(candidates);\n};\n\nconst focusable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorFocusable.bind(null, options),\n        flatten: true,\n        getShadowRoot: options.getShadowRoot,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorFocusable.bind(null, options)\n    );\n  }\n\n  return candidates;\n};\n\nconst isTabbable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\n\nconst focusableCandidateSelector = /* #__PURE__ */ candidateSelectors\n  .concat('iframe')\n  .join(',');\n\nconst isFocusable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { tabbable, focusable, isTabbable, isFocusable, getTabIndex };\n","import * as React from 'react';\nimport { useLayoutEffect, useEffect, useRef } from 'react';\nimport { stopEvent, getDocument, isMouseLikePointerType, contains, activeElement, isSafari, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, getTarget, getPlatform, isTypeableElement, isReactEvent, isRootElement, isEventTargetWithin, isMac, getUserAgent } from '@floating-ui/react/utils';\nimport { floor, evaluate, max, min, round } from '@floating-ui/utils';\nimport { jsx, jsxs, Fragment } from 'react/jsx-runtime';\nimport { getComputedStyle, isElement, getNodeName, isHTMLElement, getWindow, isLastTraversableNode, getParentNode, isWebKit } from '@floating-ui/utils/dom';\nimport { tabbable, isTabbable } from 'tabbable';\nimport * as ReactDOM from 'react-dom';\nimport { getOverflowAncestors, useFloating as useFloating$1, offset, detectOverflow } from '@floating-ui/react-dom';\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/react-dom';\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n * @see https://floating-ui.com/docs/react-utils#usemergerefs\n */\nfunction useMergeRefs(refs) {\n  return React.useMemo(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return value => {\n      refs.forEach(ref => {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref != null) {\n          ref.current = value;\n        }\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}\n\n// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379\nconst SafeReact = {\n  ...React\n};\n\nconst useInsertionEffect = SafeReact.useInsertionEffect;\nconst useSafeInsertionEffect = useInsertionEffect || (fn => fn());\nfunction useEffectEvent(callback) {\n  const ref = React.useRef(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      throw new Error('Cannot call an event handler while rendering.');\n    }\n  });\n  useSafeInsertionEffect(() => {\n    ref.current = callback;\n  });\n  return React.useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return ref.current == null ? void 0 : ref.current(...args);\n  }, []);\n}\n\nconst ARROW_UP = 'ArrowUp';\nconst ARROW_DOWN = 'ArrowDown';\nconst ARROW_LEFT = 'ArrowLeft';\nconst ARROW_RIGHT = 'ArrowRight';\nfunction isDifferentRow(index, cols, prevRow) {\n  return Math.floor(index / cols) !== prevRow;\n}\nfunction isIndexOutOfBounds(listRef, index) {\n  return index < 0 || index >= listRef.current.length;\n}\nfunction getMinIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    disabledIndices\n  });\n}\nfunction getMaxIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices\n  });\n}\nfunction findNonDisabledIndex(listRef, _temp) {\n  let {\n    startingIndex = -1,\n    decrement = false,\n    disabledIndices,\n    amount = 1\n  } = _temp === void 0 ? {} : _temp;\n  const list = listRef.current;\n  let index = startingIndex;\n  do {\n    index += decrement ? -amount : amount;\n  } while (index >= 0 && index <= list.length - 1 && isDisabled(list, index, disabledIndices));\n  return index;\n}\nfunction getGridNavigatedIndex(elementsRef, _ref) {\n  let {\n    event,\n    orientation,\n    loop,\n    rtl,\n    cols,\n    disabledIndices,\n    minIndex,\n    maxIndex,\n    prevIndex,\n    stopEvent: stop = false\n  } = _ref;\n  let nextIndex = prevIndex;\n  if (event.key === ARROW_UP) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = maxIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: nextIndex,\n        amount: cols,\n        decrement: true,\n        disabledIndices\n      });\n      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {\n        const col = prevIndex % cols;\n        const maxCol = maxIndex % cols;\n        const offset = maxIndex - (maxCol - col);\n        if (maxCol === col) {\n          nextIndex = maxIndex;\n        } else {\n          nextIndex = maxCol > col ? offset : offset - cols;\n        }\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n  if (event.key === ARROW_DOWN) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = minIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: prevIndex,\n        amount: cols,\n        disabledIndices\n      });\n      if (loop && prevIndex + cols > maxIndex) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex % cols - cols,\n          amount: cols,\n          disabledIndices\n        });\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n\n  // Remains on the same row/column.\n  if (orientation === 'both') {\n    const prevRow = floor(prevIndex / cols);\n    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== cols - 1) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex - prevIndex % cols - 1,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== 0) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          decrement: true,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex + (cols - prevIndex % cols),\n            decrement: true,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex + (cols - prevIndex % cols),\n          decrement: true,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    const lastRow = floor(maxIndex / cols) === prevRow;\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      if (loop && lastRow) {\n        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      } else {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n  return nextIndex;\n}\n\n/** For each cell index, gets the item index that occupies that cell */\nfunction buildCellMap(sizes, cols, dense) {\n  const cellMap = [];\n  let startIndex = 0;\n  sizes.forEach((_ref2, index) => {\n    let {\n      width,\n      height\n    } = _ref2;\n    if (width > cols) {\n      if (process.env.NODE_ENV !== \"production\") {\n        throw new Error(\"[Floating UI]: Invalid grid - item width at index \" + index + \" is greater than grid columns\");\n      }\n    }\n    let itemPlaced = false;\n    if (dense) {\n      startIndex = 0;\n    }\n    while (!itemPlaced) {\n      const targetCells = [];\n      for (let i = 0; i < width; i++) {\n        for (let j = 0; j < height; j++) {\n          targetCells.push(startIndex + i + j * cols);\n        }\n      }\n      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {\n        targetCells.forEach(cell => {\n          cellMap[cell] = index;\n        });\n        itemPlaced = true;\n      } else {\n        startIndex++;\n      }\n    }\n  });\n\n  // convert into a non-sparse array\n  return [...cellMap];\n}\n\n/** Gets cell index of an item's corner or -1 when index is -1. */\nfunction getCellIndexOfCorner(index, sizes, cellMap, cols, corner) {\n  if (index === -1) return -1;\n  const firstCellIndex = cellMap.indexOf(index);\n  const sizeItem = sizes[index];\n  switch (corner) {\n    case 'tl':\n      return firstCellIndex;\n    case 'tr':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + sizeItem.width - 1;\n    case 'bl':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + (sizeItem.height - 1) * cols;\n    case 'br':\n      return cellMap.lastIndexOf(index);\n  }\n}\n\n/** Gets all cell indices that correspond to the specified indices */\nfunction getCellIndices(indices, cellMap) {\n  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);\n}\nfunction isDisabled(list, index, disabledIndices) {\n  if (disabledIndices) {\n    return disabledIndices.includes(index);\n  }\n  const element = list[index];\n  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';\n}\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\nfunction sortByDocumentPosition(a, b) {\n  const position = a.compareDocumentPosition(b);\n  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n    return -1;\n  }\n  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {\n    return 1;\n  }\n  return 0;\n}\nfunction areMapsEqual(map1, map2) {\n  if (map1.size !== map2.size) {\n    return false;\n  }\n  for (const [key, value] of map1.entries()) {\n    if (value !== map2.get(key)) {\n      return false;\n    }\n  }\n  return true;\n}\nconst FloatingListContext = /*#__PURE__*/React.createContext({\n  register: () => {},\n  unregister: () => {},\n  map: /*#__PURE__*/new Map(),\n  elementsRef: {\n    current: []\n  }\n});\n/**\n * Provides context for a list of items within the floating element.\n * @see https://floating-ui.com/docs/FloatingList\n */\nfunction FloatingList(props) {\n  const {\n    children,\n    elementsRef,\n    labelsRef\n  } = props;\n  const [map, setMap] = React.useState(() => new Map());\n  const register = React.useCallback(node => {\n    setMap(prevMap => new Map(prevMap).set(node, null));\n  }, []);\n  const unregister = React.useCallback(node => {\n    setMap(prevMap => {\n      const map = new Map(prevMap);\n      map.delete(node);\n      return map;\n    });\n  }, []);\n  index(() => {\n    const newMap = new Map(map);\n    const nodes = Array.from(newMap.keys()).sort(sortByDocumentPosition);\n    nodes.forEach((node, index) => {\n      newMap.set(node, index);\n    });\n    if (!areMapsEqual(map, newMap)) {\n      setMap(newMap);\n    }\n  }, [map]);\n  return /*#__PURE__*/jsx(FloatingListContext.Provider, {\n    value: React.useMemo(() => ({\n      register,\n      unregister,\n      map,\n      elementsRef,\n      labelsRef\n    }), [register, unregister, map, elementsRef, labelsRef]),\n    children: children\n  });\n}\n/**\n * Used to register a list item and its index (DOM position) in the\n * `FloatingList`.\n * @see https://floating-ui.com/docs/FloatingList#uselistitem\n */\nfunction useListItem(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    label\n  } = props;\n  const {\n    register,\n    unregister,\n    map,\n    elementsRef,\n    labelsRef\n  } = React.useContext(FloatingListContext);\n  const [index$1, setIndex] = React.useState(null);\n  const componentRef = React.useRef(null);\n  const ref = React.useCallback(node => {\n    componentRef.current = node;\n    if (index$1 !== null) {\n      elementsRef.current[index$1] = node;\n      if (labelsRef) {\n        var _node$textContent;\n        const isLabelDefined = label !== undefined;\n        labelsRef.current[index$1] = isLabelDefined ? label : (_node$textContent = node == null ? void 0 : node.textContent) != null ? _node$textContent : null;\n      }\n    }\n  }, [index$1, elementsRef, labelsRef, label]);\n  index(() => {\n    const node = componentRef.current;\n    if (node) {\n      register(node);\n      return () => {\n        unregister(node);\n      };\n    }\n  }, [register, unregister]);\n  index(() => {\n    const index = componentRef.current ? map.get(componentRef.current) : null;\n    if (index != null) {\n      setIndex(index);\n    }\n  }, [map]);\n  return React.useMemo(() => ({\n    ref,\n    index: index$1 == null ? -1 : index$1\n  }), [index$1, ref]);\n}\n\nfunction renderJsx(render, computedProps) {\n  if (typeof render === 'function') {\n    return render(computedProps);\n  }\n  if (render) {\n    return /*#__PURE__*/React.cloneElement(render, computedProps);\n  }\n  return /*#__PURE__*/jsx(\"div\", {\n    ...computedProps\n  });\n}\nconst CompositeContext = /*#__PURE__*/React.createContext({\n  activeIndex: 0,\n  onNavigate: () => {}\n});\nconst horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];\nconst verticalKeys = [ARROW_UP, ARROW_DOWN];\nconst allKeys = [...horizontalKeys, ...verticalKeys];\n\n/**\n * Creates a single tab stop whose items are navigated by arrow keys, which\n * provides list navigation outside of floating element contexts.\n *\n * This is useful to enable navigation of a list of items that aren’t part of a\n * floating element. A menubar is an example of a composite, with each reference\n * element being an item.\n * @see https://floating-ui.com/docs/Composite\n */\nconst Composite = /*#__PURE__*/React.forwardRef(function Composite(props, forwardedRef) {\n  const {\n    render,\n    orientation = 'both',\n    loop = true,\n    rtl = false,\n    cols = 1,\n    disabledIndices,\n    activeIndex: externalActiveIndex,\n    onNavigate: externalSetActiveIndex,\n    itemSizes,\n    dense = false,\n    ...domProps\n  } = props;\n  const [internalActiveIndex, internalSetActiveIndex] = React.useState(0);\n  const activeIndex = externalActiveIndex != null ? externalActiveIndex : internalActiveIndex;\n  const onNavigate = useEffectEvent(externalSetActiveIndex != null ? externalSetActiveIndex : internalSetActiveIndex);\n  const elementsRef = React.useRef([]);\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const contextValue = React.useMemo(() => ({\n    activeIndex,\n    onNavigate\n  }), [activeIndex, onNavigate]);\n  const isGrid = cols > 1;\n  function handleKeyDown(event) {\n    if (!allKeys.includes(event.key)) return;\n    let nextIndex = activeIndex;\n    const minIndex = getMinIndex(elementsRef, disabledIndices);\n    const maxIndex = getMaxIndex(elementsRef, disabledIndices);\n    const horizontalEndKey = rtl ? ARROW_LEFT : ARROW_RIGHT;\n    const horizontalStartKey = rtl ? ARROW_RIGHT : ARROW_LEFT;\n    if (isGrid) {\n      const sizes = itemSizes || Array.from({\n        length: elementsRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(elementsRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(elementsRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const maybeNextIndex = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex ? elementsRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || elementsRef.current.map((_, index) => isDisabled(elementsRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(activeIndex > maxIndex ? minIndex : activeIndex, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction we're\n        // moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === horizontalEndKey ? 'tr' : 'tl')\n      })];\n      if (maybeNextIndex != null) {\n        nextIndex = maybeNextIndex;\n      }\n    }\n    const toEndKeys = {\n      horizontal: [horizontalEndKey],\n      vertical: [ARROW_DOWN],\n      both: [horizontalEndKey, ARROW_DOWN]\n    }[orientation];\n    const toStartKeys = {\n      horizontal: [horizontalStartKey],\n      vertical: [ARROW_UP],\n      both: [horizontalStartKey, ARROW_UP]\n    }[orientation];\n    const preventedKeys = isGrid ? allKeys : {\n      horizontal: horizontalKeys,\n      vertical: verticalKeys,\n      both: allKeys\n    }[orientation];\n    if (nextIndex === activeIndex && [...toEndKeys, ...toStartKeys].includes(event.key)) {\n      if (loop && nextIndex === maxIndex && toEndKeys.includes(event.key)) {\n        nextIndex = minIndex;\n      } else if (loop && nextIndex === minIndex && toStartKeys.includes(event.key)) {\n        nextIndex = maxIndex;\n      } else {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: nextIndex,\n          decrement: toStartKeys.includes(event.key),\n          disabledIndices\n        });\n      }\n    }\n    if (nextIndex !== activeIndex && !isIndexOutOfBounds(elementsRef, nextIndex)) {\n      var _elementsRef$current$;\n      event.stopPropagation();\n      if (preventedKeys.includes(event.key)) {\n        event.preventDefault();\n      }\n      onNavigate(nextIndex);\n      (_elementsRef$current$ = elementsRef.current[nextIndex]) == null || _elementsRef$current$.focus();\n    }\n  }\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: forwardedRef,\n    'aria-orientation': orientation === 'both' ? undefined : orientation,\n    onKeyDown(e) {\n      domProps.onKeyDown == null || domProps.onKeyDown(e);\n      renderElementProps.onKeyDown == null || renderElementProps.onKeyDown(e);\n      handleKeyDown(e);\n    }\n  };\n  return /*#__PURE__*/jsx(CompositeContext.Provider, {\n    value: contextValue,\n    children: /*#__PURE__*/jsx(FloatingList, {\n      elementsRef: elementsRef,\n      children: renderJsx(render, computedProps)\n    })\n  });\n});\n/**\n * @see https://floating-ui.com/docs/Composite\n */\nconst CompositeItem = /*#__PURE__*/React.forwardRef(function CompositeItem(props, forwardedRef) {\n  const {\n    render,\n    ...domProps\n  } = props;\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const {\n    activeIndex,\n    onNavigate\n  } = React.useContext(CompositeContext);\n  const {\n    ref,\n    index\n  } = useListItem();\n  const mergedRef = useMergeRefs([ref, forwardedRef, renderElementProps.ref]);\n  const isActive = activeIndex === index;\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: mergedRef,\n    tabIndex: isActive ? 0 : -1,\n    'data-active': isActive ? '' : undefined,\n    onFocus(e) {\n      domProps.onFocus == null || domProps.onFocus(e);\n      renderElementProps.onFocus == null || renderElementProps.onFocus(e);\n      onNavigate(index);\n    }\n  };\n  return renderJsx(render, computedProps);\n});\n\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () => // Ensure the id is unique with multiple independent versions of Floating UI\n// on <React 18\n\"floating-ui-\" + Math.random().toString(36).slice(2, 6) + count++;\nfunction useFloatingId() {\n  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : undefined);\n  index(() => {\n    if (id == null) {\n      setId(genId());\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  React.useEffect(() => {\n    serverHandoffComplete = true;\n  }, []);\n  return id;\n}\nconst useReactId = SafeReact.useId;\n\n/**\n * Uses React 18's built-in `useId()` when available, or falls back to a\n * slightly less performant (requiring a double render) implementation for\n * earlier React versions.\n * @see https://floating-ui.com/docs/react-utils#useid\n */\nconst useId = useReactId || useFloatingId;\n\nlet devMessageSet;\nif (process.env.NODE_ENV !== \"production\") {\n  devMessageSet = /*#__PURE__*/new Set();\n}\nfunction warn() {\n  var _devMessageSet;\n  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {\n    messages[_key] = arguments[_key];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {\n    var _devMessageSet2;\n    (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);\n    console.warn(message);\n  }\n}\nfunction error() {\n  var _devMessageSet3;\n  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n    messages[_key2] = arguments[_key2];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {\n    var _devMessageSet4;\n    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);\n    console.error(message);\n  }\n}\n\n/**\n * Renders a pointing arrow triangle.\n * @see https://floating-ui.com/docs/FloatingArrow\n */\nconst FloatingArrow = /*#__PURE__*/React.forwardRef(function FloatingArrow(props, ref) {\n  const {\n    context: {\n      placement,\n      elements: {\n        floating\n      },\n      middlewareData: {\n        arrow,\n        shift\n      }\n    },\n    width = 14,\n    height = 7,\n    tipRadius = 0,\n    strokeWidth = 0,\n    staticOffset,\n    stroke,\n    d,\n    style: {\n      transform,\n      ...restStyle\n    } = {},\n    ...rest\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!ref) {\n      warn('The `ref` prop is required for `FloatingArrow`.');\n    }\n  }\n  const clipPathId = useId();\n  const [isRTL, setIsRTL] = React.useState(false);\n\n  // https://github.com/floating-ui/floating-ui/issues/2932\n  index(() => {\n    if (!floating) return;\n    const isRTL = getComputedStyle(floating).direction === 'rtl';\n    if (isRTL) {\n      setIsRTL(true);\n    }\n  }, [floating]);\n  if (!floating) {\n    return null;\n  }\n  const [side, alignment] = placement.split('-');\n  const isVerticalSide = side === 'top' || side === 'bottom';\n  let computedStaticOffset = staticOffset;\n  if (isVerticalSide && shift != null && shift.x || !isVerticalSide && shift != null && shift.y) {\n    computedStaticOffset = null;\n  }\n\n  // Strokes must be double the border width, this ensures the stroke's width\n  // works as you'd expect.\n  const computedStrokeWidth = strokeWidth * 2;\n  const halfStrokeWidth = computedStrokeWidth / 2;\n  const svgX = width / 2 * (tipRadius / -8 + 1);\n  const svgY = height / 2 * tipRadius / 4;\n  const isCustomShape = !!d;\n  const yOffsetProp = computedStaticOffset && alignment === 'end' ? 'bottom' : 'top';\n  let xOffsetProp = computedStaticOffset && alignment === 'end' ? 'right' : 'left';\n  if (computedStaticOffset && isRTL) {\n    xOffsetProp = alignment === 'end' ? 'left' : 'right';\n  }\n  const arrowX = (arrow == null ? void 0 : arrow.x) != null ? computedStaticOffset || arrow.x : '';\n  const arrowY = (arrow == null ? void 0 : arrow.y) != null ? computedStaticOffset || arrow.y : '';\n  const dValue = d || 'M0,0' + (\" H\" + width) + (\" L\" + (width - svgX) + \",\" + (height - svgY)) + (\" Q\" + width / 2 + \",\" + height + \" \" + svgX + \",\" + (height - svgY)) + ' Z';\n  const rotation = {\n    top: isCustomShape ? 'rotate(180deg)' : '',\n    left: isCustomShape ? 'rotate(90deg)' : 'rotate(-90deg)',\n    bottom: isCustomShape ? '' : 'rotate(180deg)',\n    right: isCustomShape ? 'rotate(-90deg)' : 'rotate(90deg)'\n  }[side];\n  return /*#__PURE__*/jsxs(\"svg\", {\n    ...rest,\n    \"aria-hidden\": true,\n    ref: ref,\n    width: isCustomShape ? width : width + computedStrokeWidth,\n    height: width,\n    viewBox: \"0 0 \" + width + \" \" + (height > width ? height : width),\n    style: {\n      position: 'absolute',\n      pointerEvents: 'none',\n      [xOffsetProp]: arrowX,\n      [yOffsetProp]: arrowY,\n      [side]: isVerticalSide || isCustomShape ? '100%' : \"calc(100% - \" + computedStrokeWidth / 2 + \"px)\",\n      transform: [rotation, transform].filter(t => !!t).join(' '),\n      ...restStyle\n    },\n    children: [computedStrokeWidth > 0 && /*#__PURE__*/jsx(\"path\", {\n      clipPath: \"url(#\" + clipPathId + \")\",\n      fill: \"none\",\n      stroke: stroke\n      // Account for the stroke on the fill path rendered below.\n      ,\n      strokeWidth: computedStrokeWidth + (d ? 0 : 1),\n      d: dValue\n    }), /*#__PURE__*/jsx(\"path\", {\n      stroke: computedStrokeWidth && !d ? rest.fill : 'none',\n      d: dValue\n    }), /*#__PURE__*/jsx(\"clipPath\", {\n      id: clipPathId,\n      children: /*#__PURE__*/jsx(\"rect\", {\n        x: -halfStrokeWidth,\n        y: halfStrokeWidth * (isCustomShape ? -1 : 1),\n        width: width + computedStrokeWidth,\n        height: width\n      })\n    })]\n  });\n});\n\nfunction createPubSub() {\n  const map = new Map();\n  return {\n    emit(event, data) {\n      var _map$get;\n      (_map$get = map.get(event)) == null || _map$get.forEach(handler => handler(data));\n    },\n    on(event, listener) {\n      map.set(event, [...(map.get(event) || []), listener]);\n    },\n    off(event, listener) {\n      var _map$get2;\n      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter(l => l !== listener)) || []);\n    }\n  };\n}\n\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the parent node id for nested floating elements, if available.\n * Returns `null` for top-level floating elements.\n */\nconst useFloatingParentNodeId = () => {\n  var _React$useContext;\n  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;\n};\n\n/**\n * Returns the nearest floating tree context, if available.\n */\nconst useFloatingTree = () => React.useContext(FloatingTreeContext);\n\n/**\n * Registers a node into the `FloatingTree`, returning its id.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction useFloatingNodeId(customParentId) {\n  const id = useId();\n  const tree = useFloatingTree();\n  const reactParentId = useFloatingParentNodeId();\n  const parentId = customParentId || reactParentId;\n  index(() => {\n    if (!id) return;\n    const node = {\n      id,\n      parentId\n    };\n    tree == null || tree.addNode(node);\n    return () => {\n      tree == null || tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n}\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingNode(props) {\n  const {\n    children,\n    id\n  } = props;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/jsx(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId]),\n    children: children\n  });\n}\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM.\n * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:\n * - The `bubbles` option in the `useDismiss()` Hook\n * - Nested virtual list navigation\n * - Nested floating elements that each open on hover\n * - Custom communication between parent and child floating elements\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingTree(props) {\n  const {\n    children\n  } = props;\n  const nodesRef = React.useRef([]);\n  const addNode = React.useCallback(node => {\n    nodesRef.current = [...nodesRef.current, node];\n  }, []);\n  const removeNode = React.useCallback(node => {\n    nodesRef.current = nodesRef.current.filter(n => n !== node);\n  }, []);\n  const events = React.useState(() => createPubSub())[0];\n  return /*#__PURE__*/jsx(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [addNode, removeNode, events]),\n    children: children\n  });\n}\n\nfunction createAttribute(name) {\n  return \"data-floating-ui-\" + name;\n}\n\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst safePolygonIdentifier = /*#__PURE__*/createAttribute('safe-polygon');\nfunction getDelay(value, prop, pointerType) {\n  if (pointerType && !isMouseLikePointerType(pointerType)) {\n    return 0;\n  }\n  if (typeof value === 'number') {\n    return value;\n  }\n  return value == null ? void 0 : value[prop];\n}\n/**\n * Opens the floating element while hovering over the reference element, like\n * CSS `:hover`.\n * @see https://floating-ui.com/docs/useHover\n */\nfunction useHover(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    delay = 0,\n    handleClose = null,\n    mouseOnly = false,\n    restMs = 0,\n    move = true\n  } = props;\n  const tree = useFloatingTree();\n  const parentId = useFloatingParentNodeId();\n  const handleCloseRef = useLatestRef(handleClose);\n  const delayRef = useLatestRef(delay);\n  const openRef = useLatestRef(open);\n  const pointerTypeRef = React.useRef();\n  const timeoutRef = React.useRef(-1);\n  const handlerRef = React.useRef();\n  const restTimeoutRef = React.useRef(-1);\n  const blockMouseMoveRef = React.useRef(true);\n  const performedPointerEventsMutationRef = React.useRef(false);\n  const unbindMouseMoveRef = React.useRef(() => {});\n  const restTimeoutPendingRef = React.useRef(false);\n  const isHoverOpen = React.useCallback(() => {\n    var _dataRef$current$open;\n    const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;\n    return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';\n  }, [dataRef]);\n\n  // When closing before opening, clear the delay timeouts to cancel it\n  // from showing.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        open\n      } = _ref;\n      if (!open) {\n        clearTimeout(timeoutRef.current);\n        clearTimeout(restTimeoutRef.current);\n        blockMouseMoveRef.current = true;\n        restTimeoutPendingRef.current = false;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [enabled, events]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    if (!handleCloseRef.current) return;\n    if (!open) return;\n    function onLeave(event) {\n      if (isHoverOpen()) {\n        onOpenChange(false, event, 'hover');\n      }\n    }\n    const html = getDocument(elements.floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return () => {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [elements.floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);\n  const closeWithDelay = React.useCallback(function (event, runElseBranch, reason) {\n    if (runElseBranch === void 0) {\n      runElseBranch = true;\n    }\n    if (reason === void 0) {\n      reason = 'hover';\n    }\n    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = window.setTimeout(() => onOpenChange(false, event, reason), closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false, event, reason);\n    }\n  }, [delayRef, onOpenChange]);\n  const cleanupMouseMoveHandler = useEffectEvent(() => {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  });\n  const clearPointerEvents = useEffectEvent(() => {\n    if (performedPointerEventsMutationRef.current) {\n      const body = getDocument(elements.floating).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  });\n  const isClickLikeOpenEvent = useEffectEvent(() => {\n    return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n  });\n\n  // Registering the mouse events on the reference directly to bypass React's\n  // delegation system. If the cursor was on a disabled element and then entered\n  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && !getDelay(delayRef.current, 'open')) {\n        return;\n      }\n      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = window.setTimeout(() => {\n          if (!openRef.current) {\n            onOpenChange(true, event, 'hover');\n          }\n        }, openDelay);\n      } else if (!open) {\n        onOpenChange(true, event, 'hover');\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      unbindMouseMoveRef.current();\n      const doc = getDocument(elements.floating);\n      clearTimeout(restTimeoutRef.current);\n      restTimeoutPendingRef.current = false;\n      if (handleCloseRef.current && dataRef.current.floatingContext) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current({\n          ...dataRef.current.floatingContext,\n          tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            if (!isClickLikeOpenEvent()) {\n              closeWithDelay(event, true, 'safe-polygon');\n            }\n          }\n        });\n        const handler = handlerRef.current;\n        doc.addEventListener('mousemove', handler);\n        unbindMouseMoveRef.current = () => {\n          doc.removeEventListener('mousemove', handler);\n        };\n        return;\n      }\n\n      // Allow interactivity without `safePolygon` on touch devices. With a\n      // pointer, a short close delay is an alternative, so it should work\n      // consistently.\n      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(elements.floating, event.relatedTarget) : true;\n      if (shouldClose) {\n        closeWithDelay(event);\n      }\n    }\n\n    // Ensure the floating element closes after scrolling even if the pointer\n    // did not move.\n    // https://github.com/floating-ui/floating-ui/discussions/1692\n    function onScrollMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      if (!dataRef.current.floatingContext) return;\n      handleCloseRef.current == null || handleCloseRef.current({\n        ...dataRef.current.floatingContext,\n        tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          if (!isClickLikeOpenEvent()) {\n            closeWithDelay(event);\n          }\n        }\n      })(event);\n    }\n    if (isElement(elements.domReference)) {\n      var _elements$floating;\n      const ref = elements.domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      (_elements$floating = elements.floating) == null || _elements$floating.addEventListener('mouseleave', onScrollMouseLeave);\n      move && ref.addEventListener('mousemove', onMouseEnter, {\n        once: true\n      });\n      ref.addEventListener('mouseenter', onMouseEnter);\n      ref.addEventListener('mouseleave', onMouseLeave);\n      return () => {\n        var _elements$floating2;\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        (_elements$floating2 = elements.floating) == null || _elements$floating2.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [elements, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, openRef, tree, delayRef, handleCloseRef, dataRef, isClickLikeOpenEvent]);\n\n  // Block pointer-events of every element other than the reference and floating\n  // while the floating element is open and has a `handleClose` handler. Also\n  // handles nested floating elements.\n  // https://github.com/floating-ui/floating-ui/issues/1722\n  index(() => {\n    var _handleCloseRef$curre;\n    if (!enabled) return;\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      performedPointerEventsMutationRef.current = true;\n      const floatingEl = elements.floating;\n      if (isElement(elements.domReference) && floatingEl) {\n        var _tree$nodesRef$curren;\n        const body = getDocument(elements.floating).body;\n        body.setAttribute(safePolygonIdentifier, '');\n        const ref = elements.domReference;\n        const parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;\n        if (parentFloating) {\n          parentFloating.style.pointerEvents = '';\n        }\n        body.style.pointerEvents = 'none';\n        ref.style.pointerEvents = 'auto';\n        floatingEl.style.pointerEvents = 'auto';\n        return () => {\n          body.style.pointerEvents = '';\n          ref.style.pointerEvents = '';\n          floatingEl.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, elements, tree, handleCloseRef, isHoverOpen]);\n  index(() => {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      restTimeoutPendingRef.current = false;\n      cleanupMouseMoveHandler();\n      clearPointerEvents();\n    }\n  }, [open, cleanupMouseMoveHandler, clearPointerEvents]);\n  React.useEffect(() => {\n    return () => {\n      cleanupMouseMoveHandler();\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      clearPointerEvents();\n    };\n  }, [enabled, elements.domReference, cleanupMouseMoveHandler, clearPointerEvents]);\n  const reference = React.useMemo(() => {\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      onPointerDown: setPointerRef,\n      onPointerEnter: setPointerRef,\n      onMouseMove(event) {\n        const {\n          nativeEvent\n        } = event;\n        function handleMouseMove() {\n          if (!blockMouseMoveRef.current && !openRef.current) {\n            onOpenChange(true, nativeEvent, 'hover');\n          }\n        }\n        if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {\n          return;\n        }\n        if (open || restMs === 0) {\n          return;\n        }\n\n        // Ignore insignificant movements to account for tremors.\n        if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) {\n          return;\n        }\n        clearTimeout(restTimeoutRef.current);\n        if (pointerTypeRef.current === 'touch') {\n          handleMouseMove();\n        } else {\n          restTimeoutPendingRef.current = true;\n          restTimeoutRef.current = window.setTimeout(handleMouseMove, restMs);\n        }\n      }\n    };\n  }, [mouseOnly, onOpenChange, open, openRef, restMs]);\n  const floating = React.useMemo(() => ({\n    onMouseEnter() {\n      clearTimeout(timeoutRef.current);\n    },\n    onMouseLeave(event) {\n      if (!isClickLikeOpenEvent()) {\n        closeWithDelay(event.nativeEvent, false);\n      }\n    }\n  }), [closeWithDelay, isClickLikeOpenEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nconst NOOP = () => {};\nconst FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: NOOP,\n  setState: NOOP,\n  isInstantPhase: false\n});\n\n/**\n * @deprecated\n * Use the return value of `useDelayGroup()` instead.\n */\nconst useDelayGroupContext = () => React.useContext(FloatingDelayGroupContext);\n/**\n * Provides context for a group of floating elements that should share a\n * `delay`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction FloatingDelayGroup(props) {\n  const {\n    children,\n    delay,\n    timeoutMs = 0\n  } = props;\n  const [state, setState] = React.useReducer((prev, next) => ({\n    ...prev,\n    ...next\n  }), {\n    delay,\n    timeoutMs,\n    initialDelay: delay,\n    currentId: null,\n    isInstantPhase: false\n  });\n  const initialCurrentIdRef = React.useRef(null);\n  const setCurrentId = React.useCallback(currentId => {\n    setState({\n      currentId\n    });\n  }, []);\n  index(() => {\n    if (state.currentId) {\n      if (initialCurrentIdRef.current === null) {\n        initialCurrentIdRef.current = state.currentId;\n      } else if (!state.isInstantPhase) {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      if (state.isInstantPhase) {\n        setState({\n          isInstantPhase: false\n        });\n      }\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId, state.isInstantPhase]);\n  return /*#__PURE__*/jsx(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setCurrentId]),\n    children: children\n  });\n}\n/**\n * Enables grouping when called inside a component that's a child of a\n * `FloatingDelayGroup`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction useDelayGroup(context, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    floatingId\n  } = context;\n  const {\n    id: optionId,\n    enabled = true\n  } = options;\n  const id = optionId != null ? optionId : floatingId;\n  const groupContext = useDelayGroupContext();\n  const {\n    currentId,\n    setCurrentId,\n    initialDelay,\n    setState,\n    timeoutMs\n  } = groupContext;\n  index(() => {\n    if (!enabled) return;\n    if (!currentId) return;\n    setState({\n      delay: {\n        open: 1,\n        close: getDelay(initialDelay, 'close')\n      }\n    });\n    if (currentId !== id) {\n      onOpenChange(false);\n    }\n  }, [enabled, id, onOpenChange, setState, currentId, initialDelay]);\n  index(() => {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!enabled) return;\n    if (!currentId) return;\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        const timeout = window.setTimeout(unset, timeoutMs);\n        return () => {\n          clearTimeout(timeout);\n        };\n      }\n      unset();\n    }\n  }, [enabled, open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  index(() => {\n    if (!enabled) return;\n    if (setCurrentId === NOOP || !open) return;\n    setCurrentId(id);\n  }, [enabled, open, setCurrentId, id]);\n  return groupContext;\n}\n\nlet rafId = 0;\nfunction enqueueFocus(el, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    preventScroll = false,\n    cancelPrevious = true,\n    sync = false\n  } = options;\n  cancelPrevious && cancelAnimationFrame(rafId);\n  const exec = () => el == null ? void 0 : el.focus({\n    preventScroll\n  });\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}\n\nfunction getAncestors(nodes, id) {\n  var _nodes$find;\n  let allAncestors = [];\n  let currentParentId = (_nodes$find = nodes.find(node => node.id === id)) == null ? void 0 : _nodes$find.parentId;\n  while (currentParentId) {\n    const currentNode = nodes.find(node => node.id === currentParentId);\n    currentParentId = currentNode == null ? void 0 : currentNode.parentId;\n    if (currentNode) {\n      allAncestors = allAncestors.concat(currentNode);\n    }\n  }\n  return allAncestors;\n}\n\nfunction getChildren(nodes, id) {\n  let allChildren = nodes.filter(node => {\n    var _node$context;\n    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);\n  });\n  let currentChildren = allChildren;\n  while (currentChildren.length) {\n    currentChildren = nodes.filter(node => {\n      var _currentChildren;\n      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(n => {\n        var _node$context2;\n        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);\n      });\n    });\n    allChildren = allChildren.concat(currentChildren);\n  }\n  return allChildren;\n}\nfunction getDeepestNode(nodes, id) {\n  let deepestNodeId;\n  let maxDepth = -1;\n  function findDeepest(nodeId, depth) {\n    if (depth > maxDepth) {\n      deepestNodeId = nodeId;\n      maxDepth = depth;\n    }\n    const children = getChildren(nodes, nodeId);\n    children.forEach(child => {\n      findDeepest(child.id, depth + 1);\n    });\n  }\n  findDeepest(id, 0);\n  return nodes.find(node => node.id === deepestNodeId);\n}\n\n// Modified to add conditional `aria-hidden` support:\n// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts\nlet counterMap = /*#__PURE__*/new WeakMap();\nlet uncontrolledElementsSet = /*#__PURE__*/new WeakSet();\nlet markerMap = {};\nlet lockCount$1 = 0;\nconst supportsInert = () => typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;\nconst unwrapHost = node => node && (node.host || unwrapHost(node.parentNode));\nconst correctElements = (parent, targets) => targets.map(target => {\n  if (parent.contains(target)) {\n    return target;\n  }\n  const correctedTarget = unwrapHost(target);\n  if (parent.contains(correctedTarget)) {\n    return correctedTarget;\n  }\n  return null;\n}).filter(x => x != null);\nfunction applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {\n  const markerName = 'data-floating-ui-inert';\n  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;\n  const avoidElements = correctElements(body, uncorrectedAvoidElements);\n  const elementsToKeep = new Set();\n  const elementsToStop = new Set(avoidElements);\n  const hiddenElements = [];\n  if (!markerMap[markerName]) {\n    markerMap[markerName] = new WeakMap();\n  }\n  const markerCounter = markerMap[markerName];\n  avoidElements.forEach(keep);\n  deep(body);\n  elementsToKeep.clear();\n  function keep(el) {\n    if (!el || elementsToKeep.has(el)) {\n      return;\n    }\n    elementsToKeep.add(el);\n    el.parentNode && keep(el.parentNode);\n  }\n  function deep(parent) {\n    if (!parent || elementsToStop.has(parent)) {\n      return;\n    }\n    [].forEach.call(parent.children, node => {\n      if (getNodeName(node) === 'script') return;\n      if (elementsToKeep.has(node)) {\n        deep(node);\n      } else {\n        const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;\n        const alreadyHidden = attr !== null && attr !== 'false';\n        const currentCounterValue = counterMap.get(node) || 0;\n        const counterValue = controlAttribute ? currentCounterValue + 1 : currentCounterValue;\n        const markerValue = (markerCounter.get(node) || 0) + 1;\n        counterMap.set(node, counterValue);\n        markerCounter.set(node, markerValue);\n        hiddenElements.push(node);\n        if (counterValue === 1 && alreadyHidden) {\n          uncontrolledElementsSet.add(node);\n        }\n        if (markerValue === 1) {\n          node.setAttribute(markerName, '');\n        }\n        if (!alreadyHidden && controlAttribute) {\n          node.setAttribute(controlAttribute, 'true');\n        }\n      }\n    });\n  }\n  lockCount$1++;\n  return () => {\n    hiddenElements.forEach(element => {\n      const currentCounterValue = counterMap.get(element) || 0;\n      const counterValue = controlAttribute ? currentCounterValue - 1 : currentCounterValue;\n      const markerValue = (markerCounter.get(element) || 0) - 1;\n      counterMap.set(element, counterValue);\n      markerCounter.set(element, markerValue);\n      if (!counterValue) {\n        if (!uncontrolledElementsSet.has(element) && controlAttribute) {\n          element.removeAttribute(controlAttribute);\n        }\n        uncontrolledElementsSet.delete(element);\n      }\n      if (!markerValue) {\n        element.removeAttribute(markerName);\n      }\n    });\n    lockCount$1--;\n    if (!lockCount$1) {\n      counterMap = new WeakMap();\n      counterMap = new WeakMap();\n      uncontrolledElementsSet = new WeakSet();\n      markerMap = {};\n    }\n  };\n}\nfunction markOthers(avoidElements, ariaHidden, inert) {\n  if (ariaHidden === void 0) {\n    ariaHidden = false;\n  }\n  if (inert === void 0) {\n    inert = false;\n  }\n  const body = getDocument(avoidElements[0]).body;\n  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);\n}\n\nconst getTabbableOptions = () => ({\n  getShadowRoot: true,\n  displayCheck:\n  // JSDOM does not support the `tabbable` library. To solve this we can\n  // check if `ResizeObserver` is a real function (not polyfilled), which\n  // determines if the current environment is JSDOM-like.\n  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'\n});\nfunction getTabbableIn(container, direction) {\n  const allTabbable = tabbable(container, getTabbableOptions());\n  if (direction === 'prev') {\n    allTabbable.reverse();\n  }\n  const activeIndex = allTabbable.indexOf(activeElement(getDocument(container)));\n  const nextTabbableElements = allTabbable.slice(activeIndex + 1);\n  return nextTabbableElements[0];\n}\nfunction getNextTabbable() {\n  return getTabbableIn(document.body, 'next');\n}\nfunction getPreviousTabbable() {\n  return getTabbableIn(document.body, 'prev');\n}\nfunction isOutsideEvent(event, container) {\n  const containerElement = container || event.currentTarget;\n  const relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction disableFocusInside(container) {\n  const tabbableElements = tabbable(container, getTabbableOptions());\n  tabbableElements.forEach(element => {\n    element.dataset.tabindex = element.getAttribute('tabindex') || '';\n    element.setAttribute('tabindex', '-1');\n  });\n}\nfunction enableFocusInside(container) {\n  const elements = container.querySelectorAll('[data-tabindex]');\n  elements.forEach(element => {\n    const tabindex = element.dataset.tabindex;\n    delete element.dataset.tabindex;\n    if (tabindex) {\n      element.setAttribute('tabindex', tabindex);\n    } else {\n      element.removeAttribute('tabindex');\n    }\n  });\n}\n\nconst HIDDEN_STYLES = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'fixed',\n  whiteSpace: 'nowrap',\n  width: '1px',\n  top: 0,\n  left: 0\n};\nlet timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    event.target;\n    clearTimeout(timeoutId);\n  }\n}\nconst FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\n  const [role, setRole] = React.useState();\n  index(() => {\n    if (isSafari()) {\n      // Unlike other screen readers such as NVDA and JAWS, the virtual cursor\n      // on VoiceOver does trigger the onFocus event, so we can use the focus\n      // trap element. On Safari, only buttons trigger the onFocus event.\n      // NB: \"group\" role in the Sandbox no longer appears to work, must be a\n      // button role.\n      setRole('button');\n    }\n    document.addEventListener('keydown', setActiveElementOnTab);\n    return () => {\n      document.removeEventListener('keydown', setActiveElementOnTab);\n    };\n  }, []);\n  const restProps = {\n    ref,\n    tabIndex: 0,\n    // Role is only for VoiceOver\n    role,\n    'aria-hidden': role ? undefined : true,\n    [createAttribute('focus-guard')]: '',\n    style: HIDDEN_STYLES\n  };\n  return /*#__PURE__*/jsx(\"span\", {\n    ...props,\n    ...restProps\n  });\n});\n\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nconst attr = /*#__PURE__*/createAttribute('portal');\n/**\n * @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode\n */\nfunction useFloatingPortalNode(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    id,\n    root\n  } = props;\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  const [portalNode, setPortalNode] = React.useState(null);\n  const portalNodeRef = React.useRef(null);\n  index(() => {\n    return () => {\n      portalNode == null || portalNode.remove();\n      // Allow the subsequent layout effects to create a new node on updates.\n      // The portal node will still be cleaned up on unmount.\n      // https://github.com/floating-ui/floating-ui/issues/2454\n      queueMicrotask(() => {\n        portalNodeRef.current = null;\n      });\n    };\n  }, [portalNode]);\n  index(() => {\n    // Wait for the uniqueId to be generated before creating the portal node in\n    // React <18 (using `useFloatingId` instead of the native `useId`).\n    // https://github.com/floating-ui/floating-ui/issues/2778\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    const existingIdRoot = id ? document.getElementById(id) : null;\n    if (!existingIdRoot) return;\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    existingIdRoot.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, uniqueId]);\n  index(() => {\n    // Wait for the root to exist before creating the portal node. The root must\n    // be stored in state, not a ref, for this to work reactively.\n    if (root === null) return;\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    let container = root || (portalContext == null ? void 0 : portalContext.portalNode);\n    if (container && !isElement(container)) container = container.current;\n    container = container || document.body;\n    let idWrapper = null;\n    if (id) {\n      idWrapper = document.createElement('div');\n      idWrapper.id = id;\n      container.appendChild(idWrapper);\n    }\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    container = idWrapper || container;\n    container.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, root, uniqueId, portalContext]);\n  return portalNode;\n}\n/**\n * Portals the floating element into a given container element — by default,\n * outside of the app root and into the body.\n * This is necessary to ensure the floating element can appear outside any\n * potential parent containers that cause clipping (such as `overflow: hidden`),\n * while retaining its location in the React tree.\n * @see https://floating-ui.com/docs/FloatingPortal\n */\nfunction FloatingPortal(props) {\n  const {\n    children,\n    id,\n    root,\n    preserveTabOrder = true\n  } = props;\n  const portalNode = useFloatingPortalNode({\n    id,\n    root\n  });\n  const [focusManagerState, setFocusManagerState] = React.useState(null);\n  const beforeOutsideRef = React.useRef(null);\n  const afterOutsideRef = React.useRef(null);\n  const beforeInsideRef = React.useRef(null);\n  const afterInsideRef = React.useRef(null);\n  const modal = focusManagerState == null ? void 0 : focusManagerState.modal;\n  const open = focusManagerState == null ? void 0 : focusManagerState.open;\n  const shouldRenderGuards =\n  // The FocusManager and therefore floating element are currently open/\n  // rendered.\n  !!focusManagerState &&\n  // Guards are only for non-modal focus management.\n  !focusManagerState.modal &&\n  // Don't render if unmount is transitioning.\n  focusManagerState.open && preserveTabOrder && !!(root || portalNode);\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || !preserveTabOrder || modal) {\n      return;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        const focusing = event.type === 'focusin';\n        const manageFocus = focusing ? enableFocusInside : disableFocusInside;\n        manageFocus(portalNode);\n      }\n    }\n    // Listen to the event on the capture phase so they run before the focus\n    // trap elements onFocus prop is called.\n    portalNode.addEventListener('focusin', onFocus, true);\n    portalNode.addEventListener('focusout', onFocus, true);\n    return () => {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder, modal]);\n  React.useEffect(() => {\n    if (!portalNode) return;\n    if (open) return;\n    enableFocusInside(portalNode);\n  }, [open, portalNode]);\n  return /*#__PURE__*/jsxs(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode]),\n    children: [shouldRenderGuards && portalNode && /*#__PURE__*/jsx(FocusGuard, {\n      \"data-type\": \"outside\",\n      ref: beforeOutsideRef,\n      onFocus: event => {\n        if (isOutsideEvent(event, portalNode)) {\n          var _beforeInsideRef$curr;\n          (_beforeInsideRef$curr = beforeInsideRef.current) == null || _beforeInsideRef$curr.focus();\n        } else {\n          const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.domReference);\n          prevTabbable == null || prevTabbable.focus();\n        }\n      }\n    }), shouldRenderGuards && portalNode && /*#__PURE__*/jsx(\"span\", {\n      \"aria-owns\": portalNode.id,\n      style: HIDDEN_STYLES\n    }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/jsx(FocusGuard, {\n      \"data-type\": \"outside\",\n      ref: afterOutsideRef,\n      onFocus: event => {\n        if (isOutsideEvent(event, portalNode)) {\n          var _afterInsideRef$curre;\n          (_afterInsideRef$curre = afterInsideRef.current) == null || _afterInsideRef$curre.focus();\n        } else {\n          const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.domReference);\n          nextTabbable == null || nextTabbable.focus();\n          (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, event.nativeEvent, 'focus-out'));\n        }\n      }\n    })]\n  });\n}\nconst usePortalContext = () => React.useContext(PortalContext);\n\nconst FOCUSABLE_ATTRIBUTE = 'data-floating-ui-focusable';\nfunction getFloatingFocusElement(floatingElement) {\n  if (!floatingElement) {\n    return null;\n  }\n  // Try to find the element that has `{...getFloatingProps()}` spread on it.\n  // This indicates the floating element is acting as a positioning wrapper, and\n  // so focus should be managed on the child element with the event handlers and\n  // aria props.\n  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(\"[\" + FOCUSABLE_ATTRIBUTE + \"]\") || floatingElement;\n}\n\nconst LIST_LIMIT = 20;\nlet previouslyFocusedElements = [];\nfunction addPreviouslyFocusedElement(element) {\n  previouslyFocusedElements = previouslyFocusedElements.filter(el => el.isConnected);\n  if (element && getNodeName(element) !== 'body') {\n    previouslyFocusedElements.push(element);\n    if (previouslyFocusedElements.length > LIST_LIMIT) {\n      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n    }\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  return previouslyFocusedElements.slice().reverse().find(el => el.isConnected);\n}\nfunction getFirstTabbableElement(container) {\n  const tabbableOptions = getTabbableOptions();\n  if (isTabbable(container, tabbableOptions)) {\n    return container;\n  }\n  return tabbable(container, tabbableOptions)[0] || container;\n}\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/jsx(\"button\", {\n    ...props,\n    type: \"button\",\n    ref: ref,\n    tabIndex: -1,\n    style: HIDDEN_STYLES\n  });\n});\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n */\nfunction FloatingFocusManager(props) {\n  const {\n    context,\n    children,\n    disabled = false,\n    order = ['content'],\n    guards: _guards = true,\n    initialFocus = 0,\n    returnFocus = true,\n    restoreFocus = false,\n    modal = true,\n    visuallyHiddenDismiss = false,\n    closeOnFocusOut = true,\n    outsideElementsInert = false\n  } = props;\n  const {\n    open,\n    onOpenChange,\n    events,\n    dataRef,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\n  const getNodeId = useEffectEvent(() => {\n    var _dataRef$current$floa;\n    return (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;\n  });\n  const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;\n  // If the reference is a combobox and is typeable (e.g. input/textarea),\n  // there are different focus semantics. The guards should not be rendered, but\n  // aria-hidden should be applied to all nodes still. Further, the visually\n  // hidden dismiss button should only appear at the end of the list, not the\n  // start.\n  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;\n\n  // Force the guards to be rendered if the `inert` attribute is not supported.\n  const inertSupported = supportsInert();\n  const guards = inertSupported ? _guards : true;\n  const useInert = !guards || inertSupported && outsideElementsInert;\n  const orderRef = useLatestRef(order);\n  const initialFocusRef = useLatestRef(initialFocus);\n  const returnFocusRef = useLatestRef(returnFocus);\n  const tree = useFloatingTree();\n  const portalContext = usePortalContext();\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const isPointerDownRef = React.useRef(false);\n  const tabbableIndexRef = React.useRef(-1);\n  const isInsidePortal = portalContext != null;\n  const floatingFocusElement = getFloatingFocusElement(floating);\n  const getTabbableContent = useEffectEvent(function (container) {\n    if (container === void 0) {\n      container = floatingFocusElement;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  });\n  const getTabbableElements = useEffectEvent(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(type => {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floatingFocusElement && type === 'floating') {\n        return floatingFocusElement;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  });\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!modal) return;\n    function onKeyDown(event) {\n      if (event.key === 'Tab') {\n        // The focus guards have nothing to focus, so we need to stop the event.\n        if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {\n          stopEvent(event);\n        }\n        const els = getTabbableElements();\n        const target = getTarget(event);\n        if (orderRef.current[0] === 'reference' && target === domReference) {\n          stopEvent(event);\n          if (event.shiftKey) {\n            enqueueFocus(els[els.length - 1]);\n          } else {\n            enqueueFocus(els[1]);\n          }\n        }\n        if (orderRef.current[1] === 'floating' && target === floatingFocusElement && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    const doc = getDocument(floatingFocusElement);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!floating) return;\n    function handleFocusIn(event) {\n      const target = getTarget(event);\n      const tabbableContent = getTabbableContent();\n      const tabbableIndex = tabbableContent.indexOf(target);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n    }\n    floating.addEventListener('focusin', handleFocusIn);\n    return () => {\n      floating.removeEventListener('focusin', handleFocusIn);\n    };\n  }, [disabled, floating, getTabbableContent]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!closeOnFocusOut) return;\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      setTimeout(() => {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      const relatedTarget = event.relatedTarget;\n      queueMicrotask(() => {\n        const nodeId = getNodeId();\n        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute('focus-guard')) || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {\n          var _node$context, _node$context2;\n          return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);\n        }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {\n          var _node$context3, _node$context4, _node$context5;\n          return [(_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating, getFloatingFocusElement((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.floating)].includes(relatedTarget) || ((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.domReference) === relatedTarget;\n        })));\n\n        // Restore focus to the previous tabbable element index to prevent\n        // focus from being lost outside the floating tree.\n        if (restoreFocus && movedToUnrelatedNode && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {\n          // Let `FloatingPortal` effect knows that focus is still inside the\n          // floating tree.\n          if (isHTMLElement(floatingFocusElement)) {\n            floatingFocusElement.focus();\n          }\n          const prevTabbableIndex = tabbableIndexRef.current;\n          const tabbableContent = getTabbableContent();\n          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;\n          if (isHTMLElement(nodeToFocus)) {\n            nodeToFocus.focus();\n          }\n        }\n\n        // Focus did not move inside the floating tree, and there are no tabbable\n        // portal guards to handle closing.\n        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n        // Fix React 18 Strict Mode returnFocus due to double rendering.\n        relatedTarget !== getPreviouslyFocusedElement()) {\n          preventReturnFocusRef.current = true;\n          onOpenChange(false, event, 'focus-out');\n        }\n      });\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      floating.addEventListener('focusout', handleFocusOutside);\n      return () => {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId]);\n  const beforeGuardRef = React.useRef(null);\n  const afterGuardRef = React.useRef(null);\n  const mergedBeforeGuardRef = useMergeRefs([beforeGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef]);\n  const mergedAfterGuardRef = useMergeRefs([afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    if (disabled) return;\n    if (!floating) return;\n\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll(\"[\" + createAttribute('portal') + \"]\")) || []);\n    const ancestorFloatingNodes = tree && !modal ? getAncestors(tree == null ? void 0 : tree.nodesRef.current, getNodeId()).map(node => {\n      var _node$context6;\n      return (_node$context6 = node.context) == null ? void 0 : _node$context6.elements.floating;\n    }) : [];\n    const insideElements = [floating, ...portalNodes, ...ancestorFloatingNodes, startDismissButtonRef.current, endDismissButtonRef.current, beforeGuardRef.current, afterGuardRef.current, portalContext == null ? void 0 : portalContext.beforeOutsideRef.current, portalContext == null ? void 0 : portalContext.afterOutsideRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);\n    const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, !useInert, useInert) : markOthers(insideElements);\n    return () => {\n      cleanup();\n    };\n  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards, useInert, tree, getNodeId]);\n  index(() => {\n    if (disabled || !isHTMLElement(floatingFocusElement)) return;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n\n    // Wait for any layout effect state setters to execute to set `tabIndex`.\n    queueMicrotask(() => {\n      const focusableElements = getTabbableElements(floatingFocusElement);\n      const initialFocusValue = initialFocusRef.current;\n      const elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusElement;\n      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);\n      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {\n        enqueueFocus(elToFocus, {\n          preventScroll: elToFocus === floatingFocusElement\n        });\n      }\n    });\n  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef]);\n  index(() => {\n    if (disabled || !floatingFocusElement) return;\n    let preventReturnFocusScroll = false;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n    const contextData = dataRef.current;\n    let openEvent = contextData.openEvent;\n    addPreviouslyFocusedElement(previouslyFocusedElement);\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onOpenChange(_ref) {\n      let {\n        open,\n        reason,\n        event,\n        nested\n      } = _ref;\n      if (open) {\n        openEvent = event;\n      }\n      if (reason === 'escape-key' && domReference) {\n        addPreviouslyFocusedElement(domReference);\n      }\n      if (['hover', 'safe-polygon'].includes(reason) && event.type === 'mouseleave') {\n        preventReturnFocusRef.current = true;\n      }\n      if (reason !== 'outside-press') return;\n      if (nested) {\n        preventReturnFocusRef.current = false;\n        preventReturnFocusScroll = true;\n      } else {\n        preventReturnFocusRef.current = !(isVirtualClick(event) || isVirtualPointerEvent(event));\n      }\n    }\n    events.on('openchange', onOpenChange);\n    const fallbackEl = doc.createElement('span');\n    fallbackEl.setAttribute('tabindex', '-1');\n    fallbackEl.setAttribute('aria-hidden', 'true');\n    Object.assign(fallbackEl.style, HIDDEN_STYLES);\n    if (isInsidePortal && domReference) {\n      domReference.insertAdjacentElement('afterend', fallbackEl);\n    }\n    function getReturnElement() {\n      if (typeof returnFocusRef.current === 'boolean') {\n        return getPreviouslyFocusedElement() || fallbackEl;\n      }\n      return returnFocusRef.current.current || fallbackEl;\n    }\n    return () => {\n      events.off('openchange', onOpenChange);\n      const activeEl = activeElement(doc);\n      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getChildren(tree.nodesRef.current, getNodeId()).some(node => {\n        var _node$context7;\n        return contains((_node$context7 = node.context) == null ? void 0 : _node$context7.elements.floating, activeEl);\n      });\n      const shouldFocusReference = isFocusInsideFloatingTree || openEvent && ['click', 'mousedown'].includes(openEvent.type);\n      if (shouldFocusReference && domReference) {\n        addPreviouslyFocusedElement(domReference);\n      }\n      const returnElement = getReturnElement();\n      queueMicrotask(() => {\n        // This is `returnElement`, if it's tabbable, or its first tabbable child.\n        const tabbableReturnElement = getFirstTabbableElement(returnElement);\n        if (\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (\n        // If the focus moved somewhere else after mount, avoid returning focus\n        // since it likely entered a different element which should be\n        // respected: https://github.com/floating-ui/floating-ui/issues/2607\n        tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {\n          tabbableReturnElement.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n        }\n        fallbackEl.remove();\n      });\n    };\n  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, isInsidePortal, domReference, getNodeId]);\n  React.useEffect(() => {\n    // The `returnFocus` cleanup behavior is inside a microtask; ensure we\n    // wait for it to complete before resetting the flag.\n    queueMicrotask(() => {\n      preventReturnFocusRef.current = false;\n    });\n  }, [disabled]);\n\n  // Synchronize the `context` & `modal` value to the FloatingPortal context.\n  // It will decide whether or not it needs to render its own guards.\n  index(() => {\n    if (disabled) return;\n    if (!portalContext) return;\n    portalContext.setFocusManagerState({\n      modal,\n      closeOnFocusOut,\n      open,\n      onOpenChange,\n      domReference\n    });\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, onOpenChange, closeOnFocusOut, domReference]);\n  index(() => {\n    if (disabled) return;\n    if (!floatingFocusElement) return;\n    if (typeof MutationObserver !== 'function') return;\n    if (ignoreInitialFocus) return;\n    const handleMutation = () => {\n      const tabIndex = floatingFocusElement.getAttribute('tabindex');\n      const tabbableContent = getTabbableContent();\n      const activeEl = activeElement(getDocument(floating));\n      const tabbableIndex = tabbableContent.indexOf(activeEl);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n      if (orderRef.current.includes('floating') || activeEl !== domReference && tabbableContent.length === 0) {\n        if (tabIndex !== '0') {\n          floatingFocusElement.setAttribute('tabindex', '0');\n        }\n      } else if (tabIndex !== '-1') {\n        floatingFocusElement.setAttribute('tabindex', '-1');\n      }\n    };\n    handleMutation();\n    const observer = new MutationObserver(handleMutation);\n    observer.observe(floatingFocusElement, {\n      childList: true,\n      subtree: true,\n      attributes: true\n    });\n    return () => {\n      observer.disconnect();\n    };\n  }, [disabled, floating, floatingFocusElement, domReference, orderRef, getTabbableContent, ignoreInitialFocus]);\n  function renderDismissButton(location) {\n    if (disabled || !visuallyHiddenDismiss || !modal) {\n      return null;\n    }\n    return /*#__PURE__*/jsx(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: event => onOpenChange(false, event.nativeEvent),\n      children: typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss'\n    });\n  }\n  const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);\n  return /*#__PURE__*/jsxs(Fragment, {\n    children: [shouldRenderGuards && /*#__PURE__*/jsx(FocusGuard, {\n      \"data-type\": \"inside\",\n      ref: mergedBeforeGuardRef,\n      onFocus: event => {\n        if (modal) {\n          const els = getTabbableElements();\n          enqueueFocus(order[0] === 'reference' ? els[0] : els[els.length - 1]);\n        } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n          preventReturnFocusRef.current = false;\n          if (isOutsideEvent(event, portalContext.portalNode)) {\n            const nextTabbable = getNextTabbable() || domReference;\n            nextTabbable == null || nextTabbable.focus();\n          } else {\n            var _portalContext$before;\n            (_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();\n          }\n        }\n      }\n    }), !isUntrappedTypeableCombobox && renderDismissButton('start'), children, renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/jsx(FocusGuard, {\n      \"data-type\": \"inside\",\n      ref: mergedAfterGuardRef,\n      onFocus: event => {\n        if (modal) {\n          enqueueFocus(getTabbableElements()[0]);\n        } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n          if (closeOnFocusOut) {\n            preventReturnFocusRef.current = true;\n          }\n          if (isOutsideEvent(event, portalContext.portalNode)) {\n            const prevTabbable = getPreviousTabbable() || domReference;\n            prevTabbable == null || prevTabbable.focus();\n          } else {\n            var _portalContext$afterO;\n            (_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();\n          }\n        }\n      }\n    })]\n  });\n}\n\nlet lockCount = 0;\nfunction enableScrollLock() {\n  const isIOS = /iP(hone|ad|od)|iOS/.test(getPlatform());\n  const bodyStyle = document.body.style;\n  // RTL <body> scrollbar\n  const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;\n  const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';\n  const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;\n  const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.scrollX;\n  const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.scrollY;\n  bodyStyle.overflow = 'hidden';\n  if (scrollbarWidth) {\n    bodyStyle[paddingProp] = scrollbarWidth + \"px\";\n  }\n\n  // Only iOS doesn't respect `overflow: hidden` on document.body, and this\n  // technique has fewer side effects.\n  if (isIOS) {\n    var _window$visualViewpor, _window$visualViewpor2;\n    // iOS 12 does not support `visualViewport`.\n    const offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;\n    const offsetTop = ((_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetTop) || 0;\n    Object.assign(bodyStyle, {\n      position: 'fixed',\n      top: -(scrollY - Math.floor(offsetTop)) + \"px\",\n      left: -(scrollX - Math.floor(offsetLeft)) + \"px\",\n      right: '0'\n    });\n  }\n  return () => {\n    Object.assign(bodyStyle, {\n      overflow: '',\n      [paddingProp]: ''\n    });\n    if (isIOS) {\n      Object.assign(bodyStyle, {\n        position: '',\n        top: '',\n        left: '',\n        right: ''\n      });\n      window.scrollTo(scrollX, scrollY);\n    }\n  };\n}\nlet cleanup = () => {};\n\n/**\n * Provides base styling for a fixed overlay element to dim content or block\n * pointer events behind a floating element.\n * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.\n * @see https://floating-ui.com/docs/FloatingOverlay\n */\nconst FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(props, ref) {\n  const {\n    lockScroll = false,\n    ...rest\n  } = props;\n  index(() => {\n    if (!lockScroll) return;\n    lockCount++;\n    if (lockCount === 1) {\n      cleanup = enableScrollLock();\n    }\n    return () => {\n      lockCount--;\n      if (lockCount === 0) {\n        cleanup();\n      }\n    };\n  }, [lockScroll]);\n  return /*#__PURE__*/jsx(\"div\", {\n    ref: ref,\n    ...rest,\n    style: {\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      ...rest.style\n    }\n  });\n});\n\nfunction isButtonTarget(event) {\n  return isHTMLElement(event.target) && event.target.tagName === 'BUTTON';\n}\nfunction isSpaceIgnored(element) {\n  return isTypeableElement(element);\n}\n/**\n * Opens or closes the floating element when clicking the reference element.\n * @see https://floating-ui.com/docs/useClick\n */\nfunction useClick(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    elements: {\n      domReference\n    }\n  } = context;\n  const {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    keyboardHandlers = true,\n    stickIfOpen = true\n  } = props;\n  const pointerTypeRef = React.useRef();\n  const didKeyDownRef = React.useRef(false);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      pointerTypeRef.current = event.pointerType;\n    },\n    onMouseDown(event) {\n      const pointerType = pointerTypeRef.current;\n\n      // Ignore all buttons except for the \"main\" button.\n      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n      if (event.button !== 0) return;\n      if (eventOption === 'click') return;\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'mousedown' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        // Prevent stealing focus from the floating element\n        event.preventDefault();\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onClick(event) {\n      const pointerType = pointerTypeRef.current;\n      if (eventOption === 'mousedown' && pointerTypeRef.current) {\n        pointerTypeRef.current = undefined;\n        return;\n      }\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'click' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onKeyDown(event) {\n      pointerTypeRef.current = undefined;\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) {\n        return;\n      }\n      if (event.key === ' ' && !isSpaceIgnored(domReference)) {\n        // Prevent scrolling\n        event.preventDefault();\n        didKeyDownRef.current = true;\n      }\n      if (event.key === 'Enter') {\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    },\n    onKeyUp(event) {\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) {\n        return;\n      }\n      if (event.key === ' ' && didKeyDownRef.current) {\n        didKeyDownRef.current = false;\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    }\n  }), [dataRef, domReference, eventOption, ignoreMouse, keyboardHandlers, onOpenChange, open, stickIfOpen, toggle]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nfunction createVirtualElement(domElement, data) {\n  let offsetX = null;\n  let offsetY = null;\n  let isAutoUpdateEvent = false;\n  return {\n    contextElement: domElement || undefined,\n    getBoundingClientRect() {\n      var _data$dataRef$current;\n      const domRect = (domElement == null ? void 0 : domElement.getBoundingClientRect()) || {\n        width: 0,\n        height: 0,\n        x: 0,\n        y: 0\n      };\n      const isXAxis = data.axis === 'x' || data.axis === 'both';\n      const isYAxis = data.axis === 'y' || data.axis === 'both';\n      const canTrackCursorOnAutoUpdate = ['mouseenter', 'mousemove'].includes(((_data$dataRef$current = data.dataRef.current.openEvent) == null ? void 0 : _data$dataRef$current.type) || '') && data.pointerType !== 'touch';\n      let width = domRect.width;\n      let height = domRect.height;\n      let x = domRect.x;\n      let y = domRect.y;\n      if (offsetX == null && data.x && isXAxis) {\n        offsetX = domRect.x - data.x;\n      }\n      if (offsetY == null && data.y && isYAxis) {\n        offsetY = domRect.y - data.y;\n      }\n      x -= offsetX || 0;\n      y -= offsetY || 0;\n      width = 0;\n      height = 0;\n      if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {\n        width = data.axis === 'y' ? domRect.width : 0;\n        height = data.axis === 'x' ? domRect.height : 0;\n        x = isXAxis && data.x != null ? data.x : x;\n        y = isYAxis && data.y != null ? data.y : y;\n      } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {\n        height = data.axis === 'x' ? domRect.height : height;\n        width = data.axis === 'y' ? domRect.width : width;\n      }\n      isAutoUpdateEvent = true;\n      return {\n        width,\n        height,\n        x,\n        y,\n        top: y,\n        right: x + width,\n        bottom: y + height,\n        left: x\n      };\n    }\n  };\n}\nfunction isMouseBasedEvent(event) {\n  return event != null && event.clientX != null;\n}\n/**\n * Positions the floating element relative to a client point (in the viewport),\n * such as the mouse position. By default, it follows the mouse cursor.\n * @see https://floating-ui.com/docs/useClientPoint\n */\nfunction useClientPoint(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    dataRef,\n    elements: {\n      floating,\n      domReference\n    },\n    refs\n  } = context;\n  const {\n    enabled = true,\n    axis = 'both',\n    x = null,\n    y = null\n  } = props;\n  const initialRef = React.useRef(false);\n  const cleanupListenerRef = React.useRef(null);\n  const [pointerType, setPointerType] = React.useState();\n  const [reactive, setReactive] = React.useState([]);\n  const setReference = useEffectEvent((x, y) => {\n    if (initialRef.current) return;\n\n    // Prevent setting if the open event was not a mouse-like one\n    // (e.g. focus to open, then hover over the reference element).\n    // Only apply if the event exists.\n    if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {\n      return;\n    }\n    refs.setPositionReference(createVirtualElement(domReference, {\n      x,\n      y,\n      axis,\n      dataRef,\n      pointerType\n    }));\n  });\n  const handleReferenceEnterOrMove = useEffectEvent(event => {\n    if (x != null || y != null) return;\n    if (!open) {\n      setReference(event.clientX, event.clientY);\n    } else if (!cleanupListenerRef.current) {\n      // If there's no cleanup, there's no listener, but we want to ensure\n      // we add the listener if the cursor landed on the floating element and\n      // then back on the reference (i.e. it's interactive).\n      setReactive([]);\n    }\n  });\n\n  // If the pointer is a mouse-like pointer, we want to continue following the\n  // mouse even if the floating element is transitioning out. On touch\n  // devices, this is undesirable because the floating element will move to\n  // the dismissal touch point.\n  const openCheck = isMouseLikePointerType(pointerType) ? floating : open;\n  const addListener = React.useCallback(() => {\n    // Explicitly specified `x`/`y` coordinates shouldn't add a listener.\n    if (!openCheck || !enabled || x != null || y != null) return;\n    const win = getWindow(floating);\n    function handleMouseMove(event) {\n      const target = getTarget(event);\n      if (!contains(floating, target)) {\n        setReference(event.clientX, event.clientY);\n      } else {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      }\n    }\n    if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {\n      win.addEventListener('mousemove', handleMouseMove);\n      const cleanup = () => {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      };\n      cleanupListenerRef.current = cleanup;\n      return cleanup;\n    }\n    refs.setPositionReference(domReference);\n  }, [openCheck, enabled, x, y, floating, dataRef, refs, domReference, setReference]);\n  React.useEffect(() => {\n    return addListener();\n  }, [addListener, reactive]);\n  React.useEffect(() => {\n    if (enabled && !floating) {\n      initialRef.current = false;\n    }\n  }, [enabled, floating]);\n  React.useEffect(() => {\n    if (!enabled && open) {\n      initialRef.current = true;\n    }\n  }, [enabled, open]);\n  index(() => {\n    if (enabled && (x != null || y != null)) {\n      initialRef.current = false;\n      setReference(x, y);\n    }\n  }, [enabled, x, y, setReference]);\n  const reference = React.useMemo(() => {\n    function setPointerTypeRef(_ref) {\n      let {\n        pointerType\n      } = _ref;\n      setPointerType(pointerType);\n    }\n    return {\n      onPointerDown: setPointerTypeRef,\n      onPointerEnter: setPointerTypeRef,\n      onMouseMove: handleReferenceEnterOrMove,\n      onMouseEnter: handleReferenceEnterOrMove\n    };\n  }, [handleReferenceEnterOrMove]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst bubbleHandlerKeys = {\n  pointerdown: 'onPointerDown',\n  mousedown: 'onMouseDown',\n  click: 'onClick'\n};\nconst captureHandlerKeys = {\n  pointerdown: 'onPointerDownCapture',\n  mousedown: 'onMouseDownCapture',\n  click: 'onClickCapture'\n};\nconst normalizeProp = normalizable => {\n  var _normalizable$escapeK, _normalizable$outside;\n  return {\n    escapeKey: typeof normalizable === 'boolean' ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,\n    outsidePress: typeof normalizable === 'boolean' ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true\n  };\n};\n/**\n * Closes the floating element when a dismissal is requested — by default, when\n * the user presses the `escape` key or outside of the floating element.\n * @see https://floating-ui.com/docs/useDismiss\n */\nfunction useDismiss(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    elements,\n    dataRef\n  } = context;\n  const {\n    enabled = true,\n    escapeKey = true,\n    outsidePress: unstable_outsidePress = true,\n    outsidePressEvent = 'pointerdown',\n    referencePress = false,\n    referencePressEvent = 'pointerdown',\n    ancestorScroll = false,\n    bubbles,\n    capture\n  } = props;\n  const tree = useFloatingTree();\n  const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);\n  const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;\n  const insideReactTreeRef = React.useRef(false);\n  const endedOrStartedInsideRef = React.useRef(false);\n  const {\n    escapeKey: escapeKeyBubbles,\n    outsidePress: outsidePressBubbles\n  } = normalizeProp(bubbles);\n  const {\n    escapeKey: escapeKeyCapture,\n    outsidePress: outsidePressCapture\n  } = normalizeProp(capture);\n  const isComposingRef = React.useRef(false);\n  const closeOnEscapeKeyDown = useEffectEvent(event => {\n    var _dataRef$current$floa;\n    if (!open || !enabled || !escapeKey || event.key !== 'Escape') {\n      return;\n    }\n\n    // Wait until IME is settled. Pressing `Escape` while composing should\n    // close the compose menu, but not the floating element.\n    if (isComposingRef.current) {\n      return;\n    }\n    const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (!escapeKeyBubbles) {\n      event.stopPropagation();\n      if (children.length > 0) {\n        let shouldDismiss = true;\n        children.forEach(child => {\n          var _child$context;\n          if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {\n            shouldDismiss = false;\n            return;\n          }\n        });\n        if (!shouldDismiss) {\n          return;\n        }\n      }\n    }\n    onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, 'escape-key');\n  });\n  const closeOnEscapeKeyDownCapture = useEffectEvent(event => {\n    var _getTarget2;\n    const callback = () => {\n      var _getTarget;\n      closeOnEscapeKeyDown(event);\n      (_getTarget = getTarget(event)) == null || _getTarget.removeEventListener('keydown', callback);\n    };\n    (_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener('keydown', callback);\n  });\n  const closeOnPressOutside = useEffectEvent(event => {\n    var _dataRef$current$floa2;\n    // Given developers can stop the propagation of the synthetic event,\n    // we can only be confident with a positive value.\n    const insideReactTree = insideReactTreeRef.current;\n    insideReactTreeRef.current = false;\n\n    // When click outside is lazy (`click` event), handle dragging.\n    // Don't close if:\n    // - The click started inside the floating element.\n    // - The click ended inside the floating element.\n    const endedOrStartedInside = endedOrStartedInsideRef.current;\n    endedOrStartedInsideRef.current = false;\n    if (outsidePressEvent === 'click' && endedOrStartedInside) {\n      return;\n    }\n    if (insideReactTree) {\n      return;\n    }\n    if (typeof outsidePress === 'function' && !outsidePress(event)) {\n      return;\n    }\n    const target = getTarget(event);\n    const inertSelector = \"[\" + createAttribute('inert') + \"]\";\n    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);\n    let targetRootAncestor = isElement(target) ? target : null;\n    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {\n      const nextParent = getParentNode(targetRootAncestor);\n      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {\n        break;\n      }\n      targetRootAncestor = nextParent;\n    }\n\n    // Check if the click occurred on a third-party element injected after the\n    // floating element rendered.\n    if (markers.length && isElement(target) && !isRootElement(target) &&\n    // Clicked on a direct ancestor (e.g. FloatingOverlay).\n    !contains(target, elements.floating) &&\n    // If the target root element contains none of the markers, then the\n    // element was injected after the floating element rendered.\n    Array.from(markers).every(marker => !contains(targetRootAncestor, marker))) {\n      return;\n    }\n\n    // Check if the click occurred on the scrollbar\n    if (isHTMLElement(target) && floating) {\n      const lastTraversableNode = isLastTraversableNode(target);\n      const style = getComputedStyle(target);\n      const scrollRe = /auto|scroll/;\n      const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);\n      const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);\n      const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;\n      const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;\n      const isRTL = style.direction === 'rtl';\n\n      // Check click position relative to scrollbar.\n      // In some browsers it is possible to change the <body> (or window)\n      // scrollbar to the left side, but is very rare and is difficult to\n      // check for. Plus, for modal dialogs with backdrops, it is more\n      // important that the backdrop is checked but not so much the window.\n      const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);\n      const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;\n      if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {\n        return;\n      }\n    }\n    const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa2.nodeId;\n    const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n      var _node$context;\n      return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);\n    });\n    if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) {\n      return;\n    }\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (children.length > 0) {\n      let shouldDismiss = true;\n      children.forEach(child => {\n        var _child$context2;\n        if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {\n          shouldDismiss = false;\n          return;\n        }\n      });\n      if (!shouldDismiss) {\n        return;\n      }\n    }\n    onOpenChange(false, event, 'outside-press');\n  });\n  const closeOnPressOutsideCapture = useEffectEvent(event => {\n    var _getTarget4;\n    const callback = () => {\n      var _getTarget3;\n      closeOnPressOutside(event);\n      (_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);\n    };\n    (_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);\n  });\n  React.useEffect(() => {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    let compositionTimeout = -1;\n    function onScroll(event) {\n      onOpenChange(false, event, 'ancestor-scroll');\n    }\n    function handleCompositionStart() {\n      window.clearTimeout(compositionTimeout);\n      isComposingRef.current = true;\n    }\n    function handleCompositionEnd() {\n      // Safari fires `compositionend` before `keydown`, so we need to wait\n      // until the next tick to set `isComposing` to `false`.\n      // https://bugs.webkit.org/show_bug.cgi?id=165004\n      compositionTimeout = window.setTimeout(() => {\n        isComposingRef.current = false;\n      },\n      // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.\n      // Only apply to WebKit for the test to remain 0ms.\n      isWebKit() ? 5 : 0);\n    }\n    const doc = getDocument(elements.floating);\n    if (escapeKey) {\n      doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n      doc.addEventListener('compositionstart', handleCompositionStart);\n      doc.addEventListener('compositionend', handleCompositionEnd);\n    }\n    outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n    let ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(elements.domReference)) {\n        ancestors = getOverflowAncestors(elements.domReference);\n      }\n      if (isElement(elements.floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));\n      }\n      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));\n      }\n    }\n\n    // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)\n    ancestors = ancestors.filter(ancestor => {\n      var _doc$defaultView;\n      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);\n    });\n    ancestors.forEach(ancestor => {\n      ancestor.addEventListener('scroll', onScroll, {\n        passive: true\n      });\n    });\n    return () => {\n      if (escapeKey) {\n        doc.removeEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n        doc.removeEventListener('compositionstart', handleCompositionStart);\n        doc.removeEventListener('compositionend', handleCompositionEnd);\n      }\n      outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n      ancestors.forEach(ancestor => {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n      window.clearTimeout(compositionTimeout);\n    };\n  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);\n  React.useEffect(() => {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  const reference = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    ...(referencePress && {\n      [bubbleHandlerKeys[referencePressEvent]]: event => {\n        onOpenChange(false, event.nativeEvent, 'reference-press');\n      },\n      ...(referencePressEvent !== 'click' && {\n        onClick(event) {\n          onOpenChange(false, event.nativeEvent, 'reference-press');\n        }\n      })\n    })\n  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);\n  const floating = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    onMouseDown() {\n      endedOrStartedInsideRef.current = true;\n    },\n    onMouseUp() {\n      endedOrStartedInsideRef.current = true;\n    },\n    [captureHandlerKeys[outsidePressEvent]]: () => {\n      insideReactTreeRef.current = true;\n    }\n  }), [closeOnEscapeKeyDown, outsidePressEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction useFloatingRootContext(options) {\n  const {\n    open = false,\n    onOpenChange: onOpenChangeProp,\n    elements: elementsProp\n  } = options;\n  const floatingId = useId();\n  const dataRef = React.useRef({});\n  const [events] = React.useState(() => createPubSub());\n  const nested = useFloatingParentNodeId() != null;\n  if (process.env.NODE_ENV !== \"production\") {\n    const optionDomReference = elementsProp.reference;\n    if (optionDomReference && !isElement(optionDomReference)) {\n      error('Cannot pass a virtual element to the `elements.reference` option,', 'as it must be a real DOM element. Use `refs.setPositionReference()`', 'instead.');\n    }\n  }\n  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);\n  const onOpenChange = useEffectEvent((open, event, reason) => {\n    dataRef.current.openEvent = open ? event : undefined;\n    events.emit('openchange', {\n      open,\n      event,\n      reason,\n      nested\n    });\n    onOpenChangeProp == null || onOpenChangeProp(open, event, reason);\n  });\n  const refs = React.useMemo(() => ({\n    setPositionReference\n  }), []);\n  const elements = React.useMemo(() => ({\n    reference: positionReference || elementsProp.reference || null,\n    floating: elementsProp.floating || null,\n    domReference: elementsProp.reference\n  }), [positionReference, elementsProp.reference, elementsProp.floating]);\n  return React.useMemo(() => ({\n    dataRef,\n    open,\n    onOpenChange,\n    elements,\n    events,\n    floatingId,\n    refs\n  }), [open, onOpenChange, elements, events, floatingId, refs]);\n}\n\n/**\n * Provides data to position a floating element and context to add interactions.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    nodeId\n  } = options;\n  const internalRootContext = useFloatingRootContext({\n    ...options,\n    elements: {\n      reference: null,\n      floating: null,\n      ...options.elements\n    }\n  });\n  const rootContext = options.rootContext || internalRootContext;\n  const computedElements = rootContext.elements;\n  const [_domReference, setDomReference] = React.useState(null);\n  const [positionReference, _setPositionReference] = React.useState(null);\n  const optionDomReference = computedElements == null ? void 0 : computedElements.domReference;\n  const domReference = optionDomReference || _domReference;\n  const domReferenceRef = React.useRef(null);\n  const tree = useFloatingTree();\n  index(() => {\n    if (domReference) {\n      domReferenceRef.current = domReference;\n    }\n  }, [domReference]);\n  const position = useFloating$1({\n    ...options,\n    elements: {\n      ...computedElements,\n      ...(positionReference && {\n        reference: positionReference\n      })\n    }\n  });\n  const setPositionReference = React.useCallback(node => {\n    const computedPositionReference = isElement(node) ? {\n      getBoundingClientRect: () => node.getBoundingClientRect(),\n      contextElement: node\n    } : node;\n    // Store the positionReference in state if the DOM reference is specified externally via the\n    // `elements.reference` option. This ensures that it won't be overridden on future renders.\n    _setPositionReference(computedPositionReference);\n    position.refs.setReference(computedPositionReference);\n  }, [position.refs]);\n  const setReference = React.useCallback(node => {\n    if (isElement(node) || node === null) {\n      domReferenceRef.current = node;\n      setDomReference(node);\n    }\n\n    // Backwards-compatibility for passing a virtual element to `reference`\n    // after it has set the DOM reference.\n    if (isElement(position.refs.reference.current) || position.refs.reference.current === null ||\n    // Don't allow setting virtual elements using the old technique back to\n    // `null` to support `positionReference` + an unstable `reference`\n    // callback ref.\n    node !== null && !isElement(node)) {\n      position.refs.setReference(node);\n    }\n  }, [position.refs]);\n  const refs = React.useMemo(() => ({\n    ...position.refs,\n    setReference,\n    setPositionReference,\n    domReference: domReferenceRef\n  }), [position.refs, setReference, setPositionReference]);\n  const elements = React.useMemo(() => ({\n    ...position.elements,\n    domReference: domReference\n  }), [position.elements, domReference]);\n  const context = React.useMemo(() => ({\n    ...position,\n    ...rootContext,\n    refs,\n    elements,\n    nodeId\n  }), [position, refs, elements, nodeId, rootContext]);\n  index(() => {\n    rootContext.dataRef.current.floatingContext = context;\n    const node = tree == null ? void 0 : tree.nodesRef.current.find(node => node.id === nodeId);\n    if (node) {\n      node.context = context;\n    }\n  });\n  return React.useMemo(() => ({\n    ...position,\n    context,\n    refs,\n    elements\n  }), [position, refs, elements, context]);\n}\n\n/**\n * Opens the floating element while the reference element has focus, like CSS\n * `:focus`.\n * @see https://floating-ui.com/docs/useFocus\n */\nfunction useFocus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    events,\n    dataRef,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    visibleOnly = true\n  } = props;\n  const blockFocusRef = React.useRef(false);\n  const timeoutRef = React.useRef();\n  const keyboardModalityRef = React.useRef(true);\n  React.useEffect(() => {\n    if (!enabled) return;\n    const win = getWindow(elements.domReference);\n\n    // If the reference was focused and the user left the tab/window, and the\n    // floating element was not open, the focus should be blocked when they\n    // return to the tab/window.\n    function onBlur() {\n      if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) {\n        blockFocusRef.current = true;\n      }\n    }\n    function onKeyDown() {\n      keyboardModalityRef.current = true;\n    }\n    win.addEventListener('blur', onBlur);\n    win.addEventListener('keydown', onKeyDown, true);\n    return () => {\n      win.removeEventListener('blur', onBlur);\n      win.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [elements.domReference, open, enabled]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        reason\n      } = _ref;\n      if (reason === 'reference-press' || reason === 'escape-key') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [events, enabled]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      if (isVirtualPointerEvent(event.nativeEvent)) return;\n      keyboardModalityRef.current = false;\n    },\n    onMouseLeave() {\n      blockFocusRef.current = false;\n    },\n    onFocus(event) {\n      if (blockFocusRef.current) return;\n      const target = getTarget(event.nativeEvent);\n      if (visibleOnly && isElement(target)) {\n        try {\n          // Mac Safari unreliably matches `:focus-visible` on the reference\n          // if focus was outside the page initially - use the fallback\n          // instead.\n          if (isSafari() && isMac()) throw Error();\n          if (!target.matches(':focus-visible')) return;\n        } catch (e) {\n          // Old browsers will throw an error when using `:focus-visible`.\n          if (!keyboardModalityRef.current && !isTypeableElement(target)) {\n            return;\n          }\n        }\n      }\n      onOpenChange(true, event.nativeEvent, 'focus');\n    },\n    onBlur(event) {\n      blockFocusRef.current = false;\n      const relatedTarget = event.relatedTarget;\n      const nativeEvent = event.nativeEvent;\n\n      // Hit the non-modal focus management portal guard. Focus will be\n      // moved into the floating element immediately after.\n      const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';\n\n      // Wait for the window blur listener to fire.\n      timeoutRef.current = window.setTimeout(() => {\n        var _dataRef$current$floa;\n        const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);\n\n        // Focus left the page, keep it open.\n        if (!relatedTarget && activeEl === elements.domReference) return;\n\n        // When focusing the reference element (e.g. regular click), then\n        // clicking into the floating element, prevent it from hiding.\n        // Note: it must be focusable, e.g. `tabindex=\"-1\"`.\n        // We can not rely on relatedTarget to point to the correct element\n        // as it will only point to the shadow host of the newly focused element\n        // and not the element that actually has received focus if it is located\n        // inside a shadow root.\n        if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) {\n          return;\n        }\n        onOpenChange(false, nativeEvent, 'focus');\n      });\n    }\n  }), [dataRef, elements.domReference, onOpenChange, visibleOnly]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst ACTIVE_KEY = 'active';\nconst SELECTED_KEY = 'selected';\nfunction mergeProps(userProps, propsList, elementKey) {\n  const map = new Map();\n  const isItem = elementKey === 'item';\n  let domUserProps = userProps;\n  if (isItem && userProps) {\n    const {\n      [ACTIVE_KEY]: _,\n      [SELECTED_KEY]: __,\n      ...validProps\n    } = userProps;\n    domUserProps = validProps;\n  }\n  return {\n    ...(elementKey === 'floating' && {\n      tabIndex: -1,\n      [FOCUSABLE_ATTRIBUTE]: ''\n    }),\n    ...domUserProps,\n    ...propsList.map(value => {\n      const propsOrGetProps = value ? value[elementKey] : null;\n      if (typeof propsOrGetProps === 'function') {\n        return userProps ? propsOrGetProps(userProps) : null;\n      }\n      return propsOrGetProps;\n    }).concat(userProps).reduce((acc, props) => {\n      if (!props) {\n        return acc;\n      }\n      Object.entries(props).forEach(_ref => {\n        let [key, value] = _ref;\n        if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {\n          return;\n        }\n        if (key.indexOf('on') === 0) {\n          if (!map.has(key)) {\n            map.set(key, []);\n          }\n          if (typeof value === 'function') {\n            var _map$get;\n            (_map$get = map.get(key)) == null || _map$get.push(value);\n            acc[key] = function () {\n              var _map$get2;\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map(fn => fn(...args)).find(val => val !== undefined);\n            };\n          }\n        } else {\n          acc[key] = value;\n        }\n      });\n      return acc;\n    }, {})\n  };\n}\n/**\n * Merges an array of interaction hooks' props into prop getters, allowing\n * event handler functions to be composed together without overwriting one\n * another.\n * @see https://floating-ui.com/docs/useInteractions\n */\nfunction useInteractions(propsList) {\n  if (propsList === void 0) {\n    propsList = [];\n  }\n  const referenceDeps = propsList.map(key => key == null ? void 0 : key.reference);\n  const floatingDeps = propsList.map(key => key == null ? void 0 : key.floating);\n  const itemDeps = propsList.map(key => key == null ? void 0 : key.item);\n  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  referenceDeps);\n  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  floatingDeps);\n  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  itemDeps);\n  return React.useMemo(() => ({\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps\n  }), [getReferenceProps, getFloatingProps, getItemProps]);\n}\n\nfunction doSwitch(orientation, vertical, horizontal) {\n  switch (orientation) {\n    case 'vertical':\n      return vertical;\n    case 'horizontal':\n      return horizontal;\n    default:\n      return vertical || horizontal;\n  }\n}\nfunction isMainOrientationKey(key, orientation) {\n  const vertical = key === ARROW_UP || key === ARROW_DOWN;\n  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isMainOrientationToEndKey(key, orientation, rtl) {\n  const vertical = key === ARROW_DOWN;\n  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal) || key === 'Enter' || key === ' ' || key === '';\n}\nfunction isCrossOrientationOpenKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  const horizontal = key === ARROW_DOWN;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isCrossOrientationCloseKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;\n  const horizontal = key === ARROW_UP;\n  return doSwitch(orientation, vertical, horizontal);\n}\n/**\n * Adds arrow key-based navigation of a list of items, either using real DOM\n * focus or virtual focus.\n * @see https://floating-ui.com/docs/useListNavigation\n */\nfunction useListNavigation(context, props) {\n  const {\n    open,\n    onOpenChange,\n    elements\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onNavigate: unstable_onNavigate = () => {},\n    enabled = true,\n    selectedIndex = null,\n    allowEscape = false,\n    loop = false,\n    nested = false,\n    rtl = false,\n    virtual = false,\n    focusItemOnOpen = 'auto',\n    focusItemOnHover = true,\n    openOnArrowKeyDown = true,\n    disabledIndices = undefined,\n    orientation = 'vertical',\n    cols = 1,\n    scrollItemIntoView = true,\n    virtualItemRef,\n    itemSizes,\n    dense = false\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        warn('`useListNavigation` looping must be enabled to allow escaping.');\n      }\n      if (!virtual) {\n        warn('`useListNavigation` must be virtual to allow escaping.');\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      warn('In grid list navigation mode (`cols` > 1), the `orientation` should', 'be either \"horizontal\" or \"both\".');\n    }\n  }\n  const floatingFocusElement = getFloatingFocusElement(elements.floating);\n  const floatingFocusElementRef = useLatestRef(floatingFocusElement);\n  const parentId = useFloatingParentNodeId();\n  const tree = useFloatingTree();\n  const onNavigate = useEffectEvent(() => {\n    unstable_onNavigate(indexRef.current === -1 ? null : indexRef.current);\n  });\n  const typeableComboboxReference = isTypeableCombobox(elements.domReference);\n  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);\n  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);\n  const keyRef = React.useRef(null);\n  const isPointerModalityRef = React.useRef(true);\n  const previousOnNavigateRef = React.useRef(onNavigate);\n  const previousMountedRef = React.useRef(!!elements.floating);\n  const previousOpenRef = React.useRef(open);\n  const forceSyncFocusRef = React.useRef(false);\n  const forceScrollIntoViewRef = React.useRef(false);\n  const disabledIndicesRef = useLatestRef(disabledIndices);\n  const latestOpenRef = useLatestRef(open);\n  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  const selectedIndexRef = useLatestRef(selectedIndex);\n  const [activeId, setActiveId] = React.useState();\n  const [virtualId, setVirtualId] = React.useState();\n  const focusItem = useEffectEvent(() => {\n    function runFocus(item) {\n      if (virtual) {\n        setActiveId(item.id);\n        tree == null || tree.events.emit('virtualfocus', item);\n        if (virtualItemRef) {\n          virtualItemRef.current = item;\n        }\n      } else {\n        enqueueFocus(item, {\n          sync: forceSyncFocusRef.current,\n          preventScroll: true\n        });\n      }\n    }\n    const initialItem = listRef.current[indexRef.current];\n    if (initialItem) {\n      runFocus(initialItem);\n    }\n    const scheduler = forceSyncFocusRef.current ? v => v() : requestAnimationFrame;\n    scheduler(() => {\n      const waitedItem = listRef.current[indexRef.current] || initialItem;\n      if (!waitedItem) return;\n      if (!initialItem) {\n        runFocus(waitedItem);\n      }\n      const scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoViewRef.current || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        waitedItem.scrollIntoView == null || waitedItem.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\n      }\n    });\n  });\n\n  // Sync `selectedIndex` to be the `activeIndex` upon opening the floating\n  // element. Also, reset `activeIndex` upon closing the floating element.\n  index(() => {\n    if (!enabled) return;\n    if (open && elements.floating) {\n      if (focusItemOnOpenRef.current && selectedIndex != null) {\n        // Regardless of the pointer modality, we want to ensure the selected\n        // item comes into view when the floating element is opened.\n        forceScrollIntoViewRef.current = true;\n        indexRef.current = selectedIndex;\n        onNavigate();\n      }\n    } else if (previousMountedRef.current) {\n      // Since the user can specify `onNavigate` conditionally\n      // (onNavigate: open ? setActiveIndex : setSelectedIndex),\n      // we store and call the previous function.\n      indexRef.current = -1;\n      previousOnNavigateRef.current();\n    }\n  }, [enabled, open, elements.floating, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(() => {\n    if (!enabled) return;\n    if (!open) return;\n    if (!elements.floating) return;\n    if (activeIndex == null) {\n      forceSyncFocusRef.current = false;\n      if (selectedIndexRef.current != null) {\n        return;\n      }\n\n      // Reset while the floating element was open (e.g. the list changed).\n      if (previousMountedRef.current) {\n        indexRef.current = -1;\n        focusItem();\n      }\n\n      // Initial sync.\n      if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n        let runs = 0;\n        const waitForListPopulated = () => {\n          if (listRef.current[0] == null) {\n            // Avoid letting the browser paint if possible on the first try,\n            // otherwise use rAF. Don't try more than twice, since something\n            // is wrong otherwise.\n            if (runs < 2) {\n              const scheduler = runs ? requestAnimationFrame : queueMicrotask;\n              scheduler(waitForListPopulated);\n            }\n            runs++;\n          } else {\n            indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);\n            keyRef.current = null;\n            onNavigate();\n          }\n        };\n        waitForListPopulated();\n      }\n    } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n      indexRef.current = activeIndex;\n      focusItem();\n      forceScrollIntoViewRef.current = false;\n    }\n  }, [enabled, open, elements.floating, activeIndex, selectedIndexRef, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);\n\n  // Ensure the parent floating element has focus when a nested child closes\n  // to allow arrow key navigation to work after the pointer leaves the child.\n  index(() => {\n    var _nodes$find;\n    if (!enabled || elements.floating || !tree || virtual || !previousMountedRef.current) {\n      return;\n    }\n    const nodes = tree.nodesRef.current;\n    const parent = (_nodes$find = nodes.find(node => node.id === parentId)) == null || (_nodes$find = _nodes$find.context) == null ? void 0 : _nodes$find.elements.floating;\n    const activeEl = activeElement(getDocument(elements.floating));\n    const treeContainsActiveEl = nodes.some(node => node.context && contains(node.context.elements.floating, activeEl));\n    if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {\n      parent.focus({\n        preventScroll: true\n      });\n    }\n  }, [enabled, elements.floating, tree, parentId, virtual]);\n  index(() => {\n    if (!enabled) return;\n    if (!tree) return;\n    if (!virtual) return;\n    if (parentId) return;\n    function handleVirtualFocus(item) {\n      setVirtualId(item.id);\n      if (virtualItemRef) {\n        virtualItemRef.current = item;\n      }\n    }\n    tree.events.on('virtualfocus', handleVirtualFocus);\n    return () => {\n      tree.events.off('virtualfocus', handleVirtualFocus);\n    };\n  }, [enabled, tree, virtual, parentId, virtualItemRef]);\n  index(() => {\n    previousOnNavigateRef.current = onNavigate;\n    previousOpenRef.current = open;\n    previousMountedRef.current = !!elements.floating;\n  });\n  index(() => {\n    if (!open) {\n      keyRef.current = null;\n    }\n  }, [open]);\n  const hasActiveIndex = activeIndex != null;\n  const item = React.useMemo(() => {\n    function syncCurrentTarget(currentTarget) {\n      if (!open) return;\n      const index = listRef.current.indexOf(currentTarget);\n      if (index !== -1 && indexRef.current !== index) {\n        indexRef.current = index;\n        onNavigate();\n      }\n    }\n    const props = {\n      onFocus(_ref) {\n        let {\n          currentTarget\n        } = _ref;\n        forceSyncFocusRef.current = true;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: _ref2 => {\n        let {\n          currentTarget\n        } = _ref2;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      },\n      // Safari\n      ...(focusItemOnHover && {\n        onMouseMove(_ref3) {\n          let {\n            currentTarget\n          } = _ref3;\n          forceSyncFocusRef.current = true;\n          forceScrollIntoViewRef.current = false;\n          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave(_ref4) {\n          let {\n            pointerType\n          } = _ref4;\n          if (!isPointerModalityRef.current || pointerType === 'touch') {\n            return;\n          }\n          forceSyncFocusRef.current = true;\n          indexRef.current = -1;\n          onNavigate();\n          if (!virtual) {\n            var _floatingFocusElement;\n            (_floatingFocusElement = floatingFocusElementRef.current) == null || _floatingFocusElement.focus({\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, floatingFocusElementRef, focusItemOnHover, listRef, onNavigate, virtual]);\n  const commonOnKeyDown = useEffectEvent(event => {\n    isPointerModalityRef.current = false;\n    forceSyncFocusRef.current = true;\n\n    // When composing a character, Chrome fires ArrowDown twice. Firefox/Safari\n    // don't appear to suffer from this. `event.isComposing` is avoided due to\n    // Safari not supporting it properly (although it's not needed in the first\n    // place for Safari, just avoiding any possible issues).\n    if (event.which === 229) {\n      return;\n    }\n\n    // If the floating element is animating out, ignore navigation. Otherwise,\n    // the `activeIndex` gets set to 0 despite not being open so the next time\n    // the user ArrowDowns, the first item won't be focused.\n    if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) {\n      return;\n    }\n    if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n      stopEvent(event);\n      onOpenChange(false, event.nativeEvent, 'list-navigation');\n      if (isHTMLElement(elements.domReference)) {\n        if (virtual) {\n          tree == null || tree.events.emit('virtualfocus', elements.domReference);\n        } else {\n          elements.domReference.focus();\n        }\n      }\n      return;\n    }\n    const currentIndex = indexRef.current;\n    const minIndex = getMinIndex(listRef, disabledIndices);\n    const maxIndex = getMaxIndex(listRef, disabledIndices);\n    if (!typeableComboboxReference) {\n      if (event.key === 'Home') {\n        stopEvent(event);\n        indexRef.current = minIndex;\n        onNavigate();\n      }\n      if (event.key === 'End') {\n        stopEvent(event);\n        indexRef.current = maxIndex;\n        onNavigate();\n      }\n    }\n\n    // Grid navigation.\n    if (cols > 1) {\n      const sizes = itemSizes || Array.from({\n        length: listRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(listRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(listRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const index = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex != null ? listRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || listRef.current.map((_, index) => isDisabled(listRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(indexRef.current > maxIndex ? minIndex : indexRef.current, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction\n        // we're moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT) ? 'tr' : 'tl'),\n        stopEvent: true\n      })];\n      if (index != null) {\n        indexRef.current = index;\n        onNavigate();\n      }\n      if (orientation === 'both') {\n        return;\n      }\n    }\n    if (isMainOrientationKey(event.key, orientation)) {\n      stopEvent(event);\n\n      // Reset the index if no item is focused.\n      if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {\n        indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;\n        onNavigate();\n        return;\n      }\n      if (isMainOrientationToEndKey(event.key, orientation, rtl)) {\n        if (loop) {\n          indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          }));\n        }\n      } else {\n        if (loop) {\n          indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          }));\n        }\n      }\n      if (isIndexOutOfBounds(listRef, indexRef.current)) {\n        indexRef.current = -1;\n      }\n      onNavigate();\n    }\n  });\n  const ariaActiveDescendantProp = React.useMemo(() => {\n    return virtual && open && hasActiveIndex && {\n      'aria-activedescendant': virtualId || activeId\n    };\n  }, [virtual, open, hasActiveIndex, virtualId, activeId]);\n  const floating = React.useMemo(() => {\n    return {\n      'aria-orientation': orientation === 'both' ? undefined : orientation,\n      ...(!typeableComboboxReference ? ariaActiveDescendantProp : {}),\n      onKeyDown: commonOnKeyDown,\n      onPointerMove() {\n        isPointerModalityRef.current = true;\n      }\n    };\n  }, [ariaActiveDescendantProp, commonOnKeyDown, orientation, typeableComboboxReference]);\n  const reference = React.useMemo(() => {\n    function checkVirtualMouse(event) {\n      if (focusItemOnOpen === 'auto' && isVirtualClick(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    function checkVirtualPointer(event) {\n      // `pointerdown` fires first, reset the state then perform the checks.\n      focusItemOnOpenRef.current = focusItemOnOpen;\n      if (focusItemOnOpen === 'auto' && isVirtualPointerEvent(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    return {\n      ...ariaActiveDescendantProp,\n      onKeyDown(event) {\n        isPointerModalityRef.current = false;\n        const isArrowKey = event.key.startsWith('Arrow');\n        const isHomeOrEndKey = ['Home', 'End'].includes(event.key);\n        const isMoveKey = isArrowKey || isHomeOrEndKey;\n        const isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl);\n        const isCrossCloseKey = isCrossOrientationCloseKey(event.key, orientation, rtl);\n        const isMainKey = isMainOrientationKey(event.key, orientation);\n        const isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === 'Enter' || event.key.trim() === '';\n        if (virtual && open) {\n          const rootNode = tree == null ? void 0 : tree.nodesRef.current.find(node => node.parentId == null);\n          const deepestNode = tree && rootNode ? getDeepestNode(tree.nodesRef.current, rootNode.id) : null;\n          if (isMoveKey && deepestNode && virtualItemRef) {\n            const eventObject = new KeyboardEvent('keydown', {\n              key: event.key,\n              bubbles: true\n            });\n            if (isCrossOpenKey || isCrossCloseKey) {\n              var _deepestNode$context, _deepestNode$context2;\n              const isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;\n              const dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? listRef.current.find(item => (item == null ? void 0 : item.id) === activeId) : null;\n              if (dispatchItem) {\n                stopEvent(event);\n                dispatchItem.dispatchEvent(eventObject);\n                setVirtualId(undefined);\n              }\n            }\n            if ((isMainKey || isHomeOrEndKey) && deepestNode.context) {\n              if (deepestNode.context.open && deepestNode.parentId && event.currentTarget !== deepestNode.context.elements.domReference) {\n                var _deepestNode$context$;\n                stopEvent(event);\n                (_deepestNode$context$ = deepestNode.context.elements.domReference) == null || _deepestNode$context$.dispatchEvent(eventObject);\n                return;\n              }\n            }\n          }\n          return commonOnKeyDown(event);\n        }\n\n        // If a floating element should not open on arrow key down, avoid\n        // setting `activeIndex` while it's closed.\n        if (!open && !openOnArrowKeyDown && isArrowKey) {\n          return;\n        }\n        if (isNavigationKey) {\n          keyRef.current = nested && isMainKey ? null : event.key;\n        }\n        if (nested) {\n          if (isCrossOpenKey) {\n            stopEvent(event);\n            if (open) {\n              indexRef.current = getMinIndex(listRef, disabledIndicesRef.current);\n              onNavigate();\n            } else {\n              onOpenChange(true, event.nativeEvent, 'list-navigation');\n            }\n          }\n          return;\n        }\n        if (isMainKey) {\n          if (selectedIndex != null) {\n            indexRef.current = selectedIndex;\n          }\n          stopEvent(event);\n          if (!open && openOnArrowKeyDown) {\n            onOpenChange(true, event.nativeEvent, 'list-navigation');\n          } else {\n            commonOnKeyDown(event);\n          }\n          if (open) {\n            onNavigate();\n          }\n        }\n      },\n      onFocus() {\n        if (open && !virtual) {\n          indexRef.current = -1;\n          onNavigate();\n        }\n      },\n      onPointerDown: checkVirtualPointer,\n      onPointerEnter: checkVirtualPointer,\n      onMouseDown: checkVirtualMouse,\n      onClick: checkVirtualMouse\n    };\n  }, [activeId, ariaActiveDescendantProp, commonOnKeyDown, disabledIndicesRef, focusItemOnOpen, listRef, nested, onNavigate, onOpenChange, open, openOnArrowKeyDown, orientation, rtl, selectedIndex, tree, virtual, virtualItemRef]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\nconst componentRoleToAriaRoleMap = /*#__PURE__*/new Map([['select', 'listbox'], ['combobox', 'listbox'], ['label', false]]);\n\n/**\n * Adds base screen reader props to the reference and floating elements for a\n * given floating element `role`.\n * @see https://floating-ui.com/docs/useRole\n */\nfunction useRole(context, props) {\n  var _componentRoleToAriaR;\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    floatingId\n  } = context;\n  const {\n    enabled = true,\n    role = 'dialog'\n  } = props;\n  const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;\n  const referenceId = useId();\n  const parentId = useFloatingParentNodeId();\n  const isNested = parentId != null;\n  const reference = React.useMemo(() => {\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return {\n        [\"aria-\" + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined\n      };\n    }\n    return {\n      'aria-expanded': open ? 'true' : 'false',\n      'aria-haspopup': ariaRole === 'alertdialog' ? 'dialog' : ariaRole,\n      'aria-controls': open ? floatingId : undefined,\n      ...(ariaRole === 'listbox' && {\n        role: 'combobox'\n      }),\n      ...(ariaRole === 'menu' && {\n        id: referenceId\n      }),\n      ...(ariaRole === 'menu' && isNested && {\n        role: 'menuitem'\n      }),\n      ...(role === 'select' && {\n        'aria-autocomplete': 'none'\n      }),\n      ...(role === 'combobox' && {\n        'aria-autocomplete': 'list'\n      })\n    };\n  }, [ariaRole, floatingId, isNested, open, referenceId, role]);\n  const floating = React.useMemo(() => {\n    const floatingProps = {\n      id: floatingId,\n      ...(ariaRole && {\n        role: ariaRole\n      })\n    };\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return floatingProps;\n    }\n    return {\n      ...floatingProps,\n      ...(ariaRole === 'menu' && {\n        'aria-labelledby': referenceId\n      })\n    };\n  }, [ariaRole, floatingId, referenceId, role]);\n  const item = React.useCallback(_ref => {\n    let {\n      active,\n      selected\n    } = _ref;\n    const commonProps = {\n      role: 'option',\n      ...(active && {\n        id: floatingId + \"-option\"\n      })\n    };\n\n    // For `menu`, we are unable to tell if the item is a `menuitemradio`\n    // or `menuitemcheckbox`. For backwards-compatibility reasons, also\n    // avoid defaulting to `menuitem` as it may overwrite custom role props.\n    switch (role) {\n      case 'select':\n        return {\n          ...commonProps,\n          'aria-selected': active && selected\n        };\n      case 'combobox':\n        {\n          return {\n            ...commonProps,\n            ...(active && {\n              'aria-selected': true\n            })\n          };\n        }\n    }\n    return {};\n  }, [floatingId, role]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\n// Converts a JS style key like `backgroundColor` to a CSS transition-property\n// like `background-color`.\nconst camelCaseToKebabCase = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());\nfunction execWithArgsOrReturn(valueOrFn, args) {\n  return typeof valueOrFn === 'function' ? valueOrFn(args) : valueOrFn;\n}\nfunction useDelayUnmount(open, durationMs) {\n  const [isMounted, setIsMounted] = React.useState(open);\n  if (open && !isMounted) {\n    setIsMounted(true);\n  }\n  React.useEffect(() => {\n    if (!open && isMounted) {\n      const timeout = setTimeout(() => setIsMounted(false), durationMs);\n      return () => clearTimeout(timeout);\n    }\n  }, [open, isMounted, durationMs]);\n  return isMounted;\n}\n/**\n * Provides a status string to apply CSS transitions to a floating element,\n * correctly handling placement-aware transitions.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstatus\n */\nfunction useTransitionStatus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    elements: {\n      floating\n    }\n  } = context;\n  const {\n    duration = 250\n  } = props;\n  const isNumberDuration = typeof duration === 'number';\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [status, setStatus] = React.useState('unmounted');\n  const isMounted = useDelayUnmount(open, closeDuration);\n  if (!isMounted && status === 'close') {\n    setStatus('unmounted');\n  }\n  index(() => {\n    if (!floating) return;\n    if (open) {\n      setStatus('initial');\n      const frame = requestAnimationFrame(() => {\n        setStatus('open');\n      });\n      return () => {\n        cancelAnimationFrame(frame);\n      };\n    }\n    setStatus('close');\n  }, [open, floating]);\n  return {\n    isMounted,\n    status\n  };\n}\n/**\n * Provides styles to apply CSS transitions to a floating element, correctly\n * handling placement-aware transitions. Wrapper around `useTransitionStatus`.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstyles\n */\nfunction useTransitionStyles(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    initial: unstable_initial = {\n      opacity: 0\n    },\n    open: unstable_open,\n    close: unstable_close,\n    common: unstable_common,\n    duration = 250\n  } = props;\n  const placement = context.placement;\n  const side = placement.split('-')[0];\n  const fnArgs = React.useMemo(() => ({\n    side,\n    placement\n  }), [side, placement]);\n  const isNumberDuration = typeof duration === 'number';\n  const openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [styles, setStyles] = React.useState(() => ({\n    ...execWithArgsOrReturn(unstable_common, fnArgs),\n    ...execWithArgsOrReturn(unstable_initial, fnArgs)\n  }));\n  const {\n    isMounted,\n    status\n  } = useTransitionStatus(context, {\n    duration\n  });\n  const initialRef = useLatestRef(unstable_initial);\n  const openRef = useLatestRef(unstable_open);\n  const closeRef = useLatestRef(unstable_close);\n  const commonRef = useLatestRef(unstable_common);\n  index(() => {\n    const initialStyles = execWithArgsOrReturn(initialRef.current, fnArgs);\n    const closeStyles = execWithArgsOrReturn(closeRef.current, fnArgs);\n    const commonStyles = execWithArgsOrReturn(commonRef.current, fnArgs);\n    const openStyles = execWithArgsOrReturn(openRef.current, fnArgs) || Object.keys(initialStyles).reduce((acc, key) => {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial') {\n      setStyles(styles => ({\n        transitionProperty: styles.transitionProperty,\n        ...commonStyles,\n        ...initialStyles\n      }));\n    }\n    if (status === 'open') {\n      setStyles({\n        transitionProperty: Object.keys(openStyles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: openDuration + \"ms\",\n        ...commonStyles,\n        ...openStyles\n      });\n    }\n    if (status === 'close') {\n      const styles = closeStyles || initialStyles;\n      setStyles({\n        transitionProperty: Object.keys(styles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: closeDuration + \"ms\",\n        ...commonStyles,\n        ...styles\n      });\n    }\n  }, [closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status, fnArgs]);\n  return {\n    isMounted,\n    styles\n  };\n}\n\n/**\n * Provides a matching callback that can be used to focus an item as the user\n * types, often used in tandem with `useListNavigation()`.\n * @see https://floating-ui.com/docs/useTypeahead\n */\nfunction useTypeahead(context, props) {\n  var _ref;\n  const {\n    open,\n    dataRef\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onMatch: unstable_onMatch,\n    onTypingChange: unstable_onTypingChange,\n    enabled = true,\n    findMatch = null,\n    resetMs = 750,\n    ignoreKeys = [],\n    selectedIndex = null\n  } = props;\n  const timeoutIdRef = React.useRef();\n  const stringRef = React.useRef('');\n  const prevIndexRef = React.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);\n  const matchIndexRef = React.useRef(null);\n  const onMatch = useEffectEvent(unstable_onMatch);\n  const onTypingChange = useEffectEvent(unstable_onTypingChange);\n  const findMatchRef = useLatestRef(findMatch);\n  const ignoreKeysRef = useLatestRef(ignoreKeys);\n  index(() => {\n    if (open) {\n      clearTimeout(timeoutIdRef.current);\n      matchIndexRef.current = null;\n      stringRef.current = '';\n    }\n  }, [open]);\n  index(() => {\n    // Sync arrow key navigation but not typeahead navigation.\n    if (open && stringRef.current === '') {\n      var _ref2;\n      prevIndexRef.current = (_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1;\n    }\n  }, [open, selectedIndex, activeIndex]);\n  const setTypingChange = useEffectEvent(value => {\n    if (value) {\n      if (!dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    } else {\n      if (dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    }\n  });\n  const onKeyDown = useEffectEvent(event => {\n    function getMatchingIndex(list, orderedList, string) {\n      const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find(text => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);\n      return str ? list.indexOf(str) : -1;\n    }\n    const listContent = listRef.current;\n    if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {\n      if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) {\n        setTypingChange(false);\n      } else if (event.key === ' ') {\n        stopEvent(event);\n      }\n    }\n    if (listContent == null || ignoreKeysRef.current.includes(event.key) ||\n    // Character key.\n    event.key.length !== 1 ||\n    // Modifier key.\n    event.ctrlKey || event.metaKey || event.altKey) {\n      return;\n    }\n    if (open && event.key !== ' ') {\n      stopEvent(event);\n      setTypingChange(true);\n    }\n\n    // Bail out if the list contains a word like \"llama\" or \"aaron\". TODO:\n    // allow it in this case, too.\n    const allowRapidSuccessionOfFirstLetter = listContent.every(text => {\n      var _text$, _text$2;\n      return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;\n    });\n\n    // Allows the user to cycle through items that start with the same letter\n    // in rapid succession.\n    if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {\n      stringRef.current = '';\n      prevIndexRef.current = matchIndexRef.current;\n    }\n    stringRef.current += event.key;\n    clearTimeout(timeoutIdRef.current);\n    timeoutIdRef.current = setTimeout(() => {\n      stringRef.current = '';\n      prevIndexRef.current = matchIndexRef.current;\n      setTypingChange(false);\n    }, resetMs);\n    const prevIndex = prevIndexRef.current;\n    const index = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);\n    if (index !== -1) {\n      onMatch(index);\n      matchIndexRef.current = index;\n    } else if (event.key !== ' ') {\n      stringRef.current = '';\n      setTypingChange(false);\n    }\n  });\n  const reference = React.useMemo(() => ({\n    onKeyDown\n  }), [onKeyDown]);\n  const floating = React.useMemo(() => {\n    return {\n      onKeyDown,\n      onKeyUp(event) {\n        if (event.key === ' ') {\n          setTypingChange(false);\n        }\n      }\n    };\n  }, [onKeyDown, setTypingChange]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction getArgsWithCustomFloatingHeight(state, height) {\n  return {\n    ...state,\n    rects: {\n      ...state.rects,\n      floating: {\n        ...state.rects.floating,\n        height\n      }\n    }\n  };\n}\n/**\n * Positions the floating element such that an inner element inside of it is\n * anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n * @deprecated\n */\nconst inner = props => ({\n  name: 'inner',\n  options: props,\n  async fn(state) {\n    const {\n      listRef,\n      overflowRef,\n      onFallbackChange,\n      offset: innerOffset = 0,\n      index = 0,\n      minItemsVisible = 4,\n      referenceOverflowThreshold = 0,\n      scrollRef,\n      ...detectOverflowOptions\n    } = evaluate(props, state);\n    const {\n      rects,\n      elements: {\n        floating\n      }\n    } = state;\n    const item = listRef.current[index];\n    const scrollEl = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n\n    // Valid combinations:\n    // 1. Floating element is the scrollRef and has a border (default)\n    // 2. Floating element is not the scrollRef, floating element has a border\n    // 3. Floating element is not the scrollRef, scrollRef has a border\n    // Floating > {...getFloatingProps()} wrapper > scrollRef > items is not\n    // allowed as VoiceOver doesn't work.\n    const clientTop = floating.clientTop || scrollEl.clientTop;\n    const floatingIsBordered = floating.clientTop !== 0;\n    const scrollElIsBordered = scrollEl.clientTop !== 0;\n    const floatingIsScrollEl = floating === scrollEl;\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state.placement.startsWith('bottom')) {\n        warn('`placement` side must be \"bottom\" when using the `inner`', 'middleware.');\n      }\n    }\n    if (!item) {\n      return {};\n    }\n    const nextArgs = {\n      ...state,\n      ...(await offset(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state))\n    };\n    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, scrollEl.scrollHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    const refOverflow = await detectOverflow(nextArgs, {\n      ...detectOverflowOptions,\n      elementContext: 'reference'\n    });\n    const diffY = max(0, overflow.top);\n    const nextY = nextArgs.y + diffY;\n    const isScrollable = scrollEl.scrollHeight > scrollEl.clientHeight;\n    const rounder = isScrollable ? v => v : round;\n    const maxHeight = rounder(max(0, scrollEl.scrollHeight + (floatingIsBordered && floatingIsScrollEl || scrollElIsBordered ? clientTop * 2 : 0) - diffY - max(0, overflow.bottom)));\n    scrollEl.style.maxHeight = maxHeight + \"px\";\n    scrollEl.scrollTop = diffY;\n\n    // There is not enough space, fallback to standard anchored positioning\n    if (onFallbackChange) {\n      const shouldFallback = scrollEl.offsetHeight < item.offsetHeight * min(minItemsVisible, listRef.current.length) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold;\n      ReactDOM.flushSync(() => onFallbackChange(shouldFallback));\n    }\n    if (overflowRef) {\n      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({\n        ...nextArgs,\n        y: nextY\n      }, scrollEl.offsetHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    }\n    return {\n      y: nextY\n    };\n  }\n});\n/**\n * Changes the `inner` middleware's `offset` upon a `wheel` event to\n * expand the floating element's height, revealing more list items.\n * @see https://floating-ui.com/docs/inner\n * @deprecated\n */\nfunction useInnerOffset(context, props) {\n  const {\n    open,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    overflowRef,\n    scrollRef,\n    onChange: unstable_onChange\n  } = props;\n  const onChange = useEffectEvent(unstable_onChange);\n  const controlledScrollingRef = React.useRef(false);\n  const prevScrollTopRef = React.useRef(null);\n  const initialOverflowRef = React.useRef(null);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onWheel(e) {\n      if (e.ctrlKey || !el || overflowRef.current == null) {\n        return;\n      }\n      const dY = e.deltaY;\n      const isAtTop = overflowRef.current.top >= -0.5;\n      const isAtBottom = overflowRef.current.bottom >= -0.5;\n      const remainingScroll = el.scrollHeight - el.clientHeight;\n      const sign = dY < 0 ? -1 : 1;\n      const method = dY < 0 ? 'max' : 'min';\n      if (el.scrollHeight <= el.clientHeight) {\n        return;\n      }\n      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {\n        e.preventDefault();\n        ReactDOM.flushSync(() => {\n          onChange(d => d + Math[method](dY, remainingScroll * sign));\n        });\n      } else if (/firefox/i.test(getUserAgent())) {\n        // Needed to propagate scrolling during momentum scrolling phase once\n        // it gets limited by the boundary. UX improvement, not critical.\n        el.scrollTop += dY;\n      }\n    }\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n    if (open && el) {\n      el.addEventListener('wheel', onWheel);\n\n      // Wait for the position to be ready.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n        if (overflowRef.current != null) {\n          initialOverflowRef.current = {\n            ...overflowRef.current\n          };\n        }\n      });\n      return () => {\n        prevScrollTopRef.current = null;\n        initialOverflowRef.current = null;\n        el.removeEventListener('wheel', onWheel);\n      };\n    }\n  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);\n  const floating = React.useMemo(() => ({\n    onKeyDown() {\n      controlledScrollingRef.current = true;\n    },\n    onWheel() {\n      controlledScrollingRef.current = false;\n    },\n    onPointerMove() {\n      controlledScrollingRef.current = false;\n    },\n    onScroll() {\n      const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n      if (!overflowRef.current || !el || !controlledScrollingRef.current) {\n        return;\n      }\n      if (prevScrollTopRef.current !== null) {\n        const scrollDiff = el.scrollTop - prevScrollTopRef.current;\n        if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {\n          ReactDOM.flushSync(() => onChange(d => d + scrollDiff));\n        }\n      }\n\n      // [Firefox] Wait for the height change to have been applied.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n      });\n    }\n  }), [elements.floating, onChange, overflowRef, scrollRef]);\n  return React.useMemo(() => enabled ? {\n    floating\n  } : {}, [enabled, floating]);\n}\n\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let isInside = false;\n  const length = polygon.length;\n  for (let i = 0, j = length - 1; i < length; j = i++) {\n    const [xi, yi] = polygon[i] || [0, 0];\n    const [xj, yj] = polygon[j] || [0, 0];\n    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;\n    if (intersect) {\n      isInside = !isInside;\n    }\n  }\n  return isInside;\n}\nfunction isInside(point, rect) {\n  return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;\n}\n/**\n * Generates a safe polygon area that the user can traverse without closing the\n * floating element once leaving the reference element.\n * @see https://floating-ui.com/docs/useHover#safepolygon\n */\nfunction safePolygon(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    buffer = 0.5,\n    blockPointerEvents = false,\n    requireIntent = true\n  } = options;\n  let timeoutId;\n  let hasLanded = false;\n  let lastX = null;\n  let lastY = null;\n  let lastCursorTime = performance.now();\n  function getCursorSpeed(x, y) {\n    const currentTime = performance.now();\n    const elapsedTime = currentTime - lastCursorTime;\n    if (lastX === null || lastY === null || elapsedTime === 0) {\n      lastX = x;\n      lastY = y;\n      lastCursorTime = currentTime;\n      return null;\n    }\n    const deltaX = x - lastX;\n    const deltaY = y - lastY;\n    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n    const speed = distance / elapsedTime; // px / ms\n\n    lastX = x;\n    lastY = y;\n    lastCursorTime = currentTime;\n    return speed;\n  }\n  const fn = _ref => {\n    let {\n      x,\n      y,\n      placement,\n      elements,\n      onClose,\n      nodeId,\n      tree\n    } = _ref;\n    return function onMouseMove(event) {\n      function close() {\n        clearTimeout(timeoutId);\n        onClose();\n      }\n      clearTimeout(timeoutId);\n      if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) {\n        return;\n      }\n      const {\n        clientX,\n        clientY\n      } = event;\n      const clientPoint = [clientX, clientY];\n      const target = getTarget(event);\n      const isLeave = event.type === 'mouseleave';\n      const isOverFloatingEl = contains(elements.floating, target);\n      const isOverReferenceEl = contains(elements.domReference, target);\n      const refRect = elements.domReference.getBoundingClientRect();\n      const rect = elements.floating.getBoundingClientRect();\n      const side = placement.split('-')[0];\n      const cursorLeaveFromRight = x > rect.right - rect.width / 2;\n      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;\n      const isOverReferenceRect = isInside(clientPoint, refRect);\n      const isFloatingWider = rect.width > refRect.width;\n      const isFloatingTaller = rect.height > refRect.height;\n      const left = (isFloatingWider ? refRect : rect).left;\n      const right = (isFloatingWider ? refRect : rect).right;\n      const top = (isFloatingTaller ? refRect : rect).top;\n      const bottom = (isFloatingTaller ? refRect : rect).bottom;\n      if (isOverFloatingEl) {\n        hasLanded = true;\n        if (!isLeave) {\n          return;\n        }\n      }\n      if (isOverReferenceEl) {\n        hasLanded = false;\n      }\n      if (isOverReferenceEl && !isLeave) {\n        hasLanded = true;\n        return;\n      }\n\n      // Prevent overlapping floating element from being stuck in an open-close\n      // loop: https://github.com/floating-ui/floating-ui/issues/1910\n      if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {\n        return;\n      }\n\n      // If any nested child is open, abort.\n      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {\n        let {\n          context\n        } = _ref2;\n        return context == null ? void 0 : context.open;\n      })) {\n        return;\n      }\n\n      // If the pointer is leaving from the opposite side, the \"buffer\" logic\n      // creates a point where the floating element remains open, but should be\n      // ignored.\n      // A constant of 1 handles floating point rounding errors.\n      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {\n        return close();\n      }\n\n      // Ignore when the cursor is within the rectangular trough between the\n      // two elements. Since the triangle is created from the cursor point,\n      // which can start beyond the ref element's edge, traversing back and\n      // forth from the ref to the floating element can cause it to close. This\n      // ensures it always remains open in that case.\n      let rectPoly = [];\n      switch (side) {\n        case 'top':\n          rectPoly = [[left, refRect.top + 1], [left, rect.bottom - 1], [right, rect.bottom - 1], [right, refRect.top + 1]];\n          break;\n        case 'bottom':\n          rectPoly = [[left, rect.top + 1], [left, refRect.bottom - 1], [right, refRect.bottom - 1], [right, rect.top + 1]];\n          break;\n        case 'left':\n          rectPoly = [[rect.right - 1, bottom], [rect.right - 1, top], [refRect.left + 1, top], [refRect.left + 1, bottom]];\n          break;\n        case 'right':\n          rectPoly = [[refRect.right - 1, bottom], [refRect.right - 1, top], [rect.left + 1, top], [rect.left + 1, bottom]];\n          break;\n      }\n      function getPolygon(_ref3) {\n        let [x, y] = _ref3;\n        switch (side) {\n          case 'top':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'bottom':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'left':\n            {\n              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];\n              return [...commonPoints, cursorPointOne, cursorPointTwo];\n            }\n          case 'right':\n            {\n              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n        }\n      }\n      if (isPointInPolygon([clientX, clientY], rectPoly)) {\n        return;\n      }\n      if (hasLanded && !isOverReferenceRect) {\n        return close();\n      }\n      if (!isLeave && requireIntent) {\n        const cursorSpeed = getCursorSpeed(event.clientX, event.clientY);\n        const cursorSpeedThreshold = 0.1;\n        if (cursorSpeed !== null && cursorSpeed < cursorSpeedThreshold) {\n          return close();\n        }\n      }\n      if (!isPointInPolygon([clientX, clientY], getPolygon([x, y]))) {\n        close();\n      } else if (!hasLanded && requireIntent) {\n        timeoutId = window.setTimeout(close, 40);\n      }\n    };\n  };\n  fn.__options = {\n    blockPointerEvents\n  };\n  return fn;\n}\n\nexport { Composite, CompositeItem, FloatingArrow, FloatingDelayGroup, FloatingFocusManager, FloatingList, FloatingNode, FloatingOverlay, FloatingPortal, FloatingTree, inner, safePolygon, useClick, useClientPoint, useDelayGroup, useDelayGroupContext, useDismiss, useFloating, useFloatingNodeId, useFloatingParentNodeId, useFloatingPortalNode, useFloatingRootContext, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListItem, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };\n","import { isShadowRoot, isHTMLElement } from '@floating-ui/utils/dom';\n\nfunction activeElement(doc) {\n  let activeElement = doc.activeElement;\n  while (((_activeElement = activeElement) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {\n    var _activeElement;\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n  return activeElement;\n}\nfunction contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n\n  // then fallback to custom implementation with Shadow DOM support\n  if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    while (next) {\n      if (parent === next) {\n        return true;\n      }\n      // @ts-ignore\n      next = next.parentNode || next.host;\n    }\n  }\n\n  // Give up, the result is false\n  return false;\n}\n// Avoid Chrome DevTools blue warning.\nfunction getPlatform() {\n  const uaData = navigator.userAgentData;\n  if (uaData != null && uaData.platform) {\n    return uaData.platform;\n  }\n  return navigator.platform;\n}\nfunction getUserAgent() {\n  const uaData = navigator.userAgentData;\n  if (uaData && Array.isArray(uaData.brands)) {\n    return uaData.brands.map(_ref => {\n      let {\n        brand,\n        version\n      } = _ref;\n      return brand + \"/\" + version;\n    }).join(' ');\n  }\n  return navigator.userAgent;\n}\n\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nfunction isVirtualClick(event) {\n  // FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.\n  // Try to find a workaround for this. `react-aria` source still has the check.\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  if (isAndroid() && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nfunction isVirtualPointerEvent(event) {\n  if (isJSDOM()) return false;\n  return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse' ||\n  // iOS VoiceOver returns 0.333• for width/height.\n  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'touch';\n}\nfunction isSafari() {\n  // Chrome DevTools does not complain about navigator.vendor\n  return /apple/i.test(navigator.vendor);\n}\nfunction isAndroid() {\n  const re = /android/i;\n  return re.test(getPlatform()) || re.test(getUserAgent());\n}\nfunction isMac() {\n  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;\n}\nfunction isJSDOM() {\n  return getUserAgent().includes('jsdom/');\n}\nfunction isMouseLikePointerType(pointerType, strict) {\n  // On some Linux machines with Chromium, mouse inputs return a `pointerType`\n  // of \"pen\": https://github.com/floating-ui/floating-ui/issues/2015\n  const values = ['mouse', 'pen'];\n  if (!strict) {\n    values.push('', undefined);\n  }\n  return values.includes(pointerType);\n}\nfunction isReactEvent(event) {\n  return 'nativeEvent' in event;\n}\nfunction isRootElement(element) {\n  return element.matches('html,body');\n}\nfunction getDocument(node) {\n  return (node == null ? void 0 : node.ownerDocument) || document;\n}\nfunction isEventTargetWithin(event, node) {\n  if (node == null) {\n    return false;\n  }\n  if ('composedPath' in event) {\n    return event.composedPath().includes(node);\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't\n  const e = event;\n  return e.target != null && node.contains(e.target);\n}\nfunction getTarget(event) {\n  if ('composedPath' in event) {\n    return event.composedPath()[0];\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support\n  // `composedPath()`, but browsers without shadow DOM don't.\n  return event.target;\n}\nconst TYPEABLE_SELECTOR = \"input:not([type='hidden']):not([disabled]),\" + \"[contenteditable]:not([contenteditable='false']),textarea:not([disabled])\";\nfunction isTypeableElement(element) {\n  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);\n}\nfunction stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\nfunction isTypeableCombobox(element) {\n  if (!element) return false;\n  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);\n}\n\nexport { TYPEABLE_SELECTOR, activeElement, contains, getDocument, getPlatform, getTarget, getUserAgent, isAndroid, isEventTargetWithin, isJSDOM, isMac, isMouseLikePointerType, isReactEvent, isRootElement, isSafari, isTypeableCombobox, isTypeableElement, isVirtualClick, isVirtualPointerEvent, stopEvent };\n","function hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  // https://drafts.csswg.org/css-transforms-2/#individual-transforms\n  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n"],"names":["defaultTheme","createTheme","defaultCreateStyledComponent","systemStyled","name","slot","overridesResolver","props","styles","root","useThemePropsDefault","useThemePropsSystem","joinChildren","children","separator","childrenArray","React","toArray","filter","Boolean","reduce","output","child","index","push","length","key","style","ownerState","theme","display","flexDirection","handleBreakpoints","resolveBreakpointValues","values","direction","breakpoints","propValue","spacing","transformer","createUnarySpacing","base","Object","keys","acc","breakpoint","directionValues","spacingValues","forEach","previousDirectionValue","styleFromPropValue","useFlexGap","gap","getValue","margin","row","column","deepmerge","mergeBreakpointsInOrder","Stack","options","createStyledComponent","useThemeProps","componentName","StackRoot","inProps","ref","themeProps","extendSxProp","component","divider","className","other","classes","composeClasses","generateUtilityClass","_jsx","as","clsx","createStack","styled","useDialogClose","params","open","setOpen","handleClick","useEventCallback","event","nativeEvent","getRootProps","externalProps","mergeReactProps","onClick","DialogRootContext","undefined","useDialogRootContext","dialogRootContext","dialogContext","DialogContext","Error","customStyleHookMapping","baseMapping","transitionStatusMapping","DialogBackdrop","forwardedRef","render","nested","mounted","transitionStatus","backdropRef","state","mergedRef","useForkRef","renderElement","useComponentRenderer","extraProps","role","hidden","DialogClose","propGetter","DialogDescription","id","idProp","setDescriptionElementId","useBaseUiId","useEnhancedEffect","getProps","DialogPopupCssVars","DialogPopupDataAttributes","DialogPortalContext","hasNestedDialogs","value","DialogPopup","finalFocus","initialFocus","descriptionElementId","dismissible","floatingRootContext","getPopupProps","modal","nestedOpenDialogCount","openMethod","popupRef","setPopupElement","setPopupElementId","titleElementId","onOpenChangeComplete","internalBackdropRef","useDialogPortalContext","useOpenChangeComplete","onComplete","resolvedInitialFocus","useDialogPopup","nestedDialogs","_jsxs","InternalBackdrop","inert","FloatingFocusManager","context","disabled","closeOnFocusOut","returnFocus","DialogPortal","keepMounted","container","Provider","FloatingPortal","DialogRoot","defaultOpen","onOpenChange","parentDialogRootContext","useOptionalDialogRootContext","dialogRoot","useDialogRoot","onNestedDialogClose","onNestedDialogOpen","dialogContextValue","dialogRootContextValue","DialogTitle","setTitleElementId","DialogTrigger","setTriggerElement","getTriggerProps","triggerOpenStateMapping","parameters","idParam","handleRef","defaultInitialFocus","interactionType","tabIndex","onOpenChangeParameter","openParam","setOpenUnwrapped","useControlled","controlled","default","triggerElement","popupElement","popupElementId","setMounted","useTransitionStatus","nextOpen","reason","useScrollLock","useFloatingRootContext","elements","reference","floating","handleFloatingUIOpenChange","nativeReason","click","hover","focus","translateOpenChangeReason","ownNestedOpenDialogs","setOwnNestedOpenDialogs","isTopmost","useClick","dismiss","useDismiss","outsidePressEvent","outsidePress","target","getTarget","backdrop","current","includes","escapeKey","getReferenceProps","getFloatingProps","useInteractions","handleNestedDialogOpen","ownChildrenCount","handleNestedDialogClose","triggerProps","useOpenInteractionType","SUPPORTED_KEYS","ARROW_DOWN","ARROW_UP","ARROW_RIGHT","ARROW_LEFT","isDisabled","element","hasAttribute","useAccordionRoot","loop","onValueChange","orientation","openMultiple","valueParam","defaultValue","accordionItemRefs","setValue","handleValueChange","newValue","nextOpenValues","slice","v","nextValue","isRtl","isHorizontal","dir","onKeyDown","preventDefault","triggers","accordionItemElements","i","section","trigger","querySelector","getActiveTriggers","lastIndex","nextIndex","thisIndex","indexOf","toNext","Math","min","toPrev","AccordionRootContext","useAccordionRootContext","rootStyleHookMapping","AccordionRoot","hiddenUntilFound","hiddenUntilFoundProp","keepMountedProp","onValueChangeProp","defaultValueProp","otherProps","useDirection","accordion","NOOP","contextValue","CompositeList","elementsRef","useCollapsibleRoot","setOpenState","panelId","setPanelId","CollapsibleRootContext","useCollapsibleRootContext","AccordionItemContext","useAccordionItemContext","PANEL_OPEN_HOOK","PANEL_CLOSED_HOOK","collapsibleOpenStateMapping","accordionStyleHookMapping","Number","isInteger","String","AccordionItem","disabledProp","onOpenChangeProp","valueProp","listItemRef","useCompositeListItem","contextDisabled","rootState","openValues","isOpen","collapsible","collapsibleState","collapsibleContext","triggerId","setTriggerId","accordionItemContext","AccordionHeader","useCollapsibleTrigger","rootRef","externalRef","getButtonProps","buttonRef","useButton","focusableWhenDisabled","type","AccordionTrigger","cachedSupportsHiddenUntilFound","supportsHiddenUntilFound","supportsCssContentVisibility","CSS","supports","supportsOnBeforeMatch","ownerWindow","useCollapsiblePanel","setContextMounted","panelRef","height","width","setDimensions","latestAnimationNameRef","originalTransitionDurationStyleRef","isTransitioningRef","handlePanelRef","computedAnimationName","hasComputedStyleMapSupport","animationName","computedStyleMap","get","getComputedStyle","getAnimationNameFromComputedStyles","transitionDuration","runOnceAnimationsFinish","useAnimationsFinished","isBeforeMatchRef","isInitialOpenAnimationRef","registerCssTransitionListeners","addEventListener","handleTransitionCancel","handleTransitionEnd","handleTransitionRun","removeEventListener","frame1","frame2","isBeforeMatch","isInitialOpenAnimation","isTransitioning","originalAnimationName","originalTransitionDuration","shouldCancelAnimation","isClosed","rect","getBoundingClientRect","requestAnimationFrame","cancelAnimationFrame","useOnMount","frame3","frame","handleOnBeforeMatch","AccordionPanelCssVars","AccordionPanel","styleProp","contextHiddenUntilFound","contextKeepMounted","accordionPanelHeight","accordionPanelWidth","AlertDialogPopupDataAttributes","FieldControlDataAttributes","DEFAULT_VALIDITY_STATE","badInput","customError","patternMismatch","rangeOverflow","rangeUnderflow","stepMismatch","tooLong","tooShort","typeMismatch","valid","valueMissing","fieldValidityMapping","invalid","FieldRootContext","controlId","setControlId","labelId","setLabelId","messageIds","setMessageIds","validityData","errors","error","initialValue","setValidityData","touched","setTouched","dirty","setDirty","filled","setFilled","focused","setFocused","validate","validationMode","validationDebounceTime","markedDirtyRef","useFieldRootContext","optional","visuallyHidden","clip","overflow","whiteSpace","position","top","left","border","padding","FormContext","formRef","fields","Map","onClearErrors","getCombinedFieldValidityData","validityKeys","useFieldControlValidation","timeoutRef","inputRef","window","clearTimeout","commitValidation","async","resultOrPromise","result","errorMessage","Array","isArray","join","setCustomValidity","nextState","el","validity","validationErrors","validationMessage","nextValidityData","currentFieldData","set","getValidationProps","getInputValidationProps","onChange","defaultPrevented","currentTarget","setTimeout","collapsibleStyleHookMapping","CollapsibleRoot","renderProp","CollapsibleTrigger","CollapsiblePanelCssVars","CollapsiblePanel","collapsiblePanelHeight","collapsiblePanelWidth","getLogicalSide","sideParam","renderedSide","isLogicalSideParam","right","bottom","isRef","param","HAN_NUMERALS","ARABIC_NUMERALS","RegExp","EMPTY_ARRAY","SelectRootContext","useSelectRootContext","SelectIndexContext","SelectRoot","alignItemToTrigger","readOnly","required","selectRoot","alignItemToTriggerParam","fieldControlValidation","setValueUnwrapped","controlledAlignItemToTrigger","setcontrolledAlignItemToTrigger","listRef","labelsRef","valueRef","valuesRef","typingRef","selectedItemTextRef","selectionRef","allowSelectedMouseUp","allowUnselectedMouseUp","allowSelect","positionerElement","setPositionerElement","activeIndex","setActiveIndex","selectedIndex","setSelectedIndex","label","setLabel","touchModality","setTouchModality","scrollUpArrowVisible","setScrollUpArrowVisible","scrollDownArrowVisible","setScrollDownArrowVisible","activeOption","queueMicrotask","setAttribute","hasRegisteredRef","registerSelectedItem","suppliedIndex","stringValue","JSON","stringify","triggerDisabled","enabled","bubbles","useRole","listNavigation","useListNavigation","disabledIndices","onNavigate","nextActiveIndex","focusItemOnHover","typeahead","useTypeahead","onMatch","onTypingChange","typing","getRootTriggerProps","getRootPositionerProps","getItemProps","rootContext","indexContext","useSelectRoot","serializedValue","onFocus","exactValue","find","toLowerCase","useSelectTrigger","triggerRef","timeoutId1","timeoutId2","onBlur","onPointerMove","pointerType","onPointerDown","onMouseDown","doc","ownerDocument","handleMouseUp","mouseEvent","mouseUpTarget","contains","bounds","elementRect","beforeStyles","afterStyles","content","beforeWidth","parseFloat","beforeHeight","afterWidth","afterHeight","totalWidth","max","totalHeight","widthDiff","heightDiff","getPseudoElementBounds","clientX","clientY","once","SelectTrigger","fieldState","fieldDisabled","selectDisabled","styleHookMapping","pressableTriggerOpenStateMapping","SelectPortalContext","SelectPortal","popupStateMapping","useSelectPositioner","positioning","anchor","positionMethod","side","sideOffset","align","alignOffset","collisionBoundary","collisionPadding","sticky","arrowPadding","trackAnchor","nodeId","placement","commonCollisionProps","boundary","arrowRef","sideOffsetRef","useLatestRef","alignOffsetRef","sideOffsetDep","alignOffsetDep","middleware","offset","rects","currentPlacement","data","getSide","getAlignment","positioner","sideAxis","alignAxis","mainAxis","crossAxis","alignmentAxis","flipMiddleware","flip","shiftMiddleware","shift","limiter","limitShift","size","apply","availableWidth","availableHeight","entries","setProperty","arrow","document","createElement","hide","fn","middlewareData","renderedPlacement","currentRenderedSide","arrowEl","arrowX","x","arrowY","y","transformX","clientWidth","transformY","clientHeight","transformOrigin","domReference","autoUpdateOptions","elementResize","ResizeObserver","layoutShift","IntersectionObserver","refs","floatingStyles","update","isPositioned","useFloating","strategy","whileElementsMounted","args","autoUpdate","registeredPositionReferenceRef","resolvedAnchor","unwrappedElement","setPositionReference","logicalRenderedSide","renderedAlign","anchorHidden","referenceHidden","arrowStyles","arrowUncentered","centerOffset","positionerStyles","useAnchorPositioning","getPositionerProps","hiddenStyles","pointerEvents","SelectPositionerContext","SelectPositioner","clearPositionerStyles","originalPositionerStyles","assign","SelectPopup","useSelectPositionerContext","initialHeightRef","reachedMaxHeightRef","maxHeightRef","initialPlacedRef","originalPositionerStylesRef","handleScrollArrowVisibility","isScrolledToTop","scrollTop","isScrolledToBottom","scrollHeight","minHeight","maxHeight","marginTop","marginBottom","popupStyles","win","triggerRect","positionerRect","triggerX","triggerHeight","borderBottom","borderBottomWidth","viewportHeight","documentElement","viewportWidth","availableSpaceBeneathTrigger","textElement","valueElement","offsetX","offsetY","valueRect","textRect","valueLeftFromTriggerLeft","textLeftFromPositionerLeft","valueCenterFromPositionerTop","idealHeight","maxRight","rightOverflow","maxScrollTop","isTopPositioned","fallbackToAlignPopupToTrigger","isPinchZoomed","visualViewport","scale","isWebKit","topOffset","handleResize","onScroll","isBottomPositioned","currentHeight","diff","nextHeight","overshoot","overflowX","overflowY","useSelectPopup","transition","popupSelector","html","__html","dangerouslySetInnerHTML","visuallyHiddenDismiss","SelectItemContext","InnerSelectItem","highlighted","selected","getRootItemProps","selectedIndexRef","indexRef","handleSelect","commitSelection","lastKeyRef","pointerTypeRef","prevPopupHeightRef","allowFocusSyncRef","onMouseMove","offsetHeight","onMouseLeave","popup","targetRect","preventScroll","onTouchStart","onPointerEnter","onMouseUp","disallowSelectedMouseUp","disallowUnselectedMouseUp","useSelectItem","rootProps","active","MemoizedInnerSelectItem","SelectItem","listItem","useSelectIndexContext","itemRef","hasRegistered","SelectItemIndicator","useSelectItemContext","indicatorRef","inset","isIOS","nav","navigator","platform","maxTouchPoints","uaData","userAgentData","getNavigatorData","test","isFirefox","getUserAgent","TRIGGER_HOOK","PRESSABLE_TRIGGER_HOOK","POPUP_OPEN_HOOK","POPUP_CLOSED_HOOK","ANCHOR_HIDDEN_HOOK","STARTING_HOOK","ENDING_HOOK","waitForNextTick","frameRef","cancelTasks","fnToExecute","getAnimations","globalThis","BASE_UI_ANIMATIONS_DISABLED","exec","Promise","allSettled","map","anim","finished","then","ReactDOM","onCompleteParam","openRef","setOpenMethod","handleTriggerClick","_","handler","lastClickInteractionTypeRef","handlePointerDown","detail","useEnhancedClickHandler","$f0a04ccd8dbdd83b$export$e5c5a5f917a5871c","$HgANd$react","useLayoutEffect","$c87311424ea30a05$var$testUserAgent","re","_window_navigator_userAgentData","brands","some","brand","userAgent","$c87311424ea30a05$var$testPlatform","$c87311424ea30a05$var$cached","res","$c87311424ea30a05$export$9ac100e40613ea10","$c87311424ea30a05$export$186c6964ca17d99","$c87311424ea30a05$export$7bef049ce92e4224","$c87311424ea30a05$export$fedb369cb70207f1","$c87311424ea30a05$export$6446a186d09e379e","$ff5963eb1fccf552$export$e08e3b67e392101e","callbacks","callback","$cc38e7bd3fc7b213$export$2bb74740c4e19def","node","checkForOverflow","isScrollable","scrollWidth","$62d8ded9296f3872$export$cfa2225e87938781","scrollableNode","parentElement","scrollingElement","$49c51c25361d4cd2$var$visualViewport","$49c51c25361d4cd2$var$nonTextInputTypes","Set","$49c51c25361d4cd2$var$restore","$49c51c25361d4cd2$var$preventScrollCount","$49c51c25361d4cd2$export$ee0f7cc6afcd1c18","$7mMvr$useLayoutEffect","$7mMvr$isIOS","scrollable","restoreScrollableStyles","onTouchMove","e","body","onTouchEnd","HTMLInputElement","has","HTMLTextAreaElement","HTMLElement","isContentEditable","$49c51c25361d4cd2$var$willOpenKeyboard","setupStyles","transform","innerHeight","$49c51c25361d4cd2$var$scrollIntoView","restoreStyles","onWindowScroll","scrollTo","scrollX","pageXOffset","scrollY","pageYOffset","$7mMvr$chain","$49c51c25361d4cd2$var$addEvent","$49c51c25361d4cd2$var$setStyle","innerWidth","removeEvents","$7mMvr$getScrollParent","overscrollBehavior","passive","capture","$49c51c25361d4cd2$var$preventScrollMobileSafari","cur","nextTarget","scrollableTop","targetTop","originalHtmlStyles","originalBodyStyles","originalHtmlScrollBehavior","preventScrollCount","restore","referenceElement","isReactAriaHook","hasInsetScrollbars","usePreventScroll","scrollLeft","resizeRaf","lockScroll","htmlStyles","bodyStyles","scrollBehavior","boxSizing","hasScrollbarGutterStable","scrollbarGutter","isScrollableY","isScrollableX","hasConstantOverflowY","hasConstantOverflowX","scrollbarWidth","scrollbarHeight","marginY","marginX","marginLeft","marginRight","cleanup","removeAttribute","preventScrollStandard","delayStartingStatus","setTransitionStatus","computeCoordsFromPlacement","_ref","rtl","getSideAxis","getAlignmentAxis","alignLength","getAxisLength","isVertical","commonX","commonY","commonAlign","coords","detectOverflow","_await$platform$isEle","rootBoundary","elementContext","altBoundary","evaluate","paddingObject","getPaddingObject","clippingClientRect","rectToClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getSideOffsets","isAnySideFullyClipped","sides","getCssDimensions","css","hasOffset","isHTMLElement","offsetWidth","shouldFallback","round","$","unwrapElement","domElement","createCoords","isFinite","noOffsets","getVisualOffsets","getWindow","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","getFrameElement","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","leftScroll","getNodeScroll","getHTMLOffset","scroll","ignoreScrollbarX","htmlRect","getClientRectFromClippingAncestor","clippingAncestor","visualViewportBased","getViewportRect","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","parentNode","getParentNode","isLastTraversableNode","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","getNodeName","isOverflowElement","offsetRect","htmlOffset","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","isTopLayer","svgOffsetParent","isTableElement","isContainingBlock","getContainingBlock","topLayer","clippingAncestors","cache","cachedResult","getOverflowAncestors","currentContainingBlockComputedStyle","elementIsFixed","currentNode","computedStyle","currentNodeIsContaining","ancestor","getClippingElementAncestors","this","_c","concat","firstClippingAncestor","clippingRect","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getClientRects","from","isRTL","rectsAreEqual","a","b","ancestorScroll","ancestorResize","animationFrame","referenceEl","ancestors","cleanupIo","onMove","timeoutId","io","_io","disconnect","refresh","skip","threshold","elementRectForRootMargin","rootMargin","floor","isFirstUpdate","handleObserve","ratio","intersectionRatio","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","_middlewareData$offse","_middlewareData$arrow","diffCoords","alignment","mainAxisMulti","crossAxisMulti","rawValue","convertValueToCoords","alignmentOffset","checkMainAxis","checkCrossAxis","detectOverflowOptions","getOppositeAxis","mainAxisCoord","crossAxisCoord","maxSide","clamp","limitedCoords","_middlewareData$flip","initialPlacement","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","getOppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","getOppositeAxisPlacements","placements","overflows","overflowsData","getAlignmentSides","every","_middlewareData$flip2","_overflowsData$filter","nextPlacement","reset","resetPlacement","d","sort","_overflowsData$filter2","currentSideAxis","_state$middlewareData","_state$middlewareData2","isYAxis","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","xMin","xMax","yMin","yMax","nextDimensions","referenceHiddenOffsets","escapedOffsets","escaped","axis","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","computePosition","mergedOptions","platformWithCache","config","validMiddleware","statefulPlacement","resetCount","nextX","nextY","computePosition$1","useEffect","deepEqual","toString","hasOwnProperty","call","$$typeof","getDPR","defaultView","devicePixelRatio","roundByDPR","dpr","externalReference","externalFloating","setData","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","setReference","referenceRef","setFloating","floatingRef","floatingEl","dataRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","fullData","isMountedRef","initialStyles","willChange","arrow$1","arrow$2","deps","offset$1","shift$1","limitShift$1","flip$1","size$1","hide$1","candidateSelectors","candidateSelector","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","_element$getRootNode","isInert","lookUp","_node$getAttribute","inertAtt","getAttribute","getCandidates","includeContainer","candidates","querySelectorAll","unshift","getCandidatesIteratively","elementsToCheck","tagName","assigned","assignedElements","nestedCandidates","flatten","scopeParent","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","_nestedCandidates","hasTabIndex","isNaN","parseInt","getTabIndex","_node$getAttribute2","attValue","sortOrderedTabbables","documentOrder","isInput","isNonTabbableRadio","isRadio","radioSet","radioScope","form","queryRadios","escape","err","console","message","checked","nodes","getCheckedRadio","isTabbableRadio","isZeroArea","_node$getBoundingClie","isHidden","displayCheck","visibility","nodeUnderDetails","originalNode","rootNode","assignedSlot","host","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","isNodeMatchingSelectorFocusable","isHiddenInput","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","isScope","candidateTabindex","getSortOrderTabIndex","sortable","tabbable","bind","isTabbable","useMergeRefs","SafeReact","useSafeInsertionEffect","useInsertionEffect","useEffectEvent","process","_len","arguments","_key","isDifferentRow","cols","prevRow","isIndexOutOfBounds","getMinIndex","findNonDisabledIndex","getMaxIndex","decrement","startingIndex","_temp","amount","list","getGridNavigatedIndex","minIndex","maxIndex","prevIndex","stopEvent","stop","col","maxCol","lastRow","buildCellMap","sizes","dense","cellMap","startIndex","_ref2","itemPlaced","targetCells","j","cell","getCellIndexOfCorner","corner","firstCellIndex","sizeItem","lastIndexOf","getCellIndices","indices","flatMap","cellIndex","horizontalKeys","verticalKeys","serverHandoffComplete","count","genId","random","useId","setId","createPubSub","emit","_map$get","on","listener","off","_map$get2","l","FloatingNodeContext","FloatingTreeContext","useFloatingParentNodeId","_React$useContext","useFloatingTree","createAttribute","useRef","rafId","enqueueFocus","cancelPrevious","sync","getAncestors","_nodes$find","allAncestors","currentParentId","parentId","getChildren","allChildren","_node$context","currentChildren","_currentChildren","n","_node$context2","counterMap","WeakMap","uncontrolledElementsSet","WeakSet","markerMap","lockCount$1","supportsInert","unwrapHost","correctElements","parent","targets","correctedTarget","markOthers","avoidElements","ariaHidden","getDocument","uncorrectedAvoidElements","markerName","controlAttribute","elementsToKeep","elementsToStop","hiddenElements","markerCounter","keep","add","deep","attr","alreadyHidden","currentCounterValue","counterValue","markerValue","clear","delete","applyAttributeToOthers","getTabbableOptions","getTabbableIn","allTabbable","reverse","activeElement","getNextTabbable","getPreviousTabbable","isOutsideEvent","containerElement","relatedTarget","disableFocusInside","dataset","tabindex","enableFocusInside","HIDDEN_STYLES","setActiveElementOnTab","FocusGuard","setRole","isSafari","restProps","jsx","PortalContext","preserveTabOrder","portalNode","uniqueId","portalContext","usePortalContext","setPortalNode","portalNodeRef","remove","existingIdRoot","getElementById","subRoot","appendChild","idWrapper","useFloatingPortalNode","focusManagerState","setFocusManagerState","beforeOutsideRef","afterOutsideRef","beforeInsideRef","afterInsideRef","shouldRenderGuards","jsxs","_beforeInsideRef$curr","prevTabbable","_afterInsideRef$curre","nextTabbable","FOCUSABLE_ATTRIBUTE","getFloatingFocusElement","floatingElement","LIST_LIMIT","previouslyFocusedElements","addPreviouslyFocusedElement","isConnected","getPreviouslyFocusedElement","VisuallyHiddenDismiss","order","guards","_guards","restoreFocus","outsideElementsInert","events","getNodeId","_dataRef$current$floa","floatingContext","ignoreInitialFocus","isUntrappedTypeableCombobox","isTypeableCombobox","inertSupported","useInert","orderRef","initialFocusRef","returnFocusRef","tree","startDismissButtonRef","endDismissButtonRef","preventReturnFocusRef","isPointerDownRef","tabbableIndexRef","isInsidePortal","floatingFocusElement","getTabbableContent","getTabbableElements","flat","els","shiftKey","handleFocusIn","tabbableIndex","handleFocusOutside","movedToUnrelatedNode","nodesRef","_node$context3","_node$context4","_node$context5","prevTabbableIndex","tabbableContent","nodeToFocus","beforeGuardRef","afterGuardRef","mergedBeforeGuardRef","mergedAfterGuardRef","renderDismissButton","location","_portalContext$portal","portalNodes","ancestorFloatingNodes","_node$context6","insideElements","previouslyFocusedElement","focusableElements","initialFocusValue","elToFocus","focusAlreadyInsideFloatingEl","preventReturnFocusScroll","openEvent","isVirtualClick","isVirtualPointerEvent","fallbackEl","insertAdjacentElement","activeEl","isFocusInsideFloatingTree","_node$context7","returnElement","tabbableReturnElement","tabbableOptions","getFirstTabbableElement","MutationObserver","handleMutation","observer","childList","subtree","attributes","Fragment","_portalContext$before","_portalContext$afterO","isButtonTarget","isSpaceIgnored","isTypeableElement","eventOption","toggle","ignoreMouse","keyboardHandlers","stickIfOpen","didKeyDownRef","button","isMouseLikePointerType","onKeyUp","bubbleHandlerKeys","pointerdown","mousedown","captureHandlerKeys","normalizeProp","normalizable","_normalizable$escapeK","_normalizable$outside","unstable_outsidePress","referencePress","referencePressEvent","outsidePressFn","insideReactTreeRef","endedOrStartedInsideRef","escapeKeyBubbles","outsidePressBubbles","escapeKeyCapture","outsidePressCapture","isComposingRef","closeOnEscapeKeyDown","stopPropagation","shouldDismiss","_child$context","__escapeKeyBubbles","isReactEvent","closeOnEscapeKeyDownCapture","_getTarget2","_getTarget","closeOnPressOutside","_dataRef$current$floa2","insideReactTree","endedOrStartedInside","inertSelector","markers","targetRootAncestor","nextParent","isRootElement","marker","lastTraversableNode","scrollRe","canScrollX","canScrollY","pressedVerticalScrollbar","pressedHorizontalScrollbar","targetIsInsideChildren","isEventTargetWithin","_child$context2","__outsidePressBubbles","closeOnPressOutsideCapture","_getTarget4","_getTarget3","compositionTimeout","handleCompositionStart","handleCompositionEnd","_doc$defaultView","elementsProp","floatingId","positionReference","internalRootContext","computedElements","_domReference","setDomReference","_setPositionReference","domReferenceRef","useFloating$1","computedPositionReference","ACTIVE_KEY","SELECTED_KEY","mergeProps","userProps","propsList","elementKey","isItem","domUserProps","__","validProps","propsOrGetProps","val","referenceDeps","floatingDeps","itemDeps","doSwitch","vertical","horizontal","isMainOrientationKey","isMainOrientationToEndKey","isCrossOrientationCloseKey","unstable_onNavigate","allowEscape","virtual","focusItemOnOpen","openOnArrowKeyDown","scrollItemIntoView","virtualItemRef","itemSizes","floatingFocusElementRef","typeableComboboxReference","focusItemOnOpenRef","keyRef","isPointerModalityRef","previousOnNavigateRef","previousMountedRef","previousOpenRef","forceSyncFocusRef","forceScrollIntoViewRef","disabledIndicesRef","latestOpenRef","scrollItemIntoViewRef","activeId","setActiveId","virtualId","setVirtualId","focusItem","runFocus","initialItem","waitedItem","scrollIntoViewOptions","scrollIntoView","block","inline","runs","waitForListPopulated","treeContainsActiveEl","handleVirtualFocus","hasActiveIndex","syncCurrentTarget","_ref3","onPointerLeave","_ref4","_floatingFocusElement","commonOnKeyDown","which","currentIndex","minGridIndex","findIndex","maxGridIndex","foundIndex","itemIndex","ariaActiveDescendantProp","checkVirtualMouse","checkVirtualPointer","isArrowKey","startsWith","isHomeOrEndKey","isMoveKey","isCrossOpenKey","isCrossOrientationOpenKey","isCrossCloseKey","isMainKey","isNavigationKey","trim","deepestNode","deepestNodeId","maxDepth","findDeepest","depth","getDeepestNode","eventObject","KeyboardEvent","_deepestNode$context","_deepestNode$context2","isCurrentTarget","dispatchItem","dispatchEvent","_deepestNode$context$","componentRoleToAriaRoleMap","_componentRoleToAriaR","ariaRole","referenceId","isNested","floatingProps","commonProps","unstable_onMatch","unstable_onTypingChange","findMatch","resetMs","ignoreKeys","timeoutIdRef","stringRef","prevIndexRef","matchIndexRef","findMatchRef","ignoreKeysRef","setTypingChange","getMatchingIndex","orderedList","string","str","text","toLocaleLowerCase","listContent","ctrlKey","metaKey","altKey","_text$","_text$2","_activeElement","isShadowRoot","next","getPlatform","version","mozInputSource","isTrusted","isAndroid","buttons","pressure","vendor","strict","composedPath","TYPEABLE_SELECTOR","hasWindow","isNode","nodeName","Node","ShadowRoot","selector","elementOrCss","webkit","containerType","backdropFilter","contain","getNearestOverflowAncestor","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","frameElement","getPrototypeOf","oppositeSideMap","oppositeAlignmentMap","start","end","split","mainAlignmentSide","oppositePlacement","getOppositeAlignmentPlacement","replace","isStart","lr","rl","tb","bt","getSideList","expandPaddingObject"],"sourceRoot":""}