{"version":3,"file":"static/js/2471.77adb9da.chunk.js","mappings":"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","sources":["../node_modules/@mui/material/Backdrop/backdropClasses.js","../node_modules/@mui/material/Backdrop/Backdrop.js","../node_modules/@mui/material/Fade/Fade.js","../node_modules/@mui/material/Grow/Grow.js","../node_modules/@mui/material/node_modules/@mui/base/unstable_useModal/ModalManager.js","../node_modules/@mui/material/node_modules/@mui/base/unstable_useModal/useModal.js","../node_modules/@mui/material/node_modules/@mui/base/FocusTrap/FocusTrap.js","../node_modules/@mui/material/Modal/modalClasses.js","../node_modules/@mui/material/Modal/Modal.js","../node_modules/@mui/material/node_modules/@mui/base/Portal/Portal.js","../node_modules/@mui/material/node_modules/@mui/base/utils/useSlotProps.js","../node_modules/@mui/material/utils/debounce.js","../node_modules/@mui/material/utils/ownerWindow.js","../node_modules/@mui/utils/createChainedFunction/createChainedFunction.js","../node_modules/@mui/utils/getScrollbarSize/getScrollbarSize.js","../node_modules/@mui/utils/useId/useId.js"],"sourcesContent":["import generateUtilityClasses from '@mui/utils/generateUtilityClasses';\nimport generateUtilityClass from '@mui/utils/generateUtilityClass';\nexport function getBackdropUtilityClass(slot) {\n  return generateUtilityClass('MuiBackdrop', slot);\n}\nconst backdropClasses = generateUtilityClasses('MuiBackdrop', ['root', 'invisible']);\nexport default backdropClasses;","'use client';\n\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"children\", \"className\", \"component\", \"components\", \"componentsProps\", \"invisible\", \"open\", \"slotProps\", \"slots\", \"TransitionComponent\", \"transitionDuration\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport composeClasses from '@mui/utils/composeClasses';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport Fade from '../Fade';\nimport { getBackdropUtilityClass } from './backdropClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    invisible\n  } = ownerState;\n  const slots = {\n    root: ['root', invisible && 'invisible']\n  };\n  return composeClasses(slots, getBackdropUtilityClass, classes);\n};\nconst BackdropRoot = styled('div', {\n  name: 'MuiBackdrop',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, ownerState.invisible && styles.invisible];\n  }\n})(({\n  ownerState\n}) => _extends({\n  position: 'fixed',\n  display: 'flex',\n  alignItems: 'center',\n  justifyContent: 'center',\n  right: 0,\n  bottom: 0,\n  top: 0,\n  left: 0,\n  backgroundColor: 'rgba(0, 0, 0, 0.5)',\n  WebkitTapHighlightColor: 'transparent'\n}, ownerState.invisible && {\n  backgroundColor: 'transparent'\n}));\nconst Backdrop = /*#__PURE__*/React.forwardRef(function Backdrop(inProps, ref) {\n  var _slotProps$root, _ref, _slots$root;\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiBackdrop'\n  });\n  const {\n      children,\n      className,\n      component = 'div',\n      components = {},\n      componentsProps = {},\n      invisible = false,\n      open,\n      slotProps = {},\n      slots = {},\n      TransitionComponent = Fade,\n      transitionDuration\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const ownerState = _extends({}, props, {\n    component,\n    invisible\n  });\n  const classes = useUtilityClasses(ownerState);\n  const rootSlotProps = (_slotProps$root = slotProps.root) != null ? _slotProps$root : componentsProps.root;\n  return /*#__PURE__*/_jsx(TransitionComponent, _extends({\n    in: open,\n    timeout: transitionDuration\n  }, other, {\n    children: /*#__PURE__*/_jsx(BackdropRoot, _extends({\n      \"aria-hidden\": true\n    }, rootSlotProps, {\n      as: (_ref = (_slots$root = slots.root) != null ? _slots$root : components.Root) != null ? _ref : component,\n      className: clsx(classes.root, className, rootSlotProps == null ? void 0 : rootSlotProps.className),\n      ownerState: _extends({}, ownerState, rootSlotProps == null ? void 0 : rootSlotProps.ownerState),\n      classes: classes,\n      ref: ref,\n      children: children\n    }))\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Backdrop.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   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\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   * The components used for each slot inside.\n   *\n   * This prop is an alias for the `slots` prop.\n   * It's recommended to use the `slots` prop instead.\n   *\n   * @default {}\n   */\n  components: PropTypes.shape({\n    Root: PropTypes.elementType\n  }),\n  /**\n   * The extra props for the slot components.\n   * You can override the existing props or add new ones.\n   *\n   * This prop is an alias for the `slotProps` prop.\n   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.\n   *\n   * @default {}\n   */\n  componentsProps: PropTypes.shape({\n    root: PropTypes.object\n  }),\n  /**\n   * If `true`, the backdrop is invisible.\n   * It can be used when rendering a popover or a custom select component.\n   * @default false\n   */\n  invisible: PropTypes.bool,\n  /**\n   * If `true`, the component is shown.\n   */\n  open: PropTypes.bool.isRequired,\n  /**\n   * The extra props for the slot components.\n   * You can override the existing props or add new ones.\n   *\n   * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.\n   *\n   * @default {}\n   */\n  slotProps: PropTypes.shape({\n    root: PropTypes.object\n  }),\n  /**\n   * The components used for each slot inside.\n   *\n   * This prop is an alias for the `components` prop, which will be deprecated in the future.\n   *\n   * @default {}\n   */\n  slots: PropTypes.shape({\n    root: PropTypes.elementType\n  }),\n  /**\n   * The system prop that 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   * The component used for the transition.\n   * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.\n   * @default Fade\n   */\n  TransitionComponent: PropTypes.elementType,\n  /**\n   * The duration for the transition, in milliseconds.\n   * You may specify a single timeout for all transitions, or individually with an object.\n   */\n  transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({\n    appear: PropTypes.number,\n    enter: PropTypes.number,\n    exit: PropTypes.number\n  })])\n} : void 0;\nexport default Backdrop;","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"addEndListener\", \"appear\", \"children\", \"easing\", \"in\", \"onEnter\", \"onEntered\", \"onEntering\", \"onExit\", \"onExited\", \"onExiting\", \"style\", \"timeout\", \"TransitionComponent\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { Transition } from 'react-transition-group';\nimport elementAcceptingRef from '@mui/utils/elementAcceptingRef';\nimport useTheme from '../styles/useTheme';\nimport { reflow, getTransitionProps } from '../transitions/utils';\nimport useForkRef from '../utils/useForkRef';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst styles = {\n  entering: {\n    opacity: 1\n  },\n  entered: {\n    opacity: 1\n  }\n};\n\n/**\n * The Fade transition is used by the [Modal](/material-ui/react-modal/) component.\n * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.\n */\nconst Fade = /*#__PURE__*/React.forwardRef(function Fade(props, ref) {\n  const theme = useTheme();\n  const defaultTimeout = {\n    enter: theme.transitions.duration.enteringScreen,\n    exit: theme.transitions.duration.leavingScreen\n  };\n  const {\n      addEndListener,\n      appear = true,\n      children,\n      easing,\n      in: inProp,\n      onEnter,\n      onEntered,\n      onEntering,\n      onExit,\n      onExited,\n      onExiting,\n      style,\n      timeout = defaultTimeout,\n      // eslint-disable-next-line react/prop-types\n      TransitionComponent = Transition\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const enableStrictModeCompat = true;\n  const nodeRef = React.useRef(null);\n  const handleRef = useForkRef(nodeRef, children.ref, ref);\n  const normalizedTransitionCallback = callback => maybeIsAppearing => {\n    if (callback) {\n      const node = nodeRef.current;\n\n      // onEnterXxx and onExitXxx callbacks have a different arguments.length value.\n      if (maybeIsAppearing === undefined) {\n        callback(node);\n      } else {\n        callback(node, maybeIsAppearing);\n      }\n    }\n  };\n  const handleEntering = normalizedTransitionCallback(onEntering);\n  const handleEnter = normalizedTransitionCallback((node, isAppearing) => {\n    reflow(node); // So the animation always start from the start.\n\n    const transitionProps = getTransitionProps({\n      style,\n      timeout,\n      easing\n    }, {\n      mode: 'enter'\n    });\n    node.style.webkitTransition = theme.transitions.create('opacity', transitionProps);\n    node.style.transition = theme.transitions.create('opacity', transitionProps);\n    if (onEnter) {\n      onEnter(node, isAppearing);\n    }\n  });\n  const handleEntered = normalizedTransitionCallback(onEntered);\n  const handleExiting = normalizedTransitionCallback(onExiting);\n  const handleExit = normalizedTransitionCallback(node => {\n    const transitionProps = getTransitionProps({\n      style,\n      timeout,\n      easing\n    }, {\n      mode: 'exit'\n    });\n    node.style.webkitTransition = theme.transitions.create('opacity', transitionProps);\n    node.style.transition = theme.transitions.create('opacity', transitionProps);\n    if (onExit) {\n      onExit(node);\n    }\n  });\n  const handleExited = normalizedTransitionCallback(onExited);\n  const handleAddEndListener = next => {\n    if (addEndListener) {\n      // Old call signature before `react-transition-group` implemented `nodeRef`\n      addEndListener(nodeRef.current, next);\n    }\n  };\n  return /*#__PURE__*/_jsx(TransitionComponent, _extends({\n    appear: appear,\n    in: inProp,\n    nodeRef: enableStrictModeCompat ? nodeRef : undefined,\n    onEnter: handleEnter,\n    onEntered: handleEntered,\n    onEntering: handleEntering,\n    onExit: handleExit,\n    onExited: handleExited,\n    onExiting: handleExiting,\n    addEndListener: handleAddEndListener,\n    timeout: timeout\n  }, other, {\n    children: (state, childProps) => {\n      return /*#__PURE__*/React.cloneElement(children, _extends({\n        style: _extends({\n          opacity: 0,\n          visibility: state === 'exited' && !inProp ? 'hidden' : undefined\n        }, styles[state], style, children.props.style),\n        ref: handleRef\n      }, childProps));\n    }\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Fade.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   * Add a custom transition end trigger. Called with the transitioning DOM\n   * node and a done callback. Allows for more fine grained transition end\n   * logic. Note: Timeouts are still used as a fallback if provided.\n   */\n  addEndListener: PropTypes.func,\n  /**\n   * Perform the enter transition when it first mounts if `in` is also `true`.\n   * Set this to `false` to disable this behavior.\n   * @default true\n   */\n  appear: PropTypes.bool,\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef.isRequired,\n  /**\n   * The transition timing function.\n   * You may specify a single easing or a object containing enter and exit values.\n   */\n  easing: PropTypes.oneOfType([PropTypes.shape({\n    enter: PropTypes.string,\n    exit: PropTypes.string\n  }), PropTypes.string]),\n  /**\n   * If `true`, the component will transition in.\n   */\n  in: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  onEnter: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onEntered: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onEntering: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onExit: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onExited: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onExiting: PropTypes.func,\n  /**\n   * @ignore\n   */\n  style: PropTypes.object,\n  /**\n   * The duration for the transition, in milliseconds.\n   * You may specify a single timeout for all transitions, or individually with an object.\n   * @default {\n   *   enter: theme.transitions.duration.enteringScreen,\n   *   exit: theme.transitions.duration.leavingScreen,\n   * }\n   */\n  timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({\n    appear: PropTypes.number,\n    enter: PropTypes.number,\n    exit: PropTypes.number\n  })])\n} : void 0;\nexport default Fade;","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"addEndListener\", \"appear\", \"children\", \"easing\", \"in\", \"onEnter\", \"onEntered\", \"onEntering\", \"onExit\", \"onExited\", \"onExiting\", \"style\", \"timeout\", \"TransitionComponent\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport useTimeout from '@mui/utils/useTimeout';\nimport elementAcceptingRef from '@mui/utils/elementAcceptingRef';\nimport { Transition } from 'react-transition-group';\nimport useTheme from '../styles/useTheme';\nimport { getTransitionProps, reflow } from '../transitions/utils';\nimport useForkRef from '../utils/useForkRef';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction getScale(value) {\n  return `scale(${value}, ${value ** 2})`;\n}\nconst styles = {\n  entering: {\n    opacity: 1,\n    transform: getScale(1)\n  },\n  entered: {\n    opacity: 1,\n    transform: 'none'\n  }\n};\n\n/*\n TODO v6: remove\n Conditionally apply a workaround for the CSS transition bug in Safari 15.4 / WebKit browsers.\n */\nconst isWebKit154 = typeof navigator !== 'undefined' && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\\/)15(.|_)4/i.test(navigator.userAgent);\n\n/**\n * The Grow transition is used by the [Tooltip](/material-ui/react-tooltip/) and\n * [Popover](/material-ui/react-popover/) components.\n * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.\n */\nconst Grow = /*#__PURE__*/React.forwardRef(function Grow(props, ref) {\n  const {\n      addEndListener,\n      appear = true,\n      children,\n      easing,\n      in: inProp,\n      onEnter,\n      onEntered,\n      onEntering,\n      onExit,\n      onExited,\n      onExiting,\n      style,\n      timeout = 'auto',\n      // eslint-disable-next-line react/prop-types\n      TransitionComponent = Transition\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const timer = useTimeout();\n  const autoTimeout = React.useRef();\n  const theme = useTheme();\n  const nodeRef = React.useRef(null);\n  const handleRef = useForkRef(nodeRef, children.ref, ref);\n  const normalizedTransitionCallback = callback => maybeIsAppearing => {\n    if (callback) {\n      const node = nodeRef.current;\n\n      // onEnterXxx and onExitXxx callbacks have a different arguments.length value.\n      if (maybeIsAppearing === undefined) {\n        callback(node);\n      } else {\n        callback(node, maybeIsAppearing);\n      }\n    }\n  };\n  const handleEntering = normalizedTransitionCallback(onEntering);\n  const handleEnter = normalizedTransitionCallback((node, isAppearing) => {\n    reflow(node); // So the animation always start from the start.\n\n    const {\n      duration: transitionDuration,\n      delay,\n      easing: transitionTimingFunction\n    } = getTransitionProps({\n      style,\n      timeout,\n      easing\n    }, {\n      mode: 'enter'\n    });\n    let duration;\n    if (timeout === 'auto') {\n      duration = theme.transitions.getAutoHeightDuration(node.clientHeight);\n      autoTimeout.current = duration;\n    } else {\n      duration = transitionDuration;\n    }\n    node.style.transition = [theme.transitions.create('opacity', {\n      duration,\n      delay\n    }), theme.transitions.create('transform', {\n      duration: isWebKit154 ? duration : duration * 0.666,\n      delay,\n      easing: transitionTimingFunction\n    })].join(',');\n    if (onEnter) {\n      onEnter(node, isAppearing);\n    }\n  });\n  const handleEntered = normalizedTransitionCallback(onEntered);\n  const handleExiting = normalizedTransitionCallback(onExiting);\n  const handleExit = normalizedTransitionCallback(node => {\n    const {\n      duration: transitionDuration,\n      delay,\n      easing: transitionTimingFunction\n    } = getTransitionProps({\n      style,\n      timeout,\n      easing\n    }, {\n      mode: 'exit'\n    });\n    let duration;\n    if (timeout === 'auto') {\n      duration = theme.transitions.getAutoHeightDuration(node.clientHeight);\n      autoTimeout.current = duration;\n    } else {\n      duration = transitionDuration;\n    }\n    node.style.transition = [theme.transitions.create('opacity', {\n      duration,\n      delay\n    }), theme.transitions.create('transform', {\n      duration: isWebKit154 ? duration : duration * 0.666,\n      delay: isWebKit154 ? delay : delay || duration * 0.333,\n      easing: transitionTimingFunction\n    })].join(',');\n    node.style.opacity = 0;\n    node.style.transform = getScale(0.75);\n    if (onExit) {\n      onExit(node);\n    }\n  });\n  const handleExited = normalizedTransitionCallback(onExited);\n  const handleAddEndListener = next => {\n    if (timeout === 'auto') {\n      timer.start(autoTimeout.current || 0, next);\n    }\n    if (addEndListener) {\n      // Old call signature before `react-transition-group` implemented `nodeRef`\n      addEndListener(nodeRef.current, next);\n    }\n  };\n  return /*#__PURE__*/_jsx(TransitionComponent, _extends({\n    appear: appear,\n    in: inProp,\n    nodeRef: nodeRef,\n    onEnter: handleEnter,\n    onEntered: handleEntered,\n    onEntering: handleEntering,\n    onExit: handleExit,\n    onExited: handleExited,\n    onExiting: handleExiting,\n    addEndListener: handleAddEndListener,\n    timeout: timeout === 'auto' ? null : timeout\n  }, other, {\n    children: (state, childProps) => {\n      return /*#__PURE__*/React.cloneElement(children, _extends({\n        style: _extends({\n          opacity: 0,\n          transform: getScale(0.75),\n          visibility: state === 'exited' && !inProp ? 'hidden' : undefined\n        }, styles[state], style, children.props.style),\n        ref: handleRef\n      }, childProps));\n    }\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Grow.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   * Add a custom transition end trigger. Called with the transitioning DOM\n   * node and a done callback. Allows for more fine grained transition end\n   * logic. Note: Timeouts are still used as a fallback if provided.\n   */\n  addEndListener: PropTypes.func,\n  /**\n   * Perform the enter transition when it first mounts if `in` is also `true`.\n   * Set this to `false` to disable this behavior.\n   * @default true\n   */\n  appear: PropTypes.bool,\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef.isRequired,\n  /**\n   * The transition timing function.\n   * You may specify a single easing or a object containing enter and exit values.\n   */\n  easing: PropTypes.oneOfType([PropTypes.shape({\n    enter: PropTypes.string,\n    exit: PropTypes.string\n  }), PropTypes.string]),\n  /**\n   * If `true`, the component will transition in.\n   */\n  in: PropTypes.bool,\n  /**\n   * @ignore\n   */\n  onEnter: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onEntered: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onEntering: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onExit: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onExited: PropTypes.func,\n  /**\n   * @ignore\n   */\n  onExiting: PropTypes.func,\n  /**\n   * @ignore\n   */\n  style: PropTypes.object,\n  /**\n   * The duration for the transition, in milliseconds.\n   * You may specify a single timeout for all transitions, or individually with an object.\n   *\n   * Set to 'auto' to automatically calculate transition time based on height.\n   * @default 'auto'\n   */\n  timeout: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.shape({\n    appear: PropTypes.number,\n    enter: PropTypes.number,\n    exit: PropTypes.number\n  })])\n} : void 0;\nGrow.muiSupportAuto = true;\nexport default Grow;","import { unstable_ownerWindow as ownerWindow, unstable_ownerDocument as ownerDocument, unstable_getScrollbarSize as getScrollbarSize } from '@mui/utils';\n// Is a vertical scrollbar displayed?\nfunction isOverflowing(container) {\n  const doc = ownerDocument(container);\n  if (doc.body === container) {\n    return ownerWindow(container).innerWidth > doc.documentElement.clientWidth;\n  }\n  return container.scrollHeight > container.clientHeight;\n}\nexport function ariaHidden(element, show) {\n  if (show) {\n    element.setAttribute('aria-hidden', 'true');\n  } else {\n    element.removeAttribute('aria-hidden');\n  }\n}\nfunction getPaddingRight(element) {\n  return parseInt(ownerWindow(element).getComputedStyle(element).paddingRight, 10) || 0;\n}\nfunction isAriaHiddenForbiddenOnElement(element) {\n  // The forbidden HTML tags are the ones from ARIA specification that\n  // can be children of body and can't have aria-hidden attribute.\n  // cf. https://www.w3.org/TR/html-aria/#docconformance\n  const forbiddenTagNames = ['TEMPLATE', 'SCRIPT', 'STYLE', 'LINK', 'MAP', 'META', 'NOSCRIPT', 'PICTURE', 'COL', 'COLGROUP', 'PARAM', 'SLOT', 'SOURCE', 'TRACK'];\n  const isForbiddenTagName = forbiddenTagNames.indexOf(element.tagName) !== -1;\n  const isInputHidden = element.tagName === 'INPUT' && element.getAttribute('type') === 'hidden';\n  return isForbiddenTagName || isInputHidden;\n}\nfunction ariaHiddenSiblings(container, mountElement, currentElement, elementsToExclude, show) {\n  const blacklist = [mountElement, currentElement, ...elementsToExclude];\n  [].forEach.call(container.children, element => {\n    const isNotExcludedElement = blacklist.indexOf(element) === -1;\n    const isNotForbiddenElement = !isAriaHiddenForbiddenOnElement(element);\n    if (isNotExcludedElement && isNotForbiddenElement) {\n      ariaHidden(element, show);\n    }\n  });\n}\nfunction findIndexOf(items, callback) {\n  let idx = -1;\n  items.some((item, index) => {\n    if (callback(item)) {\n      idx = index;\n      return true;\n    }\n    return false;\n  });\n  return idx;\n}\nfunction handleContainer(containerInfo, props) {\n  const restoreStyle = [];\n  const container = containerInfo.container;\n  if (!props.disableScrollLock) {\n    if (isOverflowing(container)) {\n      // Compute the size before applying overflow hidden to avoid any scroll jumps.\n      const scrollbarSize = getScrollbarSize(ownerDocument(container));\n      restoreStyle.push({\n        value: container.style.paddingRight,\n        property: 'padding-right',\n        el: container\n      });\n      // Use computed style, here to get the real padding to add our scrollbar width.\n      container.style.paddingRight = `${getPaddingRight(container) + scrollbarSize}px`;\n\n      // .mui-fixed is a global helper.\n      const fixedElements = ownerDocument(container).querySelectorAll('.mui-fixed');\n      [].forEach.call(fixedElements, element => {\n        restoreStyle.push({\n          value: element.style.paddingRight,\n          property: 'padding-right',\n          el: element\n        });\n        element.style.paddingRight = `${getPaddingRight(element) + scrollbarSize}px`;\n      });\n    }\n    let scrollContainer;\n    if (container.parentNode instanceof DocumentFragment) {\n      scrollContainer = ownerDocument(container).body;\n    } else {\n      // Support html overflow-y: auto for scroll stability between pages\n      // https://css-tricks.com/snippets/css/force-vertical-scrollbar/\n      const parent = container.parentElement;\n      const containerWindow = ownerWindow(container);\n      scrollContainer = (parent == null ? void 0 : parent.nodeName) === 'HTML' && containerWindow.getComputedStyle(parent).overflowY === 'scroll' ? parent : container;\n    }\n\n    // Block the scroll even if no scrollbar is visible to account for mobile keyboard\n    // screensize shrink.\n    restoreStyle.push({\n      value: scrollContainer.style.overflow,\n      property: 'overflow',\n      el: scrollContainer\n    }, {\n      value: scrollContainer.style.overflowX,\n      property: 'overflow-x',\n      el: scrollContainer\n    }, {\n      value: scrollContainer.style.overflowY,\n      property: 'overflow-y',\n      el: scrollContainer\n    });\n    scrollContainer.style.overflow = 'hidden';\n  }\n  const restore = () => {\n    restoreStyle.forEach(({\n      value,\n      el,\n      property\n    }) => {\n      if (value) {\n        el.style.setProperty(property, value);\n      } else {\n        el.style.removeProperty(property);\n      }\n    });\n  };\n  return restore;\n}\nfunction getHiddenSiblings(container) {\n  const hiddenSiblings = [];\n  [].forEach.call(container.children, element => {\n    if (element.getAttribute('aria-hidden') === 'true') {\n      hiddenSiblings.push(element);\n    }\n  });\n  return hiddenSiblings;\n}\n/**\n * @ignore - do not document.\n *\n * Proper state management for containers and the modals in those containers.\n * Simplified, but inspired by react-overlay's ModalManager class.\n * Used by the Modal to ensure proper styling of containers.\n */\nexport class ModalManager {\n  constructor() {\n    this.containers = void 0;\n    this.modals = void 0;\n    this.modals = [];\n    this.containers = [];\n  }\n  add(modal, container) {\n    let modalIndex = this.modals.indexOf(modal);\n    if (modalIndex !== -1) {\n      return modalIndex;\n    }\n    modalIndex = this.modals.length;\n    this.modals.push(modal);\n\n    // If the modal we are adding is already in the DOM.\n    if (modal.modalRef) {\n      ariaHidden(modal.modalRef, false);\n    }\n    const hiddenSiblings = getHiddenSiblings(container);\n    ariaHiddenSiblings(container, modal.mount, modal.modalRef, hiddenSiblings, true);\n    const containerIndex = findIndexOf(this.containers, item => item.container === container);\n    if (containerIndex !== -1) {\n      this.containers[containerIndex].modals.push(modal);\n      return modalIndex;\n    }\n    this.containers.push({\n      modals: [modal],\n      container,\n      restore: null,\n      hiddenSiblings\n    });\n    return modalIndex;\n  }\n  mount(modal, props) {\n    const containerIndex = findIndexOf(this.containers, item => item.modals.indexOf(modal) !== -1);\n    const containerInfo = this.containers[containerIndex];\n    if (!containerInfo.restore) {\n      containerInfo.restore = handleContainer(containerInfo, props);\n    }\n  }\n  remove(modal, ariaHiddenState = true) {\n    const modalIndex = this.modals.indexOf(modal);\n    if (modalIndex === -1) {\n      return modalIndex;\n    }\n    const containerIndex = findIndexOf(this.containers, item => item.modals.indexOf(modal) !== -1);\n    const containerInfo = this.containers[containerIndex];\n    containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);\n    this.modals.splice(modalIndex, 1);\n\n    // If that was the last modal in a container, clean up the container.\n    if (containerInfo.modals.length === 0) {\n      // The modal might be closed before it had the chance to be mounted in the DOM.\n      if (containerInfo.restore) {\n        containerInfo.restore();\n      }\n      if (modal.modalRef) {\n        // In case the modal wasn't in the DOM yet.\n        ariaHidden(modal.modalRef, ariaHiddenState);\n      }\n      ariaHiddenSiblings(containerInfo.container, modal.mount, modal.modalRef, containerInfo.hiddenSiblings, false);\n      this.containers.splice(containerIndex, 1);\n    } else {\n      // Otherwise make sure the next top modal is visible to a screen reader.\n      const nextTop = containerInfo.modals[containerInfo.modals.length - 1];\n      // as soon as a modal is adding its modalRef is undefined. it can't set\n      // aria-hidden because the dom element doesn't exist either\n      // when modal was unmounted before modalRef gets null\n      if (nextTop.modalRef) {\n        ariaHidden(nextTop.modalRef, false);\n      }\n    }\n    return modalIndex;\n  }\n  isTopModal(modal) {\n    return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;\n  }\n}","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_ownerDocument as ownerDocument, unstable_useForkRef as useForkRef, unstable_useEventCallback as useEventCallback, unstable_createChainedFunction as createChainedFunction } from '@mui/utils';\nimport { extractEventHandlers } from '../utils';\nimport { ModalManager, ariaHidden } from './ModalManager';\nfunction getContainer(container) {\n  return typeof container === 'function' ? container() : container;\n}\nfunction getHasTransition(children) {\n  return children ? children.props.hasOwnProperty('in') : false;\n}\n\n// A modal manager used to track and manage the state of open Modals.\n// Modals don't open on the server so this won't conflict with concurrent requests.\nconst defaultManager = new ModalManager();\n/**\n *\n * Demos:\n *\n * - [Modal](https://mui.com/base-ui/react-modal/#hook)\n *\n * API:\n *\n * - [useModal API](https://mui.com/base-ui/react-modal/hooks-api/#use-modal)\n */\nexport function useModal(parameters) {\n  const {\n    container,\n    disableEscapeKeyDown = false,\n    disableScrollLock = false,\n    // @ts-ignore internal logic - Base UI supports the manager as a prop too\n    manager = defaultManager,\n    closeAfterTransition = false,\n    onTransitionEnter,\n    onTransitionExited,\n    children,\n    onClose,\n    open,\n    rootRef\n  } = parameters;\n\n  // @ts-ignore internal logic\n  const modal = React.useRef({});\n  const mountNodeRef = React.useRef(null);\n  const modalRef = React.useRef(null);\n  const handleRef = useForkRef(modalRef, rootRef);\n  const [exited, setExited] = React.useState(!open);\n  const hasTransition = getHasTransition(children);\n  let ariaHiddenProp = true;\n  if (parameters['aria-hidden'] === 'false' || parameters['aria-hidden'] === false) {\n    ariaHiddenProp = false;\n  }\n  const getDoc = () => ownerDocument(mountNodeRef.current);\n  const getModal = () => {\n    modal.current.modalRef = modalRef.current;\n    modal.current.mount = mountNodeRef.current;\n    return modal.current;\n  };\n  const handleMounted = () => {\n    manager.mount(getModal(), {\n      disableScrollLock\n    });\n\n    // Fix a bug on Chrome where the scroll isn't initially 0.\n    if (modalRef.current) {\n      modalRef.current.scrollTop = 0;\n    }\n  };\n  const handleOpen = useEventCallback(() => {\n    const resolvedContainer = getContainer(container) || getDoc().body;\n    manager.add(getModal(), resolvedContainer);\n\n    // The element was already mounted.\n    if (modalRef.current) {\n      handleMounted();\n    }\n  });\n  const isTopModal = React.useCallback(() => manager.isTopModal(getModal()), [manager]);\n  const handlePortalRef = useEventCallback(node => {\n    mountNodeRef.current = node;\n    if (!node) {\n      return;\n    }\n    if (open && isTopModal()) {\n      handleMounted();\n    } else if (modalRef.current) {\n      ariaHidden(modalRef.current, ariaHiddenProp);\n    }\n  });\n  const handleClose = React.useCallback(() => {\n    manager.remove(getModal(), ariaHiddenProp);\n  }, [ariaHiddenProp, manager]);\n  React.useEffect(() => {\n    return () => {\n      handleClose();\n    };\n  }, [handleClose]);\n  React.useEffect(() => {\n    if (open) {\n      handleOpen();\n    } else if (!hasTransition || !closeAfterTransition) {\n      handleClose();\n    }\n  }, [open, handleClose, hasTransition, closeAfterTransition, handleOpen]);\n  const createHandleKeyDown = otherHandlers => event => {\n    var _otherHandlers$onKeyD;\n    (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);\n\n    // The handler doesn't take event.defaultPrevented into account:\n    //\n    // event.preventDefault() is meant to stop default behaviors like\n    // clicking a checkbox to check it, hitting a button to submit a form,\n    // and hitting left arrow to move the cursor in a text input etc.\n    // Only special HTML elements have these default behaviors.\n    if (event.key !== 'Escape' || event.which === 229 ||\n    // Wait until IME is settled.\n    !isTopModal()) {\n      return;\n    }\n    if (!disableEscapeKeyDown) {\n      // Swallow the event, in case someone is listening for the escape key on the body.\n      event.stopPropagation();\n      if (onClose) {\n        onClose(event, 'escapeKeyDown');\n      }\n    }\n  };\n  const createHandleBackdropClick = otherHandlers => event => {\n    var _otherHandlers$onClic;\n    (_otherHandlers$onClic = otherHandlers.onClick) == null || _otherHandlers$onClic.call(otherHandlers, event);\n    if (event.target !== event.currentTarget) {\n      return;\n    }\n    if (onClose) {\n      onClose(event, 'backdropClick');\n    }\n  };\n  const getRootProps = (otherHandlers = {}) => {\n    const propsEventHandlers = extractEventHandlers(parameters);\n\n    // The custom event handlers shouldn't be spread on the root element\n    delete propsEventHandlers.onTransitionEnter;\n    delete propsEventHandlers.onTransitionExited;\n    const externalEventHandlers = _extends({}, propsEventHandlers, otherHandlers);\n    return _extends({\n      role: 'presentation'\n    }, externalEventHandlers, {\n      onKeyDown: createHandleKeyDown(externalEventHandlers),\n      ref: handleRef\n    });\n  };\n  const getBackdropProps = (otherHandlers = {}) => {\n    const externalEventHandlers = otherHandlers;\n    return _extends({\n      'aria-hidden': true\n    }, externalEventHandlers, {\n      onClick: createHandleBackdropClick(externalEventHandlers),\n      open\n    });\n  };\n  const getTransitionProps = () => {\n    const handleEnter = () => {\n      setExited(false);\n      if (onTransitionEnter) {\n        onTransitionEnter();\n      }\n    };\n    const handleExited = () => {\n      setExited(true);\n      if (onTransitionExited) {\n        onTransitionExited();\n      }\n      if (closeAfterTransition) {\n        handleClose();\n      }\n    };\n    return {\n      onEnter: createChainedFunction(handleEnter, children == null ? void 0 : children.props.onEnter),\n      onExited: createChainedFunction(handleExited, children == null ? void 0 : children.props.onExited)\n    };\n  };\n  return {\n    getRootProps,\n    getBackdropProps,\n    getTransitionProps,\n    rootRef: handleRef,\n    portalRef: handlePortalRef,\n    isTopModal,\n    exited,\n    hasTransition\n  };\n}","'use client';\n\n/* eslint-disable consistent-return, jsx-a11y/no-noninteractive-tabindex */\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { exactProp, elementAcceptingRef, unstable_useForkRef as useForkRef, unstable_ownerDocument as ownerDocument } from '@mui/utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n// Inspired by https://github.com/focus-trap/tabbable\nconst candidatesSelector = ['input', 'select', 'textarea', 'a[href]', 'button', '[tabindex]', 'audio[controls]', 'video[controls]', '[contenteditable]:not([contenteditable=\"false\"])'].join(',');\nfunction getTabIndex(node) {\n  const tabindexAttr = parseInt(node.getAttribute('tabindex') || '', 10);\n  if (!Number.isNaN(tabindexAttr)) {\n    return tabindexAttr;\n  }\n\n  // Browsers do not return `tabIndex` correctly for contentEditable nodes;\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=661108&q=contenteditable%20tabindex&can=2\n  // so if they don't have a tabindex attribute specifically set, assume it's 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  if (node.contentEditable === 'true' || (node.nodeName === 'AUDIO' || node.nodeName === 'VIDEO' || node.nodeName === 'DETAILS') && node.getAttribute('tabindex') === null) {\n    return 0;\n  }\n  return node.tabIndex;\n}\nfunction isNonTabbableRadio(node) {\n  if (node.tagName !== 'INPUT' || node.type !== 'radio') {\n    return false;\n  }\n  if (!node.name) {\n    return false;\n  }\n  const getRadio = selector => node.ownerDocument.querySelector(`input[type=\"radio\"]${selector}`);\n  let roving = getRadio(`[name=\"${node.name}\"]:checked`);\n  if (!roving) {\n    roving = getRadio(`[name=\"${node.name}\"]`);\n  }\n  return roving !== node;\n}\nfunction isNodeMatchingSelectorFocusable(node) {\n  if (node.disabled || node.tagName === 'INPUT' && node.type === 'hidden' || isNonTabbableRadio(node)) {\n    return false;\n  }\n  return true;\n}\nfunction defaultGetTabbable(root) {\n  const regularTabNodes = [];\n  const orderedTabNodes = [];\n  Array.from(root.querySelectorAll(candidatesSelector)).forEach((node, i) => {\n    const nodeTabIndex = getTabIndex(node);\n    if (nodeTabIndex === -1 || !isNodeMatchingSelectorFocusable(node)) {\n      return;\n    }\n    if (nodeTabIndex === 0) {\n      regularTabNodes.push(node);\n    } else {\n      orderedTabNodes.push({\n        documentOrder: i,\n        tabIndex: nodeTabIndex,\n        node: node\n      });\n    }\n  });\n  return orderedTabNodes.sort((a, b) => a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex).map(a => a.node).concat(regularTabNodes);\n}\nfunction defaultIsEnabled() {\n  return true;\n}\n\n/**\n * Utility component that locks focus inside the component.\n *\n * Demos:\n *\n * - [Focus Trap](https://mui.com/base-ui/react-focus-trap/)\n *\n * API:\n *\n * - [FocusTrap API](https://mui.com/base-ui/react-focus-trap/components-api/#focus-trap)\n */\nfunction FocusTrap(props) {\n  const {\n    children,\n    disableAutoFocus = false,\n    disableEnforceFocus = false,\n    disableRestoreFocus = false,\n    getTabbable = defaultGetTabbable,\n    isEnabled = defaultIsEnabled,\n    open\n  } = props;\n  const ignoreNextEnforceFocus = React.useRef(false);\n  const sentinelStart = React.useRef(null);\n  const sentinelEnd = React.useRef(null);\n  const nodeToRestore = React.useRef(null);\n  const reactFocusEventTarget = React.useRef(null);\n  // This variable is useful when disableAutoFocus is true.\n  // It waits for the active element to move into the component to activate.\n  const activated = React.useRef(false);\n  const rootRef = React.useRef(null);\n  // @ts-expect-error TODO upstream fix\n  const handleRef = useForkRef(children.ref, rootRef);\n  const lastKeydown = React.useRef(null);\n  React.useEffect(() => {\n    // We might render an empty child.\n    if (!open || !rootRef.current) {\n      return;\n    }\n    activated.current = !disableAutoFocus;\n  }, [disableAutoFocus, open]);\n  React.useEffect(() => {\n    // We might render an empty child.\n    if (!open || !rootRef.current) {\n      return;\n    }\n    const doc = ownerDocument(rootRef.current);\n    if (!rootRef.current.contains(doc.activeElement)) {\n      if (!rootRef.current.hasAttribute('tabIndex')) {\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(['MUI: The modal content node does not accept focus.', 'For the benefit of assistive technologies, ' + 'the tabIndex of the node is being set to \"-1\".'].join('\\n'));\n        }\n        rootRef.current.setAttribute('tabIndex', '-1');\n      }\n      if (activated.current) {\n        rootRef.current.focus();\n      }\n    }\n    return () => {\n      // restoreLastFocus()\n      if (!disableRestoreFocus) {\n        // In IE11 it is possible for document.activeElement to be null resulting\n        // in nodeToRestore.current being null.\n        // Not all elements in IE11 have a focus method.\n        // Once IE11 support is dropped the focus() call can be unconditional.\n        if (nodeToRestore.current && nodeToRestore.current.focus) {\n          ignoreNextEnforceFocus.current = true;\n          nodeToRestore.current.focus();\n        }\n        nodeToRestore.current = null;\n      }\n    };\n    // Missing `disableRestoreFocus` which is fine.\n    // We don't support changing that prop on an open FocusTrap\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [open]);\n  React.useEffect(() => {\n    // We might render an empty child.\n    if (!open || !rootRef.current) {\n      return;\n    }\n    const doc = ownerDocument(rootRef.current);\n    const loopFocus = nativeEvent => {\n      lastKeydown.current = nativeEvent;\n      if (disableEnforceFocus || !isEnabled() || nativeEvent.key !== 'Tab') {\n        return;\n      }\n\n      // Make sure the next tab starts from the right place.\n      // doc.activeElement refers to the origin.\n      if (doc.activeElement === rootRef.current && nativeEvent.shiftKey) {\n        // We need to ignore the next contain as\n        // it will try to move the focus back to the rootRef element.\n        ignoreNextEnforceFocus.current = true;\n        if (sentinelEnd.current) {\n          sentinelEnd.current.focus();\n        }\n      }\n    };\n    const contain = () => {\n      const rootElement = rootRef.current;\n\n      // Cleanup functions are executed lazily in React 17.\n      // Contain can be called between the component being unmounted and its cleanup function being run.\n      if (rootElement === null) {\n        return;\n      }\n      if (!doc.hasFocus() || !isEnabled() || ignoreNextEnforceFocus.current) {\n        ignoreNextEnforceFocus.current = false;\n        return;\n      }\n\n      // The focus is already inside\n      if (rootElement.contains(doc.activeElement)) {\n        return;\n      }\n\n      // The disableEnforceFocus is set and the focus is outside of the focus trap (and sentinel nodes)\n      if (disableEnforceFocus && doc.activeElement !== sentinelStart.current && doc.activeElement !== sentinelEnd.current) {\n        return;\n      }\n\n      // if the focus event is not coming from inside the children's react tree, reset the refs\n      if (doc.activeElement !== reactFocusEventTarget.current) {\n        reactFocusEventTarget.current = null;\n      } else if (reactFocusEventTarget.current !== null) {\n        return;\n      }\n      if (!activated.current) {\n        return;\n      }\n      let tabbable = [];\n      if (doc.activeElement === sentinelStart.current || doc.activeElement === sentinelEnd.current) {\n        tabbable = getTabbable(rootRef.current);\n      }\n\n      // one of the sentinel nodes was focused, so move the focus\n      // to the first/last tabbable element inside the focus trap\n      if (tabbable.length > 0) {\n        var _lastKeydown$current, _lastKeydown$current2;\n        const isShiftTab = Boolean(((_lastKeydown$current = lastKeydown.current) == null ? void 0 : _lastKeydown$current.shiftKey) && ((_lastKeydown$current2 = lastKeydown.current) == null ? void 0 : _lastKeydown$current2.key) === 'Tab');\n        const focusNext = tabbable[0];\n        const focusPrevious = tabbable[tabbable.length - 1];\n        if (typeof focusNext !== 'string' && typeof focusPrevious !== 'string') {\n          if (isShiftTab) {\n            focusPrevious.focus();\n          } else {\n            focusNext.focus();\n          }\n        }\n        // no tabbable elements in the trap focus or the focus was outside of the focus trap\n      } else {\n        rootElement.focus();\n      }\n    };\n    doc.addEventListener('focusin', contain);\n    doc.addEventListener('keydown', loopFocus, true);\n\n    // With Edge, Safari and Firefox, no focus related events are fired when the focused area stops being a focused area.\n    // e.g. https://bugzilla.mozilla.org/show_bug.cgi?id=559561.\n    // Instead, we can look if the active element was restored on the BODY element.\n    //\n    // The whatwg spec defines how the browser should behave but does not explicitly mention any events:\n    // https://html.spec.whatwg.org/multipage/interaction.html#focus-fixup-rule.\n    const interval = setInterval(() => {\n      if (doc.activeElement && doc.activeElement.tagName === 'BODY') {\n        contain();\n      }\n    }, 50);\n    return () => {\n      clearInterval(interval);\n      doc.removeEventListener('focusin', contain);\n      doc.removeEventListener('keydown', loopFocus, true);\n    };\n  }, [disableAutoFocus, disableEnforceFocus, disableRestoreFocus, isEnabled, open, getTabbable]);\n  const onFocus = event => {\n    if (nodeToRestore.current === null) {\n      nodeToRestore.current = event.relatedTarget;\n    }\n    activated.current = true;\n    reactFocusEventTarget.current = event.target;\n    const childrenPropsHandler = children.props.onFocus;\n    if (childrenPropsHandler) {\n      childrenPropsHandler(event);\n    }\n  };\n  const handleFocusSentinel = event => {\n    if (nodeToRestore.current === null) {\n      nodeToRestore.current = event.relatedTarget;\n    }\n    activated.current = true;\n  };\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [/*#__PURE__*/_jsx(\"div\", {\n      tabIndex: open ? 0 : -1,\n      onFocus: handleFocusSentinel,\n      ref: sentinelStart,\n      \"data-testid\": \"sentinelStart\"\n    }), /*#__PURE__*/React.cloneElement(children, {\n      ref: handleRef,\n      onFocus\n    }), /*#__PURE__*/_jsx(\"div\", {\n      tabIndex: open ? 0 : -1,\n      onFocus: handleFocusSentinel,\n      ref: sentinelEnd,\n      \"data-testid\": \"sentinelEnd\"\n    })]\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? FocusTrap.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   * A single child content element.\n   */\n  children: elementAcceptingRef,\n  /**\n   * If `true`, the focus trap will not automatically shift focus to itself when it opens, and\n   * replace it to the last focused element when it closes.\n   * This also works correctly with any focus trap children that have the `disableAutoFocus` prop.\n   *\n   * Generally this should never be set to `true` as it makes the focus trap less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableAutoFocus: PropTypes.bool,\n  /**\n   * If `true`, the focus trap will not prevent focus from leaving the focus trap while open.\n   *\n   * Generally this should never be set to `true` as it makes the focus trap less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableEnforceFocus: PropTypes.bool,\n  /**\n   * If `true`, the focus trap will not restore focus to previously focused element once\n   * focus trap is hidden or unmounted.\n   * @default false\n   */\n  disableRestoreFocus: PropTypes.bool,\n  /**\n   * Returns an array of ordered tabbable nodes (i.e. in tab order) within the root.\n   * For instance, you can provide the \"tabbable\" npm dependency.\n   * @param {HTMLElement} root\n   */\n  getTabbable: PropTypes.func,\n  /**\n   * This prop extends the `open` prop.\n   * It allows to toggle the open state without having to wait for a rerender when changing the `open` prop.\n   * This prop should be memoized.\n   * It can be used to support multiple focus trap mounted at the same time.\n   * @default function defaultIsEnabled(): boolean {\n   *   return true;\n   * }\n   */\n  isEnabled: PropTypes.func,\n  /**\n   * If `true`, focus is locked.\n   */\n  open: PropTypes.bool.isRequired\n} : void 0;\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  FocusTrap['propTypes' + ''] = exactProp(FocusTrap.propTypes);\n}\nexport { FocusTrap };","import generateUtilityClasses from '@mui/utils/generateUtilityClasses';\nimport generateUtilityClass from '@mui/utils/generateUtilityClass';\nexport function getModalUtilityClass(slot) {\n  return generateUtilityClass('MuiModal', slot);\n}\nconst modalClasses = generateUtilityClasses('MuiModal', ['root', 'hidden', 'backdrop']);\nexport default modalClasses;","'use client';\n\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"BackdropComponent\", \"BackdropProps\", \"classes\", \"className\", \"closeAfterTransition\", \"children\", \"container\", \"component\", \"components\", \"componentsProps\", \"disableAutoFocus\", \"disableEnforceFocus\", \"disableEscapeKeyDown\", \"disablePortal\", \"disableRestoreFocus\", \"disableScrollLock\", \"hideBackdrop\", \"keepMounted\", \"onBackdropClick\", \"onClose\", \"onTransitionEnter\", \"onTransitionExited\", \"open\", \"slotProps\", \"slots\", \"theme\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport HTMLElementType from '@mui/utils/HTMLElementType';\nimport elementAcceptingRef from '@mui/utils/elementAcceptingRef';\nimport { useSlotProps } from '@mui/base/utils';\nimport { unstable_useModal as useModal } from '@mui/base/unstable_useModal';\nimport composeClasses from '@mui/utils/composeClasses';\nimport FocusTrap from '../Unstable_TrapFocus';\nimport Portal from '../Portal';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport Backdrop from '../Backdrop';\nimport { getModalUtilityClass } from './modalClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    open,\n    exited,\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root', !open && exited && 'hidden'],\n    backdrop: ['backdrop']\n  };\n  return composeClasses(slots, getModalUtilityClass, classes);\n};\nconst ModalRoot = styled('div', {\n  name: 'MuiModal',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, !ownerState.open && ownerState.exited && styles.hidden];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  position: 'fixed',\n  zIndex: (theme.vars || theme).zIndex.modal,\n  right: 0,\n  bottom: 0,\n  top: 0,\n  left: 0\n}, !ownerState.open && ownerState.exited && {\n  visibility: 'hidden'\n}));\nconst ModalBackdrop = styled(Backdrop, {\n  name: 'MuiModal',\n  slot: 'Backdrop',\n  overridesResolver: (props, styles) => {\n    return styles.backdrop;\n  }\n})({\n  zIndex: -1\n});\n\n/**\n * Modal is a lower-level construct that is leveraged by the following components:\n *\n * - [Dialog](/material-ui/api/dialog/)\n * - [Drawer](/material-ui/api/drawer/)\n * - [Menu](/material-ui/api/menu/)\n * - [Popover](/material-ui/api/popover/)\n *\n * If you are creating a modal dialog, you probably want to use the [Dialog](/material-ui/api/dialog/) component\n * rather than directly using Modal.\n *\n * This component shares many concepts with [react-overlays](https://react-bootstrap.github.io/react-overlays/#modals).\n */\nconst Modal = /*#__PURE__*/React.forwardRef(function Modal(inProps, ref) {\n  var _ref, _slots$root, _ref2, _slots$backdrop, _slotProps$root, _slotProps$backdrop;\n  const props = useThemeProps({\n    name: 'MuiModal',\n    props: inProps\n  });\n  const {\n      BackdropComponent = ModalBackdrop,\n      BackdropProps,\n      className,\n      closeAfterTransition = false,\n      children,\n      container,\n      component,\n      components = {},\n      componentsProps = {},\n      disableAutoFocus = false,\n      disableEnforceFocus = false,\n      disableEscapeKeyDown = false,\n      disablePortal = false,\n      disableRestoreFocus = false,\n      disableScrollLock = false,\n      hideBackdrop = false,\n      keepMounted = false,\n      onBackdropClick,\n      open,\n      slotProps,\n      slots\n      // eslint-disable-next-line react/prop-types\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const propsWithDefaults = _extends({}, props, {\n    closeAfterTransition,\n    disableAutoFocus,\n    disableEnforceFocus,\n    disableEscapeKeyDown,\n    disablePortal,\n    disableRestoreFocus,\n    disableScrollLock,\n    hideBackdrop,\n    keepMounted\n  });\n  const {\n    getRootProps,\n    getBackdropProps,\n    getTransitionProps,\n    portalRef,\n    isTopModal,\n    exited,\n    hasTransition\n  } = useModal(_extends({}, propsWithDefaults, {\n    rootRef: ref\n  }));\n  const ownerState = _extends({}, propsWithDefaults, {\n    exited\n  });\n  const classes = useUtilityClasses(ownerState);\n  const childProps = {};\n  if (children.props.tabIndex === undefined) {\n    childProps.tabIndex = '-1';\n  }\n\n  // It's a Transition like component\n  if (hasTransition) {\n    const {\n      onEnter,\n      onExited\n    } = getTransitionProps();\n    childProps.onEnter = onEnter;\n    childProps.onExited = onExited;\n  }\n  const RootSlot = (_ref = (_slots$root = slots == null ? void 0 : slots.root) != null ? _slots$root : components.Root) != null ? _ref : ModalRoot;\n  const BackdropSlot = (_ref2 = (_slots$backdrop = slots == null ? void 0 : slots.backdrop) != null ? _slots$backdrop : components.Backdrop) != null ? _ref2 : BackdropComponent;\n  const rootSlotProps = (_slotProps$root = slotProps == null ? void 0 : slotProps.root) != null ? _slotProps$root : componentsProps.root;\n  const backdropSlotProps = (_slotProps$backdrop = slotProps == null ? void 0 : slotProps.backdrop) != null ? _slotProps$backdrop : componentsProps.backdrop;\n  const rootProps = useSlotProps({\n    elementType: RootSlot,\n    externalSlotProps: rootSlotProps,\n    externalForwardedProps: other,\n    getSlotProps: getRootProps,\n    additionalProps: {\n      ref,\n      as: component\n    },\n    ownerState,\n    className: clsx(className, rootSlotProps == null ? void 0 : rootSlotProps.className, classes == null ? void 0 : classes.root, !ownerState.open && ownerState.exited && (classes == null ? void 0 : classes.hidden))\n  });\n  const backdropProps = useSlotProps({\n    elementType: BackdropSlot,\n    externalSlotProps: backdropSlotProps,\n    additionalProps: BackdropProps,\n    getSlotProps: otherHandlers => {\n      return getBackdropProps(_extends({}, otherHandlers, {\n        onClick: e => {\n          if (onBackdropClick) {\n            onBackdropClick(e);\n          }\n          if (otherHandlers != null && otherHandlers.onClick) {\n            otherHandlers.onClick(e);\n          }\n        }\n      }));\n    },\n    className: clsx(backdropSlotProps == null ? void 0 : backdropSlotProps.className, BackdropProps == null ? void 0 : BackdropProps.className, classes == null ? void 0 : classes.backdrop),\n    ownerState\n  });\n  if (!keepMounted && !open && (!hasTransition || exited)) {\n    return null;\n  }\n  return /*#__PURE__*/_jsx(Portal, {\n    ref: portalRef,\n    container: container,\n    disablePortal: disablePortal,\n    children: /*#__PURE__*/_jsxs(RootSlot, _extends({}, rootProps, {\n      children: [!hideBackdrop && BackdropComponent ? /*#__PURE__*/_jsx(BackdropSlot, _extends({}, backdropProps)) : null, /*#__PURE__*/_jsx(FocusTrap, {\n        disableEnforceFocus: disableEnforceFocus,\n        disableAutoFocus: disableAutoFocus,\n        disableRestoreFocus: disableRestoreFocus,\n        isEnabled: isTopModal,\n        open: open,\n        children: /*#__PURE__*/React.cloneElement(children, childProps)\n      })]\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? Modal.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   * A backdrop component. This prop enables custom backdrop rendering.\n   * @deprecated Use `slots.backdrop` instead. While this prop currently works, it will be removed in the next major version.\n   * Use the `slots.backdrop` prop to make your application ready for the next version of Material UI.\n   * @default styled(Backdrop, {\n   *   name: 'MuiModal',\n   *   slot: 'Backdrop',\n   *   overridesResolver: (props, styles) => {\n   *     return styles.backdrop;\n   *   },\n   * })({\n   *   zIndex: -1,\n   * })\n   */\n  BackdropComponent: PropTypes.elementType,\n  /**\n   * Props applied to the [`Backdrop`](/material-ui/api/backdrop/) element.\n   * @deprecated Use `slotProps.backdrop` instead.\n   */\n  BackdropProps: PropTypes.object,\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef.isRequired,\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n  /**\n   * When set to true the Modal waits until a nested Transition is completed before closing.\n   * @default false\n   */\n  closeAfterTransition: PropTypes.bool,\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   * The components used for each slot inside.\n   *\n   * This prop is an alias for the `slots` prop.\n   * It's recommended to use the `slots` prop instead.\n   *\n   * @default {}\n   */\n  components: PropTypes.shape({\n    Backdrop: PropTypes.elementType,\n    Root: PropTypes.elementType\n  }),\n  /**\n   * The extra props for the slot components.\n   * You can override the existing props or add new ones.\n   *\n   * This prop is an alias for the `slotProps` prop.\n   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.\n   *\n   * @default {}\n   */\n  componentsProps: PropTypes.shape({\n    backdrop: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),\n    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])\n  }),\n  /**\n   * An HTML element or function that returns one.\n   * The `container` will have the portal children appended to it.\n   *\n   * You can also provide a callback, which is called in a React layout effect.\n   * This lets you set the container from a ref, and also makes server-side rendering possible.\n   *\n   * By default, it uses the body of the top-level document object,\n   * so it's simply `document.body` most of the time.\n   */\n  container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),\n  /**\n   * If `true`, the modal will not automatically shift focus to itself when it opens, and\n   * replace it to the last focused element when it closes.\n   * This also works correctly with any modal children that have the `disableAutoFocus` prop.\n   *\n   * Generally this should never be set to `true` as it makes the modal less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableAutoFocus: PropTypes.bool,\n  /**\n   * If `true`, the modal will not prevent focus from leaving the modal while open.\n   *\n   * Generally this should never be set to `true` as it makes the modal less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableEnforceFocus: PropTypes.bool,\n  /**\n   * If `true`, hitting escape will not fire the `onClose` callback.\n   * @default false\n   */\n  disableEscapeKeyDown: PropTypes.bool,\n  /**\n   * The `children` will be under the DOM hierarchy of the parent component.\n   * @default false\n   */\n  disablePortal: PropTypes.bool,\n  /**\n   * If `true`, the modal will not restore focus to previously focused element once\n   * modal is hidden or unmounted.\n   * @default false\n   */\n  disableRestoreFocus: PropTypes.bool,\n  /**\n   * Disable the scroll lock behavior.\n   * @default false\n   */\n  disableScrollLock: PropTypes.bool,\n  /**\n   * If `true`, the backdrop is not rendered.\n   * @default false\n   */\n  hideBackdrop: PropTypes.bool,\n  /**\n   * Always keep the children in the DOM.\n   * This prop can be useful in SEO situation or\n   * when you want to maximize the responsiveness of the Modal.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Callback fired when the backdrop is clicked.\n   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.\n   */\n  onBackdropClick: PropTypes.func,\n  /**\n   * Callback fired when the component requests to be closed.\n   * The `reason` parameter can optionally be used to control the response to `onClose`.\n   *\n   * @param {object} event The event source of the callback.\n   * @param {string} reason Can be: `\"escapeKeyDown\"`, `\"backdropClick\"`.\n   */\n  onClose: PropTypes.func,\n  /**\n   * A function called when a transition enters.\n   */\n  onTransitionEnter: PropTypes.func,\n  /**\n   * A function called when a transition has exited.\n   */\n  onTransitionExited: PropTypes.func,\n  /**\n   * If `true`, the component is shown.\n   */\n  open: PropTypes.bool.isRequired,\n  /**\n   * The props used for each slot inside the Modal.\n   * @default {}\n   */\n  slotProps: PropTypes.shape({\n    backdrop: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),\n    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])\n  }),\n  /**\n   * The components used for each slot inside the Modal.\n   * Either a string to use a HTML element or a component.\n   * @default {}\n   */\n  slots: PropTypes.shape({\n    backdrop: PropTypes.elementType,\n    root: PropTypes.elementType\n  }),\n  /**\n   * The system prop that 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} : void 0;\nexport default Modal;","'use client';\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport PropTypes from 'prop-types';\nimport { exactProp, HTMLElementType, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useForkRef as useForkRef, unstable_setRef as setRef } from '@mui/utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction getContainer(container) {\n  return typeof container === 'function' ? container() : container;\n}\n\n/**\n * Portals provide a first-class way to render children into a DOM node\n * that exists outside the DOM hierarchy of the parent component.\n *\n * Demos:\n *\n * - [Portal](https://mui.com/base-ui/react-portal/)\n *\n * API:\n *\n * - [Portal API](https://mui.com/base-ui/react-portal/components-api/#portal)\n */\nconst Portal = /*#__PURE__*/React.forwardRef(function Portal(props, forwardedRef) {\n  const {\n    children,\n    container,\n    disablePortal = false\n  } = props;\n  const [mountNode, setMountNode] = React.useState(null);\n  // @ts-expect-error TODO upstream fix\n  const handleRef = useForkRef( /*#__PURE__*/React.isValidElement(children) ? children.ref : null, forwardedRef);\n  useEnhancedEffect(() => {\n    if (!disablePortal) {\n      setMountNode(getContainer(container) || document.body);\n    }\n  }, [container, disablePortal]);\n  useEnhancedEffect(() => {\n    if (mountNode && !disablePortal) {\n      setRef(forwardedRef, mountNode);\n      return () => {\n        setRef(forwardedRef, null);\n      };\n    }\n    return undefined;\n  }, [forwardedRef, mountNode, disablePortal]);\n  if (disablePortal) {\n    if ( /*#__PURE__*/React.isValidElement(children)) {\n      const newProps = {\n        ref: handleRef\n      };\n      return /*#__PURE__*/React.cloneElement(children, newProps);\n    }\n    return /*#__PURE__*/_jsx(React.Fragment, {\n      children: children\n    });\n  }\n  return /*#__PURE__*/_jsx(React.Fragment, {\n    children: mountNode ? /*#__PURE__*/ReactDOM.createPortal(children, mountNode) : mountNode\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? Portal.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   * The children to render into the `container`.\n   */\n  children: PropTypes.node,\n  /**\n   * An HTML element or function that returns one.\n   * The `container` will have the portal children appended to it.\n   *\n   * You can also provide a callback, which is called in a React layout effect.\n   * This lets you set the container from a ref, and also makes server-side rendering possible.\n   *\n   * By default, it uses the body of the top-level document object,\n   * so it's simply `document.body` most of the time.\n   */\n  container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),\n  /**\n   * The `children` will be under the DOM hierarchy of the parent component.\n   * @default false\n   */\n  disablePortal: PropTypes.bool\n} : void 0;\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  Portal['propTypes' + ''] = exactProp(Portal.propTypes);\n}\nexport { Portal };","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"elementType\", \"externalSlotProps\", \"ownerState\", \"skipResolvingSlotProps\"];\nimport { unstable_useForkRef as useForkRef } from '@mui/utils';\nimport { appendOwnerState } from './appendOwnerState';\nimport { mergeSlotProps } from './mergeSlotProps';\nimport { resolveComponentProps } from './resolveComponentProps';\n/**\n * @ignore - do not document.\n * Builds the props to be passed into the slot of an unstyled component.\n * It merges the internal props of the component with the ones supplied by the user, allowing to customize the behavior.\n * If the slot component is not a host component, it also merges in the `ownerState`.\n *\n * @param parameters.getSlotProps - A function that returns the props to be passed to the slot component.\n */\nexport function useSlotProps(parameters) {\n  var _parameters$additiona;\n  const {\n      elementType,\n      externalSlotProps,\n      ownerState,\n      skipResolvingSlotProps = false\n    } = parameters,\n    rest = _objectWithoutPropertiesLoose(parameters, _excluded);\n  const resolvedComponentsProps = skipResolvingSlotProps ? {} : resolveComponentProps(externalSlotProps, ownerState);\n  const {\n    props: mergedProps,\n    internalRef\n  } = mergeSlotProps(_extends({}, rest, {\n    externalSlotProps: resolvedComponentsProps\n  }));\n  const ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, (_parameters$additiona = parameters.additionalProps) == null ? void 0 : _parameters$additiona.ref);\n  const props = appendOwnerState(elementType, _extends({}, mergedProps, {\n    ref\n  }), ownerState);\n  return props;\n}","import debounce from '@mui/utils/debounce';\nexport default debounce;","import ownerWindow from '@mui/utils/ownerWindow';\nexport default ownerWindow;","/**\n * Safe chained function.\n *\n * Will only create a new function if needed,\n * otherwise will pass back existing functions or null.\n */\nexport default function createChainedFunction(...funcs) {\n  return funcs.reduce((acc, func) => {\n    if (func == null) {\n      return acc;\n    }\n    return function chainedFunction(...args) {\n      acc.apply(this, args);\n      func.apply(this, args);\n    };\n  }, () => {});\n}","// A change of the browser zoom change the scrollbar size.\n// Credit https://github.com/twbs/bootstrap/blob/488fd8afc535ca3a6ad4dc581f5e89217b6a36ac/js/src/util/scrollbar.js#L14-L18\nexport default function getScrollbarSize(doc) {\n  // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes\n  const documentWidth = doc.documentElement.clientWidth;\n  return Math.abs(window.innerWidth - documentWidth);\n}","'use client';\n\nimport * as React from 'react';\nlet globalId = 0;\nfunction useGlobalId(idOverride) {\n  const [defaultId, setDefaultId] = React.useState(idOverride);\n  const id = idOverride || defaultId;\n  React.useEffect(() => {\n    if (defaultId == null) {\n      // Fallback to this default id when possible.\n      // Use the incrementing value for client-side rendering only.\n      // We can't use it server-side.\n      // If you want to use random values please consider the Birthday Problem: https://en.wikipedia.org/wiki/Birthday_problem\n      globalId += 1;\n      setDefaultId(`mui-${globalId}`);\n    }\n  }, [defaultId]);\n  return id;\n}\n\n// downstream bundlers may remove unnecessary concatenation, but won't remove toString call -- Workaround for https://github.com/webpack/webpack/issues/14814\nconst maybeReactUseId = React['useId'.toString()];\n/**\n *\n * @example <div id={useId()} />\n * @param idOverride\n * @returns {string}\n */\nexport default function useId(idOverride) {\n  if (maybeReactUseId !== undefined) {\n    const reactId = maybeReactUseId();\n    return idOverride != null ? idOverride : reactId;\n  }\n  // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.\n  return useGlobalId(idOverride);\n}"],"names":["getBackdropUtilityClass","slot","generateUtilityClass","generateUtilityClasses","_excluded","BackdropRoot","styled","name","overridesResolver","props","styles","ownerState","root","invisible","_ref2","_extends","position","display","alignItems","justifyContent","right","bottom","top","left","backgroundColor","WebkitTapHighlightColor","React","inProps","ref","_slotProps$root","_ref","_slots$root","useThemeProps","children","className","_props$component","component","_props$components","components","_props$componentsProp","componentsProps","_props$invisible","open","_props$slotProps","slotProps","_props$slots","slots","_props$TransitionComp","TransitionComponent","Fade","transitionDuration","other","_objectWithoutPropertiesLoose","classes","composeClasses","useUtilityClasses","rootSlotProps","_jsx","in","timeout","as","Root","clsx","entering","opacity","entered","theme","useTheme","defaultTimeout","enter","transitions","duration","enteringScreen","exit","leavingScreen","addEndListener","_props$appear","appear","easing","inProp","onEnter","onEntered","onEntering","onExit","onExited","onExiting","style","_props$timeout","Transition","nodeRef","handleRef","useForkRef","normalizedTransitionCallback","callback","maybeIsAppearing","node","current","undefined","handleEntering","handleEnter","isAppearing","reflow","transitionProps","getTransitionProps","mode","webkitTransition","create","transition","handleEntered","handleExiting","handleExit","handleExited","next","state","childProps","visibility","getScale","value","concat","Math","pow","transform","isWebKit154","navigator","test","userAgent","Grow","timer","useTimeout","autoTimeout","_getTransitionProps","delay","transitionTimingFunction","getAutoHeightDuration","clientHeight","join","_getTransitionProps2","start","muiSupportAuto","ariaHidden","element","show","setAttribute","removeAttribute","getPaddingRight","parseInt","ownerWindow","getComputedStyle","paddingRight","ariaHiddenSiblings","container","mountElement","currentElement","elementsToExclude","blacklist","_toConsumableArray","forEach","call","isNotExcludedElement","indexOf","isNotForbiddenElement","isForbiddenTagName","tagName","isInputHidden","getAttribute","isAriaHiddenForbiddenOnElement","findIndexOf","items","idx","some","item","index","handleContainer","containerInfo","restoreStyle","disableScrollLock","doc","ownerDocument","body","innerWidth","documentElement","clientWidth","scrollHeight","isOverflowing","scrollbarSize","getScrollbarSize","push","property","el","fixedElements","querySelectorAll","scrollContainer","parentNode","DocumentFragment","parent","parentElement","containerWindow","nodeName","overflowY","overflow","overflowX","setProperty","removeProperty","ModalManager","_classCallCheck","this","containers","modals","_createClass","key","modal","modalIndex","length","modalRef","hiddenSiblings","getHiddenSiblings","mount","containerIndex","restore","ariaHiddenState","arguments","splice","nextTop","defaultManager","useModal","parameters","_parameters$disableEs","disableEscapeKeyDown","_parameters$disableSc","_parameters$manager","manager","_parameters$closeAfte","closeAfterTransition","onTransitionEnter","onTransitionExited","onClose","rootRef","mountNodeRef","_React$useState","_React$useState2","_slicedToArray","exited","setExited","hasTransition","hasOwnProperty","getHasTransition","ariaHiddenProp","getModal","handleMounted","scrollTop","handleOpen","useEventCallback","resolvedContainer","getContainer","add","isTopModal","handlePortalRef","handleClose","remove","createHandleKeyDown","otherHandlers","event","_otherHandlers$onKeyD","onKeyDown","which","stopPropagation","createHandleBackdropClick","_otherHandlers$onClic","onClick","target","currentTarget","getRootProps","propsEventHandlers","extractEventHandlers","externalEventHandlers","role","getBackdropProps","createChainedFunction","portalRef","candidatesSelector","defaultGetTabbable","regularTabNodes","orderedTabNodes","Array","from","i","nodeTabIndex","tabindexAttr","Number","isNaN","contentEditable","tabIndex","getTabIndex","disabled","type","getRadio","selector","querySelector","roving","isNonTabbableRadio","isNodeMatchingSelectorFocusable","documentOrder","sort","a","b","map","defaultIsEnabled","FocusTrap","_props$disableAutoFoc","disableAutoFocus","_props$disableEnforce","disableEnforceFocus","_props$disableRestore","disableRestoreFocus","_props$getTabbable","getTabbable","_props$isEnabled","isEnabled","ignoreNextEnforceFocus","sentinelStart","sentinelEnd","nodeToRestore","reactFocusEventTarget","activated","lastKeydown","contains","activeElement","hasAttribute","focus","loopFocus","nativeEvent","shiftKey","contain","rootElement","hasFocus","tabbable","_lastKeydown$current","_lastKeydown$current2","isShiftTab","Boolean","focusNext","focusPrevious","addEventListener","interval","setInterval","clearInterval","removeEventListener","handleFocusSentinel","relatedTarget","_jsxs","onFocus","childrenPropsHandler","getModalUtilityClass","ModalRoot","hidden","_ref3","zIndex","vars","ModalBackdrop","Backdrop","backdrop","_slots$backdrop","_slotProps$backdrop","_props$BackdropCompon","BackdropComponent","BackdropProps","_props$closeAfterTran","_props$disableEscapeK","_props$disablePortal","disablePortal","_props$disableScrollL","_props$hideBackdrop","hideBackdrop","_props$keepMounted","keepMounted","onBackdropClick","propsWithDefaults","_useModal","RootSlot","BackdropSlot","backdropSlotProps","rootProps","useSlotProps","elementType","externalSlotProps","externalForwardedProps","getSlotProps","additionalProps","backdropProps","e","Portal","forwardedRef","mountNode","setMountNode","useEnhancedEffect","document","setRef","newProps","ReactDOM","_parameters$additiona","_parameters$skipResol","skipResolvingSlotProps","rest","resolvedComponentsProps","resolveComponentProps","_mergeSlotProps","mergeSlotProps","mergedProps","internalRef","appendOwnerState","debounce","_len","funcs","_key","reduce","acc","func","_len2","args","_key2","apply","documentWidth","abs","window","globalId","maybeReactUseId","toString","useId","idOverride","reactId","defaultId","setDefaultId","id","useGlobalId"],"sourceRoot":""}