{"version":3,"file":"javascripts/66353.7b2cdb5916c6919011f3.js","mappings":"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","sources":["webpack:///../../node_modules/@mui/base/ClickAwayListener/ClickAwayListener.js","webpack:///../../node_modules/@mui/base/FocusTrap/FocusTrap.js","webpack:///../../node_modules/@mui/base/generateUtilityClass/index.js","webpack:///../../node_modules/@mui/base/Popper/popperClasses.js","webpack:///../../node_modules/@mui/base/generateUtilityClasses/index.js","webpack:///../../node_modules/@mui/base/utils/ClassNameConfigurator.js","webpack:///../../node_modules/@mui/base/Popper/Popper.js","webpack:///../../node_modules/@mui/base/Portal/Portal.js","webpack:///../../node_modules/@mui/base/TextareaAutosize/TextareaAutosize.js","webpack:///../../node_modules/@mui/base/unstable_useModal/ModalManager.js","webpack:///../../node_modules/@mui/base/unstable_useModal/useModal.js","webpack:///../../node_modules/@mui/base/useSnackbar/useSnackbar.js","webpack:///../../node_modules/@mui/base/utils/appendOwnerState.js","webpack:///../../node_modules/@mui/base/utils/extractEventHandlers.js","webpack:///../../node_modules/@mui/base/utils/isHostComponent.js","webpack:///../../node_modules/@mui/base/utils/omitEventHandlers.js","webpack:///../../node_modules/@mui/base/utils/mergeSlotProps.js","webpack:///../../node_modules/@mui/base/utils/resolveComponentProps.js","webpack:///../../node_modules/@mui/base/utils/useSlotProps.js","webpack:///../../node_modules/@mui/base/node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///../../node_modules/@mui/base/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { elementAcceptingRef, exactProp, unstable_ownerDocument as ownerDocument, unstable_useForkRef as useForkRef, unstable_useEventCallback as useEventCallback } from '@mui/utils';\n\n// TODO: return `EventHandlerName extends `on${infer EventName}` ? Lowercase<EventName> : never` once generatePropTypes runs with TS 4.1\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction mapEventPropToEvent(eventProp) {\n  return eventProp.substring(2).toLowerCase();\n}\nfunction clickedRootScrollbar(event, doc) {\n  return doc.documentElement.clientWidth < event.clientX || doc.documentElement.clientHeight < event.clientY;\n}\n/**\n * Listen for click events that occur somewhere in the document, outside of the element itself.\n * For instance, if you need to hide a menu when people click anywhere else on your page.\n *\n * Demos:\n *\n * - [Click-Away Listener](https://mui.com/base-ui/react-click-away-listener/)\n *\n * API:\n *\n * - [ClickAwayListener API](https://mui.com/base-ui/react-click-away-listener/components-api/#click-away-listener)\n */\nfunction ClickAwayListener(props) {\n  const {\n    children,\n    disableReactTree = false,\n    mouseEvent = 'onClick',\n    onClickAway,\n    touchEvent = 'onTouchEnd'\n  } = props;\n  const movedRef = React.useRef(false);\n  const nodeRef = React.useRef(null);\n  const activatedRef = React.useRef(false);\n  const syntheticEventRef = React.useRef(false);\n  React.useEffect(() => {\n    // Ensure that this component is not \"activated\" synchronously.\n    // https://github.com/facebook/react/issues/20074\n    setTimeout(() => {\n      activatedRef.current = true;\n    }, 0);\n    return () => {\n      activatedRef.current = false;\n    };\n  }, []);\n  const handleRef = useForkRef(\n  // @ts-expect-error TODO upstream fix\n  children.ref, nodeRef);\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  const handleClickAway = useEventCallback(event => {\n    // Given developers can stop the propagation of the synthetic event,\n    // we can only be confident with a positive value.\n    const insideReactTree = syntheticEventRef.current;\n    syntheticEventRef.current = false;\n    const doc = ownerDocument(nodeRef.current);\n\n    // 1. IE11 support, which trigger the handleClickAway even after the unbind\n    // 2. The child might render null.\n    // 3. Behave like a blur listener.\n    if (!activatedRef.current || !nodeRef.current || 'clientX' in event && clickedRootScrollbar(event, doc)) {\n      return;\n    }\n\n    // Do not act if user performed touchmove\n    if (movedRef.current) {\n      movedRef.current = false;\n      return;\n    }\n    let insideDOM;\n\n    // If not enough, can use https://github.com/DieterHolvoet/event-propagation-path/blob/master/propagationPath.js\n    if (event.composedPath) {\n      insideDOM = event.composedPath().indexOf(nodeRef.current) > -1;\n    } else {\n      insideDOM = !doc.documentElement.contains(\n      // @ts-expect-error returns `false` as intended when not dispatched from a Node\n      event.target) || nodeRef.current.contains(\n      // @ts-expect-error returns `false` as intended when not dispatched from a Node\n      event.target);\n    }\n    if (!insideDOM && (disableReactTree || !insideReactTree)) {\n      onClickAway(event);\n    }\n  });\n\n  // Keep track of mouse/touch events that bubbled up through the portal.\n  const createHandleSynthetic = handlerName => event => {\n    syntheticEventRef.current = true;\n    const childrenPropsHandler = children.props[handlerName];\n    if (childrenPropsHandler) {\n      childrenPropsHandler(event);\n    }\n  };\n  const childrenProps = {\n    ref: handleRef\n  };\n  if (touchEvent !== false) {\n    childrenProps[touchEvent] = createHandleSynthetic(touchEvent);\n  }\n  React.useEffect(() => {\n    if (touchEvent !== false) {\n      const mappedTouchEvent = mapEventPropToEvent(touchEvent);\n      const doc = ownerDocument(nodeRef.current);\n      const handleTouchMove = () => {\n        movedRef.current = true;\n      };\n      doc.addEventListener(mappedTouchEvent, handleClickAway);\n      doc.addEventListener('touchmove', handleTouchMove);\n      return () => {\n        doc.removeEventListener(mappedTouchEvent, handleClickAway);\n        doc.removeEventListener('touchmove', handleTouchMove);\n      };\n    }\n    return undefined;\n  }, [handleClickAway, touchEvent]);\n  if (mouseEvent !== false) {\n    childrenProps[mouseEvent] = createHandleSynthetic(mouseEvent);\n  }\n  React.useEffect(() => {\n    if (mouseEvent !== false) {\n      const mappedMouseEvent = mapEventPropToEvent(mouseEvent);\n      const doc = ownerDocument(nodeRef.current);\n      doc.addEventListener(mappedMouseEvent, handleClickAway);\n      return () => {\n        doc.removeEventListener(mappedMouseEvent, handleClickAway);\n      };\n    }\n    return undefined;\n  }, [handleClickAway, mouseEvent]);\n  return /*#__PURE__*/_jsx(React.Fragment, {\n    children: /*#__PURE__*/React.cloneElement(children, childrenProps)\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? ClickAwayListener.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 wrapped element.\n   */\n  children: elementAcceptingRef.isRequired,\n  /**\n   * If `true`, the React tree is ignored and only the DOM tree is considered.\n   * This prop changes how portaled elements are handled.\n   * @default false\n   */\n  disableReactTree: PropTypes.bool,\n  /**\n   * The mouse event to listen to. You can disable the listener by providing `false`.\n   * @default 'onClick'\n   */\n  mouseEvent: PropTypes.oneOf(['onClick', 'onMouseDown', 'onMouseUp', 'onPointerDown', 'onPointerUp', false]),\n  /**\n   * Callback fired when a \"click away\" event is detected.\n   */\n  onClickAway: PropTypes.func.isRequired,\n  /**\n   * The touch event to listen to. You can disable the listener by providing `false`.\n   * @default 'onTouchEnd'\n   */\n  touchEvent: PropTypes.oneOf(['onTouchEnd', 'onTouchStart', false])\n} : void 0;\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  ClickAwayListener['propTypes' + ''] = exactProp(ClickAwayListener.propTypes);\n}\nexport { ClickAwayListener };","'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 { globalStateClasses } from '@mui/utils/generateUtilityClass';\nconst GLOBAL_CLASS_PREFIX = 'base';\nfunction buildStateClass(state) {\n  return `${GLOBAL_CLASS_PREFIX}--${state}`;\n}\nfunction buildSlotClass(componentName, slot) {\n  return `${GLOBAL_CLASS_PREFIX}-${componentName}-${slot}`;\n}\nexport function generateUtilityClass(componentName, slot) {\n  const globalStateClass = globalStateClasses[slot];\n  return globalStateClass ? buildStateClass(globalStateClass) : buildSlotClass(componentName, slot);\n}\nexport function isGlobalState(slot) {\n  return globalStateClasses[slot] !== undefined;\n}","import { generateUtilityClass } from '../generateUtilityClass';\nimport { generateUtilityClasses } from '../generateUtilityClasses';\nconst COMPONENT_NAME = 'Popper';\nexport function getPopperUtilityClass(slot) {\n  return generateUtilityClass(COMPONENT_NAME, slot);\n}\nexport const popperClasses = generateUtilityClasses(COMPONENT_NAME, ['root']);","import { generateUtilityClass } from '../generateUtilityClass';\nexport function generateUtilityClasses(componentName, slots) {\n  const result = {};\n  slots.forEach(slot => {\n    result[slot] = generateUtilityClass(componentName, slot);\n  });\n  return result;\n}","'use client';\n\nimport * as React from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst defaultContextValue = {\n  disableDefaultClasses: false\n};\nconst ClassNameConfiguratorContext = /*#__PURE__*/React.createContext(defaultContextValue);\n/**\n * @ignore - internal hook.\n *\n * Wraps the `generateUtilityClass` function and controls how the classes are generated.\n * Currently it only affects whether the classes are applied or not.\n *\n * @returns Function to be called with the `generateUtilityClass` function specific to a component to generate the classes.\n */\nexport function useClassNamesOverride(generateUtilityClass) {\n  const {\n    disableDefaultClasses\n  } = React.useContext(ClassNameConfiguratorContext);\n  return slot => {\n    if (disableDefaultClasses) {\n      return '';\n    }\n    return generateUtilityClass(slot);\n  };\n}\n\n/**\n * Allows to configure the components within to not apply any built-in classes.\n */\nexport function ClassNameConfigurator(props) {\n  const {\n    disableDefaultClasses,\n    children\n  } = props;\n  const contextValue = React.useMemo(() => ({\n    disableDefaultClasses: disableDefaultClasses != null ? disableDefaultClasses : false\n  }), [disableDefaultClasses]);\n  return /*#__PURE__*/_jsx(ClassNameConfiguratorContext.Provider, {\n    value: contextValue,\n    children: children\n  });\n}","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"anchorEl\", \"children\", \"direction\", \"disablePortal\", \"modifiers\", \"open\", \"placement\", \"popperOptions\", \"popperRef\", \"slotProps\", \"slots\", \"TransitionProps\", \"ownerState\"],\n  _excluded2 = [\"anchorEl\", \"children\", \"container\", \"direction\", \"disablePortal\", \"keepMounted\", \"modifiers\", \"open\", \"placement\", \"popperOptions\", \"popperRef\", \"style\", \"transition\", \"slotProps\", \"slots\"];\nimport * as React from 'react';\nimport { chainPropTypes, HTMLElementType, refType, unstable_ownerDocument as ownerDocument, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useForkRef as useForkRef } from '@mui/utils';\nimport { createPopper } from '@popperjs/core';\nimport PropTypes from 'prop-types';\nimport { unstable_composeClasses as composeClasses } from '../composeClasses';\nimport { Portal } from '../Portal';\nimport { getPopperUtilityClass } from './popperClasses';\nimport { useSlotProps } from '../utils';\nimport { useClassNamesOverride } from '../utils/ClassNameConfigurator';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction flipPlacement(placement, direction) {\n  if (direction === 'ltr') {\n    return placement;\n  }\n  switch (placement) {\n    case 'bottom-end':\n      return 'bottom-start';\n    case 'bottom-start':\n      return 'bottom-end';\n    case 'top-end':\n      return 'top-start';\n    case 'top-start':\n      return 'top-end';\n    default:\n      return placement;\n  }\n}\nfunction resolveAnchorEl(anchorEl) {\n  return typeof anchorEl === 'function' ? anchorEl() : anchorEl;\n}\nfunction isHTMLElement(element) {\n  return element.nodeType !== undefined;\n}\nfunction isVirtualElement(element) {\n  return !isHTMLElement(element);\n}\nconst useUtilityClasses = () => {\n  const slots = {\n    root: ['root']\n  };\n  return composeClasses(slots, useClassNamesOverride(getPopperUtilityClass));\n};\nconst defaultPopperOptions = {};\nconst PopperTooltip = /*#__PURE__*/React.forwardRef(function PopperTooltip(props, forwardedRef) {\n  var _slots$root;\n  const {\n      anchorEl,\n      children,\n      direction,\n      disablePortal,\n      modifiers,\n      open,\n      placement: initialPlacement,\n      popperOptions,\n      popperRef: popperRefProp,\n      slotProps = {},\n      slots = {},\n      TransitionProps\n      // @ts-ignore internal logic\n      // prevent from spreading to DOM, it can come from the parent component e.g. Select.\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const tooltipRef = React.useRef(null);\n  const ownRef = useForkRef(tooltipRef, forwardedRef);\n  const popperRef = React.useRef(null);\n  const handlePopperRef = useForkRef(popperRef, popperRefProp);\n  const handlePopperRefRef = React.useRef(handlePopperRef);\n  useEnhancedEffect(() => {\n    handlePopperRefRef.current = handlePopperRef;\n  }, [handlePopperRef]);\n  React.useImperativeHandle(popperRefProp, () => popperRef.current, []);\n  const rtlPlacement = flipPlacement(initialPlacement, direction);\n  /**\n   * placement initialized from prop but can change during lifetime if modifiers.flip.\n   * modifiers.flip is essentially a flip for controlled/uncontrolled behavior\n   */\n  const [placement, setPlacement] = React.useState(rtlPlacement);\n  const [resolvedAnchorElement, setResolvedAnchorElement] = React.useState(resolveAnchorEl(anchorEl));\n  React.useEffect(() => {\n    if (popperRef.current) {\n      popperRef.current.forceUpdate();\n    }\n  });\n  React.useEffect(() => {\n    if (anchorEl) {\n      setResolvedAnchorElement(resolveAnchorEl(anchorEl));\n    }\n  }, [anchorEl]);\n  useEnhancedEffect(() => {\n    if (!resolvedAnchorElement || !open) {\n      return undefined;\n    }\n    const handlePopperUpdate = data => {\n      setPlacement(data.placement);\n    };\n    if (process.env.NODE_ENV !== 'production') {\n      if (resolvedAnchorElement && isHTMLElement(resolvedAnchorElement) && resolvedAnchorElement.nodeType === 1) {\n        const box = resolvedAnchorElement.getBoundingClientRect();\n        if (process.env.NODE_ENV !== 'test' && box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {\n          console.warn(['MUI: The `anchorEl` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', \"Make sure the element is present in the document or that it's not display none.\"].join('\\n'));\n        }\n      }\n    }\n    let popperModifiers = [{\n      name: 'preventOverflow',\n      options: {\n        altBoundary: disablePortal\n      }\n    }, {\n      name: 'flip',\n      options: {\n        altBoundary: disablePortal\n      }\n    }, {\n      name: 'onUpdate',\n      enabled: true,\n      phase: 'afterWrite',\n      fn: ({\n        state\n      }) => {\n        handlePopperUpdate(state);\n      }\n    }];\n    if (modifiers != null) {\n      popperModifiers = popperModifiers.concat(modifiers);\n    }\n    if (popperOptions && popperOptions.modifiers != null) {\n      popperModifiers = popperModifiers.concat(popperOptions.modifiers);\n    }\n    const popper = createPopper(resolvedAnchorElement, tooltipRef.current, _extends({\n      placement: rtlPlacement\n    }, popperOptions, {\n      modifiers: popperModifiers\n    }));\n    handlePopperRefRef.current(popper);\n    return () => {\n      popper.destroy();\n      handlePopperRefRef.current(null);\n    };\n  }, [resolvedAnchorElement, disablePortal, modifiers, open, popperOptions, rtlPlacement]);\n  const childProps = {\n    placement: placement\n  };\n  if (TransitionProps !== null) {\n    childProps.TransitionProps = TransitionProps;\n  }\n  const classes = useUtilityClasses();\n  const Root = (_slots$root = slots.root) != null ? _slots$root : 'div';\n  const rootProps = useSlotProps({\n    elementType: Root,\n    externalSlotProps: slotProps.root,\n    externalForwardedProps: other,\n    additionalProps: {\n      role: 'tooltip',\n      ref: ownRef\n    },\n    ownerState: props,\n    className: classes.root\n  });\n  return /*#__PURE__*/_jsx(Root, _extends({}, rootProps, {\n    children: typeof children === 'function' ? children(childProps) : children\n  }));\n});\n\n/**\n * Poppers rely on the 3rd party library [Popper.js](https://popper.js.org/docs/v2/) for positioning.\n *\n * Demos:\n *\n * - [Popper](https://mui.com/base-ui/react-popper/)\n *\n * API:\n *\n * - [Popper API](https://mui.com/base-ui/react-popper/components-api/#popper)\n */\nconst Popper = /*#__PURE__*/React.forwardRef(function Popper(props, forwardedRef) {\n  const {\n      anchorEl,\n      children,\n      container: containerProp,\n      direction = 'ltr',\n      disablePortal = false,\n      keepMounted = false,\n      modifiers,\n      open,\n      placement = 'bottom',\n      popperOptions = defaultPopperOptions,\n      popperRef,\n      style,\n      transition = false,\n      slotProps = {},\n      slots = {}\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded2);\n  const [exited, setExited] = React.useState(true);\n  const handleEnter = () => {\n    setExited(false);\n  };\n  const handleExited = () => {\n    setExited(true);\n  };\n  if (!keepMounted && !open && (!transition || exited)) {\n    return null;\n  }\n\n  // If the container prop is provided, use that\n  // If the anchorEl prop is provided, use its parent body element as the container\n  // If neither are provided let the Modal take care of choosing the container\n  let container;\n  if (containerProp) {\n    container = containerProp;\n  } else if (anchorEl) {\n    const resolvedAnchorEl = resolveAnchorEl(anchorEl);\n    container = resolvedAnchorEl && isHTMLElement(resolvedAnchorEl) ? ownerDocument(resolvedAnchorEl).body : ownerDocument(null).body;\n  }\n  const display = !open && keepMounted && (!transition || exited) ? 'none' : undefined;\n  const transitionProps = transition ? {\n    in: open,\n    onEnter: handleEnter,\n    onExited: handleExited\n  } : undefined;\n  return /*#__PURE__*/_jsx(Portal, {\n    disablePortal: disablePortal,\n    container: container,\n    children: /*#__PURE__*/_jsx(PopperTooltip, _extends({\n      anchorEl: anchorEl,\n      direction: direction,\n      disablePortal: disablePortal,\n      modifiers: modifiers,\n      ref: forwardedRef,\n      open: transition ? !exited : open,\n      placement: placement,\n      popperOptions: popperOptions,\n      popperRef: popperRef,\n      slotProps: slotProps,\n      slots: slots\n    }, other, {\n      style: _extends({\n        // Prevents scroll issue, waiting for Popper.js to add this style once initiated.\n        position: 'fixed',\n        // Fix Popper.js display issue\n        top: 0,\n        left: 0,\n        display\n      }, style),\n      TransitionProps: transitionProps,\n      children: children\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? Popper.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   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),\n   * or a function that returns either.\n   * It's used to set the position of the popper.\n   * The return value will passed as the reference object of the Popper instance.\n   */\n  anchorEl: chainPropTypes(PropTypes.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]), props => {\n    if (props.open) {\n      const resolvedAnchorEl = resolveAnchorEl(props.anchorEl);\n      if (resolvedAnchorEl && isHTMLElement(resolvedAnchorEl) && resolvedAnchorEl.nodeType === 1) {\n        const box = resolvedAnchorEl.getBoundingClientRect();\n        if (process.env.NODE_ENV !== 'test' && box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {\n          return new Error(['MUI: The `anchorEl` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', \"Make sure the element is present in the document or that it's not display none.\"].join('\\n'));\n        }\n      } else if (!resolvedAnchorEl || typeof resolvedAnchorEl.getBoundingClientRect !== 'function' || isVirtualElement(resolvedAnchorEl) && resolvedAnchorEl.contextElement != null && resolvedAnchorEl.contextElement.nodeType !== 1) {\n        return new Error(['MUI: The `anchorEl` prop provided to the component is invalid.', 'It should be an HTML element instance or a virtualElement ', '(https://popper.js.org/docs/v2/virtual-elements/).'].join('\\n'));\n      }\n    }\n    return null;\n  }),\n  /**\n   * Popper render function or node.\n   */\n  children: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.node, PropTypes.func]),\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   * Direction of the text.\n   * @default 'ltr'\n   */\n  direction: PropTypes.oneOf(['ltr', 'rtl']),\n  /**\n   * The `children` will be under the DOM hierarchy of the parent component.\n   * @default false\n   */\n  disablePortal: 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 Popper.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Popper.js is based on a \"plugin-like\" architecture,\n   * most of its features are fully encapsulated \"modifiers\".\n   *\n   * A modifier is a function that is called each time Popper.js needs to\n   * compute the position of the popper.\n   * For this reason, modifiers should be very performant to avoid bottlenecks.\n   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).\n   */\n  modifiers: PropTypes.arrayOf(PropTypes.shape({\n    data: PropTypes.object,\n    effect: PropTypes.func,\n    enabled: PropTypes.bool,\n    fn: PropTypes.func,\n    name: PropTypes.any,\n    options: PropTypes.object,\n    phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),\n    requires: PropTypes.arrayOf(PropTypes.string),\n    requiresIfExists: PropTypes.arrayOf(PropTypes.string)\n  })),\n  /**\n   * If `true`, the component is shown.\n   */\n  open: PropTypes.bool.isRequired,\n  /**\n   * Popper placement.\n   * @default 'bottom'\n   */\n  placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),\n  /**\n   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.\n   * @default {}\n   */\n  popperOptions: PropTypes.shape({\n    modifiers: PropTypes.array,\n    onFirstUpdate: PropTypes.func,\n    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),\n    strategy: PropTypes.oneOf(['absolute', 'fixed'])\n  }),\n  /**\n   * A ref that points to the used popper instance.\n   */\n  popperRef: refType,\n  /**\n   * The props used for each slot inside the Popper.\n   * @default {}\n   */\n  slotProps: PropTypes.shape({\n    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])\n  }),\n  /**\n   * The components used for each slot inside the Popper.\n   * Either a string to use a HTML element or a component.\n   * @default {}\n   */\n  slots: PropTypes.shape({\n    root: PropTypes.elementType\n  }),\n  /**\n   * Help supporting a react-transition-group/Transition component.\n   * @default false\n   */\n  transition: PropTypes.bool\n} : void 0;\nexport { Popper };","'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 = [\"onChange\", \"maxRows\", \"minRows\", \"style\", \"value\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport * as ReactDOM from 'react-dom';\nimport { unstable_debounce as debounce, unstable_useForkRef as useForkRef, unstable_useEnhancedEffect as useEnhancedEffect, unstable_ownerWindow as ownerWindow } from '@mui/utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction getStyleValue(value) {\n  return parseInt(value, 10) || 0;\n}\nconst styles = {\n  shadow: {\n    // Visibility needed to hide the extra text area on iPads\n    visibility: 'hidden',\n    // Remove from the content flow\n    position: 'absolute',\n    // Ignore the scrollbar width\n    overflow: 'hidden',\n    height: 0,\n    top: 0,\n    left: 0,\n    // Create a new layer, increase the isolation of the computed values\n    transform: 'translateZ(0)'\n  }\n};\nfunction isEmpty(obj) {\n  return obj === undefined || obj === null || Object.keys(obj).length === 0 || obj.outerHeightStyle === 0 && !obj.overflow;\n}\n\n/**\n *\n * Demos:\n *\n * - [Textarea Autosize](https://mui.com/base-ui/react-textarea-autosize/)\n * - [Textarea Autosize](https://mui.com/material-ui/react-textarea-autosize/)\n *\n * API:\n *\n * - [TextareaAutosize API](https://mui.com/base-ui/react-textarea-autosize/components-api/#textarea-autosize)\n */\nconst TextareaAutosize = /*#__PURE__*/React.forwardRef(function TextareaAutosize(props, forwardedRef) {\n  const {\n      onChange,\n      maxRows,\n      minRows = 1,\n      style,\n      value\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const {\n    current: isControlled\n  } = React.useRef(value != null);\n  const inputRef = React.useRef(null);\n  const handleRef = useForkRef(forwardedRef, inputRef);\n  const shadowRef = React.useRef(null);\n  const renders = React.useRef(0);\n  const [state, setState] = React.useState({\n    outerHeightStyle: 0\n  });\n  const getUpdatedState = React.useCallback(() => {\n    const input = inputRef.current;\n    const containerWindow = ownerWindow(input);\n    const computedStyle = containerWindow.getComputedStyle(input);\n\n    // If input's width is shrunk and it's not visible, don't sync height.\n    if (computedStyle.width === '0px') {\n      return {\n        outerHeightStyle: 0\n      };\n    }\n    const inputShallow = shadowRef.current;\n    inputShallow.style.width = computedStyle.width;\n    inputShallow.value = input.value || props.placeholder || 'x';\n    if (inputShallow.value.slice(-1) === '\\n') {\n      // Certain fonts which overflow the line height will cause the textarea\n      // to report a different scrollHeight depending on whether the last line\n      // is empty. Make it non-empty to avoid this issue.\n      inputShallow.value += ' ';\n    }\n    const boxSizing = computedStyle.boxSizing;\n    const padding = getStyleValue(computedStyle.paddingBottom) + getStyleValue(computedStyle.paddingTop);\n    const border = getStyleValue(computedStyle.borderBottomWidth) + getStyleValue(computedStyle.borderTopWidth);\n\n    // The height of the inner content\n    const innerHeight = inputShallow.scrollHeight;\n\n    // Measure height of a textarea with a single row\n    inputShallow.value = 'x';\n    const singleRowHeight = inputShallow.scrollHeight;\n\n    // The height of the outer content\n    let outerHeight = innerHeight;\n    if (minRows) {\n      outerHeight = Math.max(Number(minRows) * singleRowHeight, outerHeight);\n    }\n    if (maxRows) {\n      outerHeight = Math.min(Number(maxRows) * singleRowHeight, outerHeight);\n    }\n    outerHeight = Math.max(outerHeight, singleRowHeight);\n\n    // Take the box sizing into account for applying this value as a style.\n    const outerHeightStyle = outerHeight + (boxSizing === 'border-box' ? padding + border : 0);\n    const overflow = Math.abs(outerHeight - innerHeight) <= 1;\n    return {\n      outerHeightStyle,\n      overflow\n    };\n  }, [maxRows, minRows, props.placeholder]);\n  const updateState = (prevState, newState) => {\n    const {\n      outerHeightStyle,\n      overflow\n    } = newState;\n    // Need a large enough difference to update the height.\n    // This prevents infinite rendering loop.\n    if (renders.current < 20 && (outerHeightStyle > 0 && Math.abs((prevState.outerHeightStyle || 0) - outerHeightStyle) > 1 || prevState.overflow !== overflow)) {\n      renders.current += 1;\n      return {\n        overflow,\n        outerHeightStyle\n      };\n    }\n    if (process.env.NODE_ENV !== 'production') {\n      if (renders.current === 20) {\n        console.error(['MUI: Too many re-renders. The layout is unstable.', 'TextareaAutosize limits the number of renders to prevent an infinite loop.'].join('\\n'));\n      }\n    }\n    return prevState;\n  };\n  const syncHeight = React.useCallback(() => {\n    const newState = getUpdatedState();\n    if (isEmpty(newState)) {\n      return;\n    }\n    setState(prevState => updateState(prevState, newState));\n  }, [getUpdatedState]);\n  useEnhancedEffect(() => {\n    const syncHeightWithFlushSync = () => {\n      const newState = getUpdatedState();\n      if (isEmpty(newState)) {\n        return;\n      }\n\n      // In React 18, state updates in a ResizeObserver's callback are happening after\n      // the paint, this leads to an infinite rendering.\n      //\n      // Using flushSync ensures that the states is updated before the next pain.\n      // Related issue - https://github.com/facebook/react/issues/24331\n      ReactDOM.flushSync(() => {\n        setState(prevState => updateState(prevState, newState));\n      });\n    };\n    const handleResize = () => {\n      renders.current = 0;\n      syncHeightWithFlushSync();\n    };\n    // Workaround a \"ResizeObserver loop completed with undelivered notifications\" error\n    // in test.\n    // Note that we might need to use this logic in production per https://github.com/WICG/resize-observer/issues/38\n    // Also see https://github.com/mui/mui-x/issues/8733\n    let rAF;\n    const rAFHandleResize = () => {\n      cancelAnimationFrame(rAF);\n      rAF = requestAnimationFrame(() => {\n        handleResize();\n      });\n    };\n    const debounceHandleResize = debounce(handleResize);\n    const input = inputRef.current;\n    const containerWindow = ownerWindow(input);\n    containerWindow.addEventListener('resize', debounceHandleResize);\n    let resizeObserver;\n    if (typeof ResizeObserver !== 'undefined') {\n      resizeObserver = new ResizeObserver(process.env.NODE_ENV === 'test' ? rAFHandleResize : handleResize);\n      resizeObserver.observe(input);\n    }\n    return () => {\n      debounceHandleResize.clear();\n      cancelAnimationFrame(rAF);\n      containerWindow.removeEventListener('resize', debounceHandleResize);\n      if (resizeObserver) {\n        resizeObserver.disconnect();\n      }\n    };\n  }, [getUpdatedState]);\n  useEnhancedEffect(() => {\n    syncHeight();\n  });\n  React.useEffect(() => {\n    renders.current = 0;\n  }, [value]);\n  const handleChange = event => {\n    renders.current = 0;\n    if (!isControlled) {\n      syncHeight();\n    }\n    if (onChange) {\n      onChange(event);\n    }\n  };\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [/*#__PURE__*/_jsx(\"textarea\", _extends({\n      value: value,\n      onChange: handleChange,\n      ref: handleRef\n      // Apply the rows prop to get a \"correct\" first SSR paint\n      ,\n      rows: minRows,\n      style: _extends({\n        height: state.outerHeightStyle,\n        // Need a large enough difference to allow scrolling.\n        // This prevents infinite rendering loop.\n        overflow: state.overflow ? 'hidden' : undefined\n      }, style)\n    }, other)), /*#__PURE__*/_jsx(\"textarea\", {\n      \"aria-hidden\": true,\n      className: props.className,\n      readOnly: true,\n      ref: shadowRef,\n      tabIndex: -1,\n      style: _extends({}, styles.shadow, style, {\n        paddingTop: 0,\n        paddingBottom: 0\n      })\n    })]\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? TextareaAutosize.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  className: PropTypes.string,\n  /**\n   * Maximum number of rows to display.\n   */\n  maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n  /**\n   * Minimum number of rows to display.\n   * @default 1\n   */\n  minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  onChange: PropTypes.func,\n  /**\n   * @ignore\n   */\n  placeholder: PropTypes.string,\n  /**\n   * @ignore\n   */\n  style: PropTypes.object,\n  /**\n   * @ignore\n   */\n  value: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.number, PropTypes.string])\n} : void 0;\nexport { TextareaAutosize };","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\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_useEventCallback as useEventCallback, unstable_useTimeout as useTimeout } from '@mui/utils';\nimport { extractEventHandlers } from '../utils/extractEventHandlers';\n/**\n * The basic building block for creating custom snackbar.\n *\n * Demos:\n *\n * - [Snackbar](https://mui.com/base-ui/react-snackbar/#hook)\n *\n * API:\n *\n * - [useSnackbar API](https://mui.com/base-ui/react-snackbar/hooks-api/#use-snackbar)\n */\nexport function useSnackbar(parameters = {}) {\n  const {\n    autoHideDuration = null,\n    disableWindowBlurListener = false,\n    onClose,\n    open,\n    resumeHideDuration\n  } = parameters;\n  const timerAutoHide = useTimeout();\n  React.useEffect(() => {\n    if (!open) {\n      return undefined;\n    }\n\n    /**\n     * @param {KeyboardEvent} nativeEvent\n     */\n    function handleKeyDown(nativeEvent) {\n      if (!nativeEvent.defaultPrevented) {\n        // IE11, Edge (prior to using Blink?) use 'Esc'\n        if (nativeEvent.key === 'Escape' || nativeEvent.key === 'Esc') {\n          // not calling `preventDefault` since we don't know if people may ignore this event e.g. a permanently open snackbar\n          onClose == null || onClose(nativeEvent, 'escapeKeyDown');\n        }\n      }\n    }\n    document.addEventListener('keydown', handleKeyDown);\n    return () => {\n      document.removeEventListener('keydown', handleKeyDown);\n    };\n  }, [open, onClose]);\n  const handleClose = useEventCallback((event, reason) => {\n    onClose == null || onClose(event, reason);\n  });\n  const setAutoHideTimer = useEventCallback(autoHideDurationParam => {\n    if (!onClose || autoHideDurationParam == null) {\n      return;\n    }\n    timerAutoHide.start(autoHideDurationParam, () => {\n      handleClose(null, 'timeout');\n    });\n  });\n  React.useEffect(() => {\n    if (open) {\n      setAutoHideTimer(autoHideDuration);\n    }\n    return timerAutoHide.clear;\n  }, [open, autoHideDuration, setAutoHideTimer, timerAutoHide]);\n  const handleClickAway = event => {\n    onClose == null || onClose(event, 'clickaway');\n  };\n\n  // Pause the timer when the user is interacting with the Snackbar\n  // or when the user hide the window.\n  const handlePause = timerAutoHide.clear;\n\n  // Restart the timer when the user is no longer interacting with the Snackbar\n  // or when the window is shown back.\n  const handleResume = React.useCallback(() => {\n    if (autoHideDuration != null) {\n      setAutoHideTimer(resumeHideDuration != null ? resumeHideDuration : autoHideDuration * 0.5);\n    }\n  }, [autoHideDuration, resumeHideDuration, setAutoHideTimer]);\n  const createHandleBlur = otherHandlers => event => {\n    const onBlurCallback = otherHandlers.onBlur;\n    onBlurCallback == null || onBlurCallback(event);\n    handleResume();\n  };\n  const createHandleFocus = otherHandlers => event => {\n    const onFocusCallback = otherHandlers.onFocus;\n    onFocusCallback == null || onFocusCallback(event);\n    handlePause();\n  };\n  const createMouseEnter = otherHandlers => event => {\n    const onMouseEnterCallback = otherHandlers.onMouseEnter;\n    onMouseEnterCallback == null || onMouseEnterCallback(event);\n    handlePause();\n  };\n  const createMouseLeave = otherHandlers => event => {\n    const onMouseLeaveCallback = otherHandlers.onMouseLeave;\n    onMouseLeaveCallback == null || onMouseLeaveCallback(event);\n    handleResume();\n  };\n  React.useEffect(() => {\n    // TODO: window global should be refactored here\n    if (!disableWindowBlurListener && open) {\n      window.addEventListener('focus', handleResume);\n      window.addEventListener('blur', handlePause);\n      return () => {\n        window.removeEventListener('focus', handleResume);\n        window.removeEventListener('blur', handlePause);\n      };\n    }\n    return undefined;\n  }, [disableWindowBlurListener, open, handleResume, handlePause]);\n  const getRootProps = (externalProps = {}) => {\n    const externalEventHandlers = _extends({}, extractEventHandlers(parameters), extractEventHandlers(externalProps));\n    return _extends({\n      // ClickAwayListener adds an `onClick` prop which results in the alert not being announced.\n      // See https://github.com/mui/material-ui/issues/29080\n      role: 'presentation'\n    }, externalProps, externalEventHandlers, {\n      onBlur: createHandleBlur(externalEventHandlers),\n      onFocus: createHandleFocus(externalEventHandlers),\n      onMouseEnter: createMouseEnter(externalEventHandlers),\n      onMouseLeave: createMouseLeave(externalEventHandlers)\n    });\n  };\n  return {\n    getRootProps,\n    onClickAway: handleClickAway\n  };\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { isHostComponent } from './isHostComponent';\n\n/**\n * Type of the ownerState based on the type of an element it applies to.\n * This resolves to the provided OwnerState for React components and `undefined` for host components.\n * Falls back to `OwnerState | undefined` when the exact type can't be determined in development time.\n */\n\n/**\n * Appends the ownerState object to the props, merging with the existing one if necessary.\n *\n * @param elementType Type of the element that owns the `existingProps`. If the element is a DOM node or undefined, `ownerState` is not applied.\n * @param otherProps Props of the element.\n * @param ownerState\n */\nexport function appendOwnerState(elementType, otherProps, ownerState) {\n  if (elementType === undefined || isHostComponent(elementType)) {\n    return otherProps;\n  }\n  return _extends({}, otherProps, {\n    ownerState: _extends({}, otherProps.ownerState, ownerState)\n  });\n}","/**\n * Extracts event handlers from a given object.\n * A prop is considered an event handler if it is a function and its name starts with `on`.\n *\n * @param object An object to extract event handlers from.\n * @param excludeKeys An array of keys to exclude from the returned object.\n */\nexport function extractEventHandlers(object, excludeKeys = []) {\n  if (object === undefined) {\n    return {};\n  }\n  const result = {};\n  Object.keys(object).filter(prop => prop.match(/^on[A-Z]/) && typeof object[prop] === 'function' && !excludeKeys.includes(prop)).forEach(prop => {\n    result[prop] = object[prop];\n  });\n  return result;\n}","/**\n * Determines if a given element is a DOM element name (i.e. not a React component).\n */\nexport function isHostComponent(element) {\n  return typeof element === 'string';\n}","/**\n * Removes event handlers from the given object.\n * A field is considered an event handler if it is a function with a name beginning with `on`.\n *\n * @param object Object to remove event handlers from.\n * @returns Object with event handlers removed.\n */\nexport function omitEventHandlers(object) {\n  if (object === undefined) {\n    return {};\n  }\n  const result = {};\n  Object.keys(object).filter(prop => !(prop.match(/^on[A-Z]/) && typeof object[prop] === 'function')).forEach(prop => {\n    result[prop] = object[prop];\n  });\n  return result;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport clsx from 'clsx';\nimport { extractEventHandlers } from './extractEventHandlers';\nimport { omitEventHandlers } from './omitEventHandlers';\n/**\n * Merges the slot component internal props (usually coming from a hook)\n * with the externally provided ones.\n *\n * The merge order is (the latter overrides the former):\n * 1. The internal props (specified as a getter function to work with get*Props hook result)\n * 2. Additional props (specified internally on a Base UI component)\n * 3. External props specified on the owner component. These should only be used on a root slot.\n * 4. External props specified in the `slotProps.*` prop.\n * 5. The `className` prop - combined from all the above.\n * @param parameters\n * @returns\n */\nexport function mergeSlotProps(parameters) {\n  const {\n    getSlotProps,\n    additionalProps,\n    externalSlotProps,\n    externalForwardedProps,\n    className\n  } = parameters;\n  if (!getSlotProps) {\n    // The simpler case - getSlotProps is not defined, so no internal event handlers are defined,\n    // so we can simply merge all the props without having to worry about extracting event handlers.\n    const joinedClasses = clsx(additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);\n    const mergedStyle = _extends({}, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);\n    const props = _extends({}, additionalProps, externalForwardedProps, externalSlotProps);\n    if (joinedClasses.length > 0) {\n      props.className = joinedClasses;\n    }\n    if (Object.keys(mergedStyle).length > 0) {\n      props.style = mergedStyle;\n    }\n    return {\n      props,\n      internalRef: undefined\n    };\n  }\n\n  // In this case, getSlotProps is responsible for calling the external event handlers.\n  // We don't need to include them in the merged props because of this.\n\n  const eventHandlers = extractEventHandlers(_extends({}, externalForwardedProps, externalSlotProps));\n  const componentsPropsWithoutEventHandlers = omitEventHandlers(externalSlotProps);\n  const otherPropsWithoutEventHandlers = omitEventHandlers(externalForwardedProps);\n  const internalSlotProps = getSlotProps(eventHandlers);\n\n  // The order of classes is important here.\n  // Emotion (that we use in libraries consuming Base UI) depends on this order\n  // to properly override style. It requires the most important classes to be last\n  // (see https://github.com/mui/material-ui/pull/33205) for the related discussion.\n  const joinedClasses = clsx(internalSlotProps == null ? void 0 : internalSlotProps.className, additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);\n  const mergedStyle = _extends({}, internalSlotProps == null ? void 0 : internalSlotProps.style, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);\n  const props = _extends({}, internalSlotProps, additionalProps, otherPropsWithoutEventHandlers, componentsPropsWithoutEventHandlers);\n  if (joinedClasses.length > 0) {\n    props.className = joinedClasses;\n  }\n  if (Object.keys(mergedStyle).length > 0) {\n    props.style = mergedStyle;\n  }\n  return {\n    props,\n    internalRef: internalSlotProps.ref\n  };\n}","/**\n * If `componentProps` is a function, calls it with the provided `ownerState`.\n * Otherwise, just returns `componentProps`.\n */\nexport function resolveComponentProps(componentProps, ownerState, slotState) {\n  if (typeof componentProps === 'function') {\n    return componentProps(ownerState, slotState);\n  }\n  return componentProps;\n}","'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}","function _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nexport { _extends as default };","function _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (-1 !== e.indexOf(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nexport { _objectWithoutPropertiesLoose as default };"],"names":["mapEventPropToEvent","eventProp","substring","toLowerCase","ClickAwayListener","props","children","disableReactTree","mouseEvent","onClickAway","touchEvent","movedRef","nodeRef","activatedRef","syntheticEventRef","setTimeout","current","handleRef","ref","handleClickAway","event","insideReactTree","doc","documentElement","clientWidth","clientX","clientHeight","clientY","clickedRootScrollbar","insideDOM","composedPath","indexOf","contains","target","createHandleSynthetic","handlerName","childrenPropsHandler","childrenProps","mappedTouchEvent","handleTouchMove","addEventListener","removeEventListener","mappedMouseEvent","candidatesSelector","join","defaultGetTabbable","root","regularTabNodes","orderedTabNodes","Array","from","querySelectorAll","forEach","node","i","nodeTabIndex","tabindexAttr","parseInt","getAttribute","Number","isNaN","contentEditable","nodeName","tabIndex","getTabIndex","disabled","tagName","type","name","getRadio","selector","ownerDocument","querySelector","roving","isNonTabbableRadio","isNodeMatchingSelectorFocusable","push","documentOrder","sort","a","b","map","concat","defaultIsEnabled","FocusTrap","disableAutoFocus","disableEnforceFocus","disableRestoreFocus","getTabbable","isEnabled","open","ignoreNextEnforceFocus","sentinelStart","sentinelEnd","nodeToRestore","reactFocusEventTarget","activated","rootRef","lastKeydown","activeElement","hasAttribute","setAttribute","focus","loopFocus","nativeEvent","key","shiftKey","contain","rootElement","hasFocus","tabbable","length","_lastKeydown$current","_lastKeydown$current2","isShiftTab","Boolean","focusNext","focusPrevious","interval","setInterval","clearInterval","handleFocusSentinel","relatedTarget","onFocus","GLOBAL_CLASS_PREFIX","componentName","slot","globalStateClass","buildSlotClass","COMPONENT_NAME","getPopperUtilityClass","slots","result","generateUtilityClasses","defaultContextValue","disableDefaultClasses","ClassNameConfiguratorContext","_excluded","_excluded2","resolveAnchorEl","anchorEl","isHTMLElement","element","undefined","nodeType","useUtilityClasses","composeClasses","generateUtilityClass","useClassNamesOverride","defaultPopperOptions","PopperTooltip","forwardedRef","_slots$root","direction","disablePortal","modifiers","placement","initialPlacement","popperOptions","popperRef","popperRefProp","slotProps","TransitionProps","other","tooltipRef","ownRef","useForkRef","handlePopperRef","handlePopperRefRef","useEnhancedEffect","rtlPlacement","flipPlacement","setPlacement","resolvedAnchorElement","setResolvedAnchorElement","forceUpdate","popperModifiers","options","altBoundary","enabled","phase","fn","state","popper","destroy","childProps","classes","Root","rootProps","useSlotProps","elementType","externalSlotProps","externalForwardedProps","additionalProps","role","ownerState","className","Popper","container","containerProp","keepMounted","style","transition","exited","setExited","resolvedAnchorEl","body","display","transitionProps","in","onEnter","onExited","Portal","position","top","left","mountNode","setMountNode","getContainer","document","newProps","getStyleValue","value","styles","visibility","overflow","height","transform","isEmpty","obj","Object","keys","outerHeightStyle","TextareaAutosize","onChange","maxRows","minRows","isControlled","inputRef","shadowRef","renders","setState","getUpdatedState","input","computedStyle","getComputedStyle","width","inputShallow","placeholder","slice","boxSizing","padding","paddingBottom","paddingTop","border","borderBottomWidth","borderTopWidth","innerHeight","scrollHeight","singleRowHeight","outerHeight","Math","max","min","abs","updateState","prevState","newState","syncHeight","handleResize","syncHeightWithFlushSync","rAF","debounceHandleResize","containerWindow","resizeObserver","ResizeObserver","observe","clear","cancelAnimationFrame","disconnect","rows","readOnly","ariaHidden","show","removeAttribute","getPaddingRight","ownerWindow","paddingRight","ariaHiddenSiblings","mountElement","currentElement","elementsToExclude","blacklist","call","isNotExcludedElement","isNotForbiddenElement","isForbiddenTagName","isInputHidden","isAriaHiddenForbiddenOnElement","findIndexOf","items","callback","idx","some","item","index","handleContainer","containerInfo","restoreStyle","disableScrollLock","innerWidth","isOverflowing","scrollbarSize","getScrollbarSize","property","el","fixedElements","scrollContainer","parentNode","DocumentFragment","parent","parentElement","overflowY","overflowX","setProperty","removeProperty","defaultManager","constructor","this","containers","modals","add","modal","modalIndex","modalRef","hiddenSiblings","getHiddenSiblings","mount","containerIndex","restore","remove","ariaHiddenState","splice","nextTop","isTopModal","useModal","parameters","disableEscapeKeyDown","manager","closeAfterTransition","onTransitionEnter","onTransitionExited","onClose","mountNodeRef","hasTransition","hasOwnProperty","getHasTransition","ariaHiddenProp","getModal","handleMounted","scrollTop","handleOpen","useEventCallback","resolvedContainer","handlePortalRef","handleClose","createHandleKeyDown","otherHandlers","_otherHandlers$onKeyD","onKeyDown","which","stopPropagation","createHandleBackdropClick","_otherHandlers$onClic","onClick","currentTarget","getRootProps","propsEventHandlers","extractEventHandlers","externalEventHandlers","getBackdropProps","getTransitionProps","createChainedFunction","portalRef","useSnackbar","autoHideDuration","disableWindowBlurListener","resumeHideDuration","timerAutoHide","handleKeyDown","defaultPrevented","reason","setAutoHideTimer","autoHideDurationParam","start","handlePause","handleResume","createHandleFocus","onFocusCallback","createMouseEnter","onMouseEnterCallback","onMouseEnter","createMouseLeave","onMouseLeaveCallback","onMouseLeave","window","externalProps","onBlur","onBlurCallback","appendOwnerState","otherProps","object","excludeKeys","filter","prop","match","includes","isHostComponent","omitEventHandlers","mergeSlotProps","getSlotProps","joinedClasses","mergedStyle","internalRef","eventHandlers","componentsPropsWithoutEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","resolveComponentProps","componentProps","slotState","_parameters$additiona","skipResolvingSlotProps","rest","resolvedComponentsProps","mergedProps","_extends","assign","bind","n","e","arguments","t","r","apply","_objectWithoutPropertiesLoose"],"sourceRoot":""}