{"version":3,"file":"static/js/5048.c0bd536317072b216e57.js","mappings":"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","sources":["../node_modules/@mui/system/Stack/createStack.js","../node_modules/@mui/material/Stack/Stack.js","../node_modules/@web-for-marketing/react-ui/lib/esm/components/Icons/ExpandIcon.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/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;","import { jsx as _jsx } from \"@emotion/react/jsx-runtime\";\nexport function ExpandIcon(props) {\n    return (_jsx(\"svg\", Object.assign({ \"aria-hidden\": true, width: '20', height: '20', viewBox: '0 0 20 20', fill: 'none', xmlns: 'http://www.w3.org/2000/svg', color: '#3C5164' }, props, { children: _jsx(\"path\", { d: 'M3.56444 5.50613C3.29168 5.19441 2.81786 5.16282 2.50613 5.43558C2.19441 5.70834 2.16282 6.18216 2.43558 6.49389L9.43553 14.4939C9.57794 14.6566 9.78369 14.75 9.99996 14.75C10.2162 14.75 10.422 14.6567 10.5644 14.4939L17.5644 6.49389C17.8372 6.18216 17.8056 5.70834 17.4939 5.43558C17.1822 5.16282 16.7083 5.1944 16.4356 5.50613L9.99997 12.8611L3.56444 5.50613Z', fill: 'currentColor' }) })));\n}\n","'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 };","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","ExpandIcon","assign","width","height","viewBox","fill","xmlns","color","d","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","DialogPopupCssVars","DialogPopupDataAttributes","DialogPortalContext","hasNestedDialogs","value","DialogPopup","finalFocus","id","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","idProp","setTitleElementId","useBaseUiId","useEnhancedEffect","getProps","DialogTrigger","setTriggerElement","getTriggerProps","triggerOpenStateMapping","parameters","idParam","handleRef","defaultInitialFocus","interactionType","tabIndex","onOpenChangeParameter","openParam","setOpenUnwrapped","useControlled","controlled","default","setDescriptionElementId","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","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","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","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":""}