{"version":3,"file":"js/vendors-57f73536-344e666720af0f9b94b6.js","mappings":"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","sources":["webpack://matchboards/./node_modules/@mui/base/ClickAwayListener/ClickAwayListener.js","webpack://matchboards/./node_modules/@mui/base/FocusTrap/FocusTrap.js","webpack://matchboards/./node_modules/@mui/base/generateUtilityClass/index.js","webpack://matchboards/./node_modules/@mui/base/Popper/popperClasses.js","webpack://matchboards/./node_modules/@mui/base/generateUtilityClasses/index.js","webpack://matchboards/./node_modules/@mui/base/utils/ClassNameConfigurator.js","webpack://matchboards/./node_modules/@mui/base/Popper/Popper.js","webpack://matchboards/./node_modules/@mui/base/Portal/Portal.js","webpack://matchboards/./node_modules/@mui/base/TextareaAutosize/TextareaAutosize.js","webpack://matchboards/./node_modules/@mui/base/unstable_useModal/ModalManager.js","webpack://matchboards/./node_modules/@mui/base/unstable_useModal/useModal.js","webpack://matchboards/./node_modules/@mui/base/useAutocomplete/useAutocomplete.js","webpack://matchboards/./node_modules/@mui/base/useSlider/useSlider.js","webpack://matchboards/./node_modules/@mui/base/utils/areArraysEqual.js","webpack://matchboards/./node_modules/@mui/base/useSnackbar/useSnackbar.js","webpack://matchboards/./node_modules/@mui/base/utils/appendOwnerState.js","webpack://matchboards/./node_modules/@mui/base/utils/extractEventHandlers.js","webpack://matchboards/./node_modules/@mui/base/utils/isHostComponent.js","webpack://matchboards/./node_modules/@mui/base/utils/omitEventHandlers.js","webpack://matchboards/./node_modules/@mui/base/utils/mergeSlotProps.js","webpack://matchboards/./node_modules/@mui/base/utils/resolveComponentProps.js","webpack://matchboards/./node_modules/@mui/base/utils/useSlotProps.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    // for example 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);\nif (process.env.NODE_ENV !== 'production') {\n  ClassNameConfiguratorContext.displayName = 'ClassNameConfiguratorContext';\n}\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 { 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.overflowing;\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 calculateTextareaStyles = 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        overflowing: false\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 overflowing = Math.abs(outerHeight - innerHeight) <= 1;\n    return {\n      outerHeightStyle,\n      overflowing\n    };\n  }, [maxRows, minRows, props.placeholder]);\n  const syncHeight = React.useCallback(() => {\n    const textareaStyles = calculateTextareaStyles();\n    if (isEmpty(textareaStyles)) {\n      return;\n    }\n    const input = inputRef.current;\n    input.style.height = `${textareaStyles.outerHeightStyle}px`;\n    input.style.overflow = textareaStyles.overflowing ? 'hidden' : '';\n  }, [calculateTextareaStyles]);\n  useEnhancedEffect(() => {\n    const handleResize = () => {\n      syncHeight();\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  }, [calculateTextareaStyles, syncHeight]);\n  useEnhancedEffect(() => {\n    syncHeight();\n  });\n  const handleChange = event => {\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: 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\n/* eslint-disable no-constant-condition */\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_setRef as setRef, unstable_useEventCallback as useEventCallback, unstable_useControlled as useControlled, unstable_useId as useId, usePreviousProps } from '@mui/utils';\n\n// https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript\n// Give up on IE11 support for this feature\nfunction stripDiacritics(string) {\n  return typeof string.normalize !== 'undefined' ? string.normalize('NFD').replace(/[\\u0300-\\u036f]/g, '') : string;\n}\nexport function createFilterOptions(config = {}) {\n  const {\n    ignoreAccents = true,\n    ignoreCase = true,\n    limit,\n    matchFrom = 'any',\n    stringify,\n    trim = false\n  } = config;\n  return (options, {\n    inputValue,\n    getOptionLabel\n  }) => {\n    let input = trim ? inputValue.trim() : inputValue;\n    if (ignoreCase) {\n      input = input.toLowerCase();\n    }\n    if (ignoreAccents) {\n      input = stripDiacritics(input);\n    }\n    const filteredOptions = !input ? options : options.filter(option => {\n      let candidate = (stringify || getOptionLabel)(option);\n      if (ignoreCase) {\n        candidate = candidate.toLowerCase();\n      }\n      if (ignoreAccents) {\n        candidate = stripDiacritics(candidate);\n      }\n      return matchFrom === 'start' ? candidate.indexOf(input) === 0 : candidate.indexOf(input) > -1;\n    });\n    return typeof limit === 'number' ? filteredOptions.slice(0, limit) : filteredOptions;\n  };\n}\n\n// To replace with .findIndex() once we stop IE11 support.\nfunction findIndex(array, comp) {\n  for (let i = 0; i < array.length; i += 1) {\n    if (comp(array[i])) {\n      return i;\n    }\n  }\n  return -1;\n}\nconst defaultFilterOptions = createFilterOptions();\n\n// Number of options to jump in list box when `Page Up` and `Page Down` keys are used.\nconst pageSize = 5;\nconst defaultIsActiveElementInListbox = listboxRef => {\n  var _listboxRef$current$p;\n  return listboxRef.current !== null && ((_listboxRef$current$p = listboxRef.current.parentElement) == null ? void 0 : _listboxRef$current$p.contains(document.activeElement));\n};\nexport function useAutocomplete(props) {\n  const {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    unstable_isActiveElementInListbox = defaultIsActiveElementInListbox,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    unstable_classNamePrefix = 'Mui',\n    autoComplete = false,\n    autoHighlight = false,\n    autoSelect = false,\n    blurOnSelect = false,\n    clearOnBlur = !props.freeSolo,\n    clearOnEscape = false,\n    componentName = 'useAutocomplete',\n    defaultValue = props.multiple ? [] : null,\n    disableClearable = false,\n    disableCloseOnSelect = false,\n    disabled: disabledProp,\n    disabledItemsFocusable = false,\n    disableListWrap = false,\n    filterOptions = defaultFilterOptions,\n    filterSelectedOptions = false,\n    freeSolo = false,\n    getOptionDisabled,\n    getOptionKey,\n    getOptionLabel: getOptionLabelProp = option => {\n      var _option$label;\n      return (_option$label = option.label) != null ? _option$label : option;\n    },\n    groupBy,\n    handleHomeEndKeys = !props.freeSolo,\n    id: idProp,\n    includeInputInList = false,\n    inputValue: inputValueProp,\n    isOptionEqualToValue = (option, value) => option === value,\n    multiple = false,\n    onChange,\n    onClose,\n    onHighlightChange,\n    onInputChange,\n    onOpen,\n    open: openProp,\n    openOnFocus = false,\n    options,\n    readOnly = false,\n    selectOnFocus = !props.freeSolo,\n    value: valueProp\n  } = props;\n  const id = useId(idProp);\n  let getOptionLabel = getOptionLabelProp;\n  getOptionLabel = option => {\n    const optionLabel = getOptionLabelProp(option);\n    if (typeof optionLabel !== 'string') {\n      if (process.env.NODE_ENV !== 'production') {\n        const erroneousReturn = optionLabel === undefined ? 'undefined' : `${typeof optionLabel} (${optionLabel})`;\n        console.error(`MUI: The \\`getOptionLabel\\` method of ${componentName} returned ${erroneousReturn} instead of a string for ${JSON.stringify(option)}.`);\n      }\n      return String(optionLabel);\n    }\n    return optionLabel;\n  };\n  const ignoreFocus = React.useRef(false);\n  const firstFocus = React.useRef(true);\n  const inputRef = React.useRef(null);\n  const listboxRef = React.useRef(null);\n  const [anchorEl, setAnchorEl] = React.useState(null);\n  const [focusedTag, setFocusedTag] = React.useState(-1);\n  const defaultHighlighted = autoHighlight ? 0 : -1;\n  const highlightedIndexRef = React.useRef(defaultHighlighted);\n  const [value, setValueState] = useControlled({\n    controlled: valueProp,\n    default: defaultValue,\n    name: componentName\n  });\n  const [inputValue, setInputValueState] = useControlled({\n    controlled: inputValueProp,\n    default: '',\n    name: componentName,\n    state: 'inputValue'\n  });\n  const [focused, setFocused] = React.useState(false);\n  const resetInputValue = React.useCallback((event, newValue) => {\n    // retain current `inputValue` if new option isn't selected and `clearOnBlur` is false\n    // When `multiple` is enabled, `newValue` is an array of all selected items including the newly selected item\n    const isOptionSelected = multiple ? value.length < newValue.length : newValue !== null;\n    if (!isOptionSelected && !clearOnBlur) {\n      return;\n    }\n    let newInputValue;\n    if (multiple) {\n      newInputValue = '';\n    } else if (newValue == null) {\n      newInputValue = '';\n    } else {\n      const optionLabel = getOptionLabel(newValue);\n      newInputValue = typeof optionLabel === 'string' ? optionLabel : '';\n    }\n    if (inputValue === newInputValue) {\n      return;\n    }\n    setInputValueState(newInputValue);\n    if (onInputChange) {\n      onInputChange(event, newInputValue, 'reset');\n    }\n  }, [getOptionLabel, inputValue, multiple, onInputChange, setInputValueState, clearOnBlur, value]);\n  const [open, setOpenState] = useControlled({\n    controlled: openProp,\n    default: false,\n    name: componentName,\n    state: 'open'\n  });\n  const [inputPristine, setInputPristine] = React.useState(true);\n  const inputValueIsSelectedValue = !multiple && value != null && inputValue === getOptionLabel(value);\n  const popupOpen = open && !readOnly;\n  const filteredOptions = popupOpen ? filterOptions(options.filter(option => {\n    if (filterSelectedOptions && (multiple ? value : [value]).some(value2 => value2 !== null && isOptionEqualToValue(option, value2))) {\n      return false;\n    }\n    return true;\n  }),\n  // we use the empty string to manipulate `filterOptions` to not filter any options\n  // i.e. the filter predicate always returns true\n  {\n    inputValue: inputValueIsSelectedValue && inputPristine ? '' : inputValue,\n    getOptionLabel\n  }) : [];\n  const previousProps = usePreviousProps({\n    filteredOptions,\n    value,\n    inputValue\n  });\n  React.useEffect(() => {\n    const valueChange = value !== previousProps.value;\n    if (focused && !valueChange) {\n      return;\n    }\n\n    // Only reset the input's value when freeSolo if the component's value changes.\n    if (freeSolo && !valueChange) {\n      return;\n    }\n    resetInputValue(null, value);\n  }, [value, resetInputValue, focused, previousProps.value, freeSolo]);\n  const listboxAvailable = open && filteredOptions.length > 0 && !readOnly;\n  if (process.env.NODE_ENV !== 'production') {\n    if (value !== null && !freeSolo && options.length > 0) {\n      const missingValue = (multiple ? value : [value]).filter(value2 => !options.some(option => isOptionEqualToValue(option, value2)));\n      if (missingValue.length > 0) {\n        console.warn([`MUI: The value provided to ${componentName} is invalid.`, `None of the options match with \\`${missingValue.length > 1 ? JSON.stringify(missingValue) : JSON.stringify(missingValue[0])}\\`.`, 'You can use the `isOptionEqualToValue` prop to customize the equality test.'].join('\\n'));\n      }\n    }\n  }\n  const focusTag = useEventCallback(tagToFocus => {\n    if (tagToFocus === -1) {\n      inputRef.current.focus();\n    } else {\n      anchorEl.querySelector(`[data-tag-index=\"${tagToFocus}\"]`).focus();\n    }\n  });\n\n  // Ensure the focusedTag is never inconsistent\n  React.useEffect(() => {\n    if (multiple && focusedTag > value.length - 1) {\n      setFocusedTag(-1);\n      focusTag(-1);\n    }\n  }, [value, multiple, focusedTag, focusTag]);\n  function validOptionIndex(index, direction) {\n    if (!listboxRef.current || index < 0 || index >= filteredOptions.length) {\n      return -1;\n    }\n    let nextFocus = index;\n    while (true) {\n      const option = listboxRef.current.querySelector(`[data-option-index=\"${nextFocus}\"]`);\n\n      // Same logic as MenuList.js\n      const nextFocusDisabled = disabledItemsFocusable ? false : !option || option.disabled || option.getAttribute('aria-disabled') === 'true';\n      if (option && option.hasAttribute('tabindex') && !nextFocusDisabled) {\n        // The next option is available\n        return nextFocus;\n      }\n\n      // The next option is disabled, move to the next element.\n      // with looped index\n      if (direction === 'next') {\n        nextFocus = (nextFocus + 1) % filteredOptions.length;\n      } else {\n        nextFocus = (nextFocus - 1 + filteredOptions.length) % filteredOptions.length;\n      }\n\n      // We end up with initial index, that means we don't have available options.\n      // All of them are disabled\n      if (nextFocus === index) {\n        return -1;\n      }\n    }\n  }\n  const setHighlightedIndex = useEventCallback(({\n    event,\n    index,\n    reason = 'auto'\n  }) => {\n    highlightedIndexRef.current = index;\n\n    // does the index exist?\n    if (index === -1) {\n      inputRef.current.removeAttribute('aria-activedescendant');\n    } else {\n      inputRef.current.setAttribute('aria-activedescendant', `${id}-option-${index}`);\n    }\n    if (onHighlightChange) {\n      onHighlightChange(event, index === -1 ? null : filteredOptions[index], reason);\n    }\n    if (!listboxRef.current) {\n      return;\n    }\n    const prev = listboxRef.current.querySelector(`[role=\"option\"].${unstable_classNamePrefix}-focused`);\n    if (prev) {\n      prev.classList.remove(`${unstable_classNamePrefix}-focused`);\n      prev.classList.remove(`${unstable_classNamePrefix}-focusVisible`);\n    }\n    let listboxNode = listboxRef.current;\n    if (listboxRef.current.getAttribute('role') !== 'listbox') {\n      listboxNode = listboxRef.current.parentElement.querySelector('[role=\"listbox\"]');\n    }\n\n    // \"No results\"\n    if (!listboxNode) {\n      return;\n    }\n    if (index === -1) {\n      listboxNode.scrollTop = 0;\n      return;\n    }\n    const option = listboxRef.current.querySelector(`[data-option-index=\"${index}\"]`);\n    if (!option) {\n      return;\n    }\n    option.classList.add(`${unstable_classNamePrefix}-focused`);\n    if (reason === 'keyboard') {\n      option.classList.add(`${unstable_classNamePrefix}-focusVisible`);\n    }\n\n    // Scroll active descendant into view.\n    // Logic copied from https://www.w3.org/WAI/content-assets/wai-aria-practices/patterns/combobox/examples/js/select-only.js\n    // In case of mouse clicks and touch (in mobile devices) we avoid scrolling the element and keep both behaviors same.\n    // Consider this API instead once it has a better browser support:\n    // .scrollIntoView({ scrollMode: 'if-needed', block: 'nearest' });\n    if (listboxNode.scrollHeight > listboxNode.clientHeight && reason !== 'mouse' && reason !== 'touch') {\n      const element = option;\n      const scrollBottom = listboxNode.clientHeight + listboxNode.scrollTop;\n      const elementBottom = element.offsetTop + element.offsetHeight;\n      if (elementBottom > scrollBottom) {\n        listboxNode.scrollTop = elementBottom - listboxNode.clientHeight;\n      } else if (element.offsetTop - element.offsetHeight * (groupBy ? 1.3 : 0) < listboxNode.scrollTop) {\n        listboxNode.scrollTop = element.offsetTop - element.offsetHeight * (groupBy ? 1.3 : 0);\n      }\n    }\n  });\n  const changeHighlightedIndex = useEventCallback(({\n    event,\n    diff,\n    direction = 'next',\n    reason = 'auto'\n  }) => {\n    if (!popupOpen) {\n      return;\n    }\n    const getNextIndex = () => {\n      const maxIndex = filteredOptions.length - 1;\n      if (diff === 'reset') {\n        return defaultHighlighted;\n      }\n      if (diff === 'start') {\n        return 0;\n      }\n      if (diff === 'end') {\n        return maxIndex;\n      }\n      const newIndex = highlightedIndexRef.current + diff;\n      if (newIndex < 0) {\n        if (newIndex === -1 && includeInputInList) {\n          return -1;\n        }\n        if (disableListWrap && highlightedIndexRef.current !== -1 || Math.abs(diff) > 1) {\n          return 0;\n        }\n        return maxIndex;\n      }\n      if (newIndex > maxIndex) {\n        if (newIndex === maxIndex + 1 && includeInputInList) {\n          return -1;\n        }\n        if (disableListWrap || Math.abs(diff) > 1) {\n          return maxIndex;\n        }\n        return 0;\n      }\n      return newIndex;\n    };\n    const nextIndex = validOptionIndex(getNextIndex(), direction);\n    setHighlightedIndex({\n      index: nextIndex,\n      reason,\n      event\n    });\n\n    // Sync the content of the input with the highlighted option.\n    if (autoComplete && diff !== 'reset') {\n      if (nextIndex === -1) {\n        inputRef.current.value = inputValue;\n      } else {\n        const option = getOptionLabel(filteredOptions[nextIndex]);\n        inputRef.current.value = option;\n\n        // The portion of the selected suggestion that has not been typed by the user,\n        // a completion string, appears inline after the input cursor in the textbox.\n        const index = option.toLowerCase().indexOf(inputValue.toLowerCase());\n        if (index === 0 && inputValue.length > 0) {\n          inputRef.current.setSelectionRange(inputValue.length, option.length);\n        }\n      }\n    }\n  });\n  const getPreviousHighlightedOptionIndex = () => {\n    const isSameValue = (value1, value2) => {\n      const label1 = value1 ? getOptionLabel(value1) : '';\n      const label2 = value2 ? getOptionLabel(value2) : '';\n      return label1 === label2;\n    };\n    if (highlightedIndexRef.current !== -1 && previousProps.filteredOptions && previousProps.filteredOptions.length !== filteredOptions.length && previousProps.inputValue === inputValue && (multiple ? value.length === previousProps.value.length && previousProps.value.every((val, i) => getOptionLabel(value[i]) === getOptionLabel(val)) : isSameValue(previousProps.value, value))) {\n      const previousHighlightedOption = previousProps.filteredOptions[highlightedIndexRef.current];\n      if (previousHighlightedOption) {\n        return findIndex(filteredOptions, option => {\n          return getOptionLabel(option) === getOptionLabel(previousHighlightedOption);\n        });\n      }\n    }\n    return -1;\n  };\n  const syncHighlightedIndex = React.useCallback(() => {\n    if (!popupOpen) {\n      return;\n    }\n\n    // Check if the previously highlighted option still exists in the updated filtered options list and if the value and inputValue haven't changed\n    // If it exists and the value and the inputValue haven't changed, just update its index, otherwise continue execution\n    const previousHighlightedOptionIndex = getPreviousHighlightedOptionIndex();\n    if (previousHighlightedOptionIndex !== -1) {\n      highlightedIndexRef.current = previousHighlightedOptionIndex;\n      return;\n    }\n    const valueItem = multiple ? value[0] : value;\n\n    // The popup is empty, reset\n    if (filteredOptions.length === 0 || valueItem == null) {\n      changeHighlightedIndex({\n        diff: 'reset'\n      });\n      return;\n    }\n    if (!listboxRef.current) {\n      return;\n    }\n\n    // Synchronize the value with the highlighted index\n    if (valueItem != null) {\n      const currentOption = filteredOptions[highlightedIndexRef.current];\n\n      // Keep the current highlighted index if possible\n      if (multiple && currentOption && findIndex(value, val => isOptionEqualToValue(currentOption, val)) !== -1) {\n        return;\n      }\n      const itemIndex = findIndex(filteredOptions, optionItem => isOptionEqualToValue(optionItem, valueItem));\n      if (itemIndex === -1) {\n        changeHighlightedIndex({\n          diff: 'reset'\n        });\n      } else {\n        setHighlightedIndex({\n          index: itemIndex\n        });\n      }\n      return;\n    }\n\n    // Prevent the highlighted index to leak outside the boundaries.\n    if (highlightedIndexRef.current >= filteredOptions.length - 1) {\n      setHighlightedIndex({\n        index: filteredOptions.length - 1\n      });\n      return;\n    }\n\n    // Restore the focus to the previous index.\n    setHighlightedIndex({\n      index: highlightedIndexRef.current\n    });\n    // Ignore filteredOptions (and options, isOptionEqualToValue, getOptionLabel) not to break the scroll position\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [\n  // Only sync the highlighted index when the option switch between empty and not\n  filteredOptions.length,\n  // Don't sync the highlighted index with the value when multiple\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  multiple ? false : value, filterSelectedOptions, changeHighlightedIndex, setHighlightedIndex, popupOpen, inputValue, multiple]);\n  const handleListboxRef = useEventCallback(node => {\n    setRef(listboxRef, node);\n    if (!node) {\n      return;\n    }\n    syncHighlightedIndex();\n  });\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      if (!inputRef.current || inputRef.current.nodeName !== 'INPUT') {\n        if (inputRef.current && inputRef.current.nodeName === 'TEXTAREA') {\n          console.warn([`A textarea element was provided to ${componentName} where input was expected.`, `This is not a supported scenario but it may work under certain conditions.`, `A textarea keyboard navigation may conflict with Autocomplete controls (for example enter and arrow keys).`, `Make sure to test keyboard navigation and add custom event handlers if necessary.`].join('\\n'));\n        } else {\n          console.error([`MUI: Unable to find the input element. It was resolved to ${inputRef.current} while an HTMLInputElement was expected.`, `Instead, ${componentName} expects an input element.`, '', componentName === 'useAutocomplete' ? 'Make sure you have bound getInputProps correctly and that the normal ref/effect resolutions order is guaranteed.' : 'Make sure you have customized the input component correctly.'].join('\\n'));\n        }\n      }\n    }, [componentName]);\n  }\n  React.useEffect(() => {\n    syncHighlightedIndex();\n  }, [syncHighlightedIndex]);\n  const handleOpen = event => {\n    if (open) {\n      return;\n    }\n    setOpenState(true);\n    setInputPristine(true);\n    if (onOpen) {\n      onOpen(event);\n    }\n  };\n  const handleClose = (event, reason) => {\n    if (!open) {\n      return;\n    }\n    setOpenState(false);\n    if (onClose) {\n      onClose(event, reason);\n    }\n  };\n  const handleValue = (event, newValue, reason, details) => {\n    if (multiple) {\n      if (value.length === newValue.length && value.every((val, i) => val === newValue[i])) {\n        return;\n      }\n    } else if (value === newValue) {\n      return;\n    }\n    if (onChange) {\n      onChange(event, newValue, reason, details);\n    }\n    setValueState(newValue);\n  };\n  const isTouch = React.useRef(false);\n  const selectNewValue = (event, option, reasonProp = 'selectOption', origin = 'options') => {\n    let reason = reasonProp;\n    let newValue = option;\n    if (multiple) {\n      newValue = Array.isArray(value) ? value.slice() : [];\n      if (process.env.NODE_ENV !== 'production') {\n        const matches = newValue.filter(val => isOptionEqualToValue(option, val));\n        if (matches.length > 1) {\n          console.error([`MUI: The \\`isOptionEqualToValue\\` method of ${componentName} does not handle the arguments correctly.`, `The component expects a single value to match a given option but found ${matches.length} matches.`].join('\\n'));\n        }\n      }\n      const itemIndex = findIndex(newValue, valueItem => isOptionEqualToValue(option, valueItem));\n      if (itemIndex === -1) {\n        newValue.push(option);\n      } else if (origin !== 'freeSolo') {\n        newValue.splice(itemIndex, 1);\n        reason = 'removeOption';\n      }\n    }\n    resetInputValue(event, newValue);\n    handleValue(event, newValue, reason, {\n      option\n    });\n    if (!disableCloseOnSelect && (!event || !event.ctrlKey && !event.metaKey)) {\n      handleClose(event, reason);\n    }\n    if (blurOnSelect === true || blurOnSelect === 'touch' && isTouch.current || blurOnSelect === 'mouse' && !isTouch.current) {\n      inputRef.current.blur();\n    }\n  };\n  function validTagIndex(index, direction) {\n    if (index === -1) {\n      return -1;\n    }\n    let nextFocus = index;\n    while (true) {\n      // Out of range\n      if (direction === 'next' && nextFocus === value.length || direction === 'previous' && nextFocus === -1) {\n        return -1;\n      }\n      const option = anchorEl.querySelector(`[data-tag-index=\"${nextFocus}\"]`);\n\n      // Same logic as MenuList.js\n      if (!option || !option.hasAttribute('tabindex') || option.disabled || option.getAttribute('aria-disabled') === 'true') {\n        nextFocus += direction === 'next' ? 1 : -1;\n      } else {\n        return nextFocus;\n      }\n    }\n  }\n  const handleFocusTag = (event, direction) => {\n    if (!multiple) {\n      return;\n    }\n    if (inputValue === '') {\n      handleClose(event, 'toggleInput');\n    }\n    let nextTag = focusedTag;\n    if (focusedTag === -1) {\n      if (inputValue === '' && direction === 'previous') {\n        nextTag = value.length - 1;\n      }\n    } else {\n      nextTag += direction === 'next' ? 1 : -1;\n      if (nextTag < 0) {\n        nextTag = 0;\n      }\n      if (nextTag === value.length) {\n        nextTag = -1;\n      }\n    }\n    nextTag = validTagIndex(nextTag, direction);\n    setFocusedTag(nextTag);\n    focusTag(nextTag);\n  };\n  const handleClear = event => {\n    ignoreFocus.current = true;\n    setInputValueState('');\n    if (onInputChange) {\n      onInputChange(event, '', 'clear');\n    }\n    handleValue(event, multiple ? [] : null, 'clear');\n  };\n  const handleKeyDown = other => event => {\n    if (other.onKeyDown) {\n      other.onKeyDown(event);\n    }\n    if (event.defaultMuiPrevented) {\n      return;\n    }\n    if (focusedTag !== -1 && ['ArrowLeft', 'ArrowRight'].indexOf(event.key) === -1) {\n      setFocusedTag(-1);\n      focusTag(-1);\n    }\n\n    // Wait until IME is settled.\n    if (event.which !== 229) {\n      switch (event.key) {\n        case 'Home':\n          if (popupOpen && handleHomeEndKeys) {\n            // Prevent scroll of the page\n            event.preventDefault();\n            changeHighlightedIndex({\n              diff: 'start',\n              direction: 'next',\n              reason: 'keyboard',\n              event\n            });\n          }\n          break;\n        case 'End':\n          if (popupOpen && handleHomeEndKeys) {\n            // Prevent scroll of the page\n            event.preventDefault();\n            changeHighlightedIndex({\n              diff: 'end',\n              direction: 'previous',\n              reason: 'keyboard',\n              event\n            });\n          }\n          break;\n        case 'PageUp':\n          // Prevent scroll of the page\n          event.preventDefault();\n          changeHighlightedIndex({\n            diff: -pageSize,\n            direction: 'previous',\n            reason: 'keyboard',\n            event\n          });\n          handleOpen(event);\n          break;\n        case 'PageDown':\n          // Prevent scroll of the page\n          event.preventDefault();\n          changeHighlightedIndex({\n            diff: pageSize,\n            direction: 'next',\n            reason: 'keyboard',\n            event\n          });\n          handleOpen(event);\n          break;\n        case 'ArrowDown':\n          // Prevent cursor move\n          event.preventDefault();\n          changeHighlightedIndex({\n            diff: 1,\n            direction: 'next',\n            reason: 'keyboard',\n            event\n          });\n          handleOpen(event);\n          break;\n        case 'ArrowUp':\n          // Prevent cursor move\n          event.preventDefault();\n          changeHighlightedIndex({\n            diff: -1,\n            direction: 'previous',\n            reason: 'keyboard',\n            event\n          });\n          handleOpen(event);\n          break;\n        case 'ArrowLeft':\n          handleFocusTag(event, 'previous');\n          break;\n        case 'ArrowRight':\n          handleFocusTag(event, 'next');\n          break;\n        case 'Enter':\n          if (highlightedIndexRef.current !== -1 && popupOpen) {\n            const option = filteredOptions[highlightedIndexRef.current];\n            const disabled = getOptionDisabled ? getOptionDisabled(option) : false;\n\n            // Avoid early form validation, let the end-users continue filling the form.\n            event.preventDefault();\n            if (disabled) {\n              return;\n            }\n            selectNewValue(event, option, 'selectOption');\n\n            // Move the selection to the end.\n            if (autoComplete) {\n              inputRef.current.setSelectionRange(inputRef.current.value.length, inputRef.current.value.length);\n            }\n          } else if (freeSolo && inputValue !== '' && inputValueIsSelectedValue === false) {\n            if (multiple) {\n              // Allow people to add new values before they submit the form.\n              event.preventDefault();\n            }\n            selectNewValue(event, inputValue, 'createOption', 'freeSolo');\n          }\n          break;\n        case 'Escape':\n          if (popupOpen) {\n            // Avoid Opera to exit fullscreen mode.\n            event.preventDefault();\n            // Avoid the Modal to handle the event.\n            event.stopPropagation();\n            handleClose(event, 'escape');\n          } else if (clearOnEscape && (inputValue !== '' || multiple && value.length > 0)) {\n            // Avoid Opera to exit fullscreen mode.\n            event.preventDefault();\n            // Avoid the Modal to handle the event.\n            event.stopPropagation();\n            handleClear(event);\n          }\n          break;\n        case 'Backspace':\n          // Remove the value on the left of the \"cursor\"\n          if (multiple && !readOnly && inputValue === '' && value.length > 0) {\n            const index = focusedTag === -1 ? value.length - 1 : focusedTag;\n            const newValue = value.slice();\n            newValue.splice(index, 1);\n            handleValue(event, newValue, 'removeOption', {\n              option: value[index]\n            });\n          }\n          break;\n        case 'Delete':\n          // Remove the value on the right of the \"cursor\"\n          if (multiple && !readOnly && inputValue === '' && value.length > 0 && focusedTag !== -1) {\n            const index = focusedTag;\n            const newValue = value.slice();\n            newValue.splice(index, 1);\n            handleValue(event, newValue, 'removeOption', {\n              option: value[index]\n            });\n          }\n          break;\n        default:\n      }\n    }\n  };\n  const handleFocus = event => {\n    setFocused(true);\n    if (openOnFocus && !ignoreFocus.current) {\n      handleOpen(event);\n    }\n  };\n  const handleBlur = event => {\n    // Ignore the event when using the scrollbar with IE11\n    if (unstable_isActiveElementInListbox(listboxRef)) {\n      inputRef.current.focus();\n      return;\n    }\n    setFocused(false);\n    firstFocus.current = true;\n    ignoreFocus.current = false;\n    if (autoSelect && highlightedIndexRef.current !== -1 && popupOpen) {\n      selectNewValue(event, filteredOptions[highlightedIndexRef.current], 'blur');\n    } else if (autoSelect && freeSolo && inputValue !== '') {\n      selectNewValue(event, inputValue, 'blur', 'freeSolo');\n    } else if (clearOnBlur) {\n      resetInputValue(event, value);\n    }\n    handleClose(event, 'blur');\n  };\n  const handleInputChange = event => {\n    const newValue = event.target.value;\n    if (inputValue !== newValue) {\n      setInputValueState(newValue);\n      setInputPristine(false);\n      if (onInputChange) {\n        onInputChange(event, newValue, 'input');\n      }\n    }\n    if (newValue === '') {\n      if (!disableClearable && !multiple) {\n        handleValue(event, null, 'clear');\n      }\n    } else {\n      handleOpen(event);\n    }\n  };\n  const handleOptionMouseMove = event => {\n    const index = Number(event.currentTarget.getAttribute('data-option-index'));\n    if (highlightedIndexRef.current !== index) {\n      setHighlightedIndex({\n        event,\n        index,\n        reason: 'mouse'\n      });\n    }\n  };\n  const handleOptionTouchStart = event => {\n    setHighlightedIndex({\n      event,\n      index: Number(event.currentTarget.getAttribute('data-option-index')),\n      reason: 'touch'\n    });\n    isTouch.current = true;\n  };\n  const handleOptionClick = event => {\n    const index = Number(event.currentTarget.getAttribute('data-option-index'));\n    selectNewValue(event, filteredOptions[index], 'selectOption');\n    isTouch.current = false;\n  };\n  const handleTagDelete = index => event => {\n    const newValue = value.slice();\n    newValue.splice(index, 1);\n    handleValue(event, newValue, 'removeOption', {\n      option: value[index]\n    });\n  };\n  const handlePopupIndicator = event => {\n    if (open) {\n      handleClose(event, 'toggleInput');\n    } else {\n      handleOpen(event);\n    }\n  };\n\n  // Prevent input blur when interacting with the combobox\n  const handleMouseDown = event => {\n    // Prevent focusing the input if click is anywhere outside the Autocomplete\n    if (!event.currentTarget.contains(event.target)) {\n      return;\n    }\n    if (event.target.getAttribute('id') !== id) {\n      event.preventDefault();\n    }\n  };\n\n  // Focus the input when interacting with the combobox\n  const handleClick = event => {\n    // Prevent focusing the input if click is anywhere outside the Autocomplete\n    if (!event.currentTarget.contains(event.target)) {\n      return;\n    }\n    inputRef.current.focus();\n    if (selectOnFocus && firstFocus.current && inputRef.current.selectionEnd - inputRef.current.selectionStart === 0) {\n      inputRef.current.select();\n    }\n    firstFocus.current = false;\n  };\n  const handleInputMouseDown = event => {\n    if (!disabledProp && (inputValue === '' || !open)) {\n      handlePopupIndicator(event);\n    }\n  };\n  let dirty = freeSolo && inputValue.length > 0;\n  dirty = dirty || (multiple ? value.length > 0 : value !== null);\n  let groupedOptions = filteredOptions;\n  if (groupBy) {\n    // used to keep track of key and indexes in the result array\n    const indexBy = new Map();\n    let warn = false;\n    groupedOptions = filteredOptions.reduce((acc, option, index) => {\n      const group = groupBy(option);\n      if (acc.length > 0 && acc[acc.length - 1].group === group) {\n        acc[acc.length - 1].options.push(option);\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          if (indexBy.get(group) && !warn) {\n            console.warn(`MUI: The options provided combined with the \\`groupBy\\` method of ${componentName} returns duplicated headers.`, 'You can solve the issue by sorting the options with the output of `groupBy`.');\n            warn = true;\n          }\n          indexBy.set(group, true);\n        }\n        acc.push({\n          key: index,\n          index,\n          group,\n          options: [option]\n        });\n      }\n      return acc;\n    }, []);\n  }\n  if (disabledProp && focused) {\n    handleBlur();\n  }\n  return {\n    getRootProps: (other = {}) => _extends({\n      'aria-owns': listboxAvailable ? `${id}-listbox` : null\n    }, other, {\n      onKeyDown: handleKeyDown(other),\n      onMouseDown: handleMouseDown,\n      onClick: handleClick\n    }),\n    getInputLabelProps: () => ({\n      id: `${id}-label`,\n      htmlFor: id\n    }),\n    getInputProps: () => ({\n      id,\n      value: inputValue,\n      onBlur: handleBlur,\n      onFocus: handleFocus,\n      onChange: handleInputChange,\n      onMouseDown: handleInputMouseDown,\n      // if open then this is handled imperatively so don't let react override\n      // only have an opinion about this when closed\n      'aria-activedescendant': popupOpen ? '' : null,\n      'aria-autocomplete': autoComplete ? 'both' : 'list',\n      'aria-controls': listboxAvailable ? `${id}-listbox` : undefined,\n      'aria-expanded': listboxAvailable,\n      // Disable browser's suggestion that might overlap with the popup.\n      // Handle autocomplete but not autofill.\n      autoComplete: 'off',\n      ref: inputRef,\n      autoCapitalize: 'none',\n      spellCheck: 'false',\n      role: 'combobox',\n      disabled: disabledProp\n    }),\n    getClearProps: () => ({\n      tabIndex: -1,\n      type: 'button',\n      onClick: handleClear\n    }),\n    getPopupIndicatorProps: () => ({\n      tabIndex: -1,\n      type: 'button',\n      onClick: handlePopupIndicator\n    }),\n    getTagProps: ({\n      index\n    }) => _extends({\n      key: index,\n      'data-tag-index': index,\n      tabIndex: -1\n    }, !readOnly && {\n      onDelete: handleTagDelete(index)\n    }),\n    getListboxProps: () => ({\n      role: 'listbox',\n      id: `${id}-listbox`,\n      'aria-labelledby': `${id}-label`,\n      ref: handleListboxRef,\n      onMouseDown: event => {\n        // Prevent blur\n        event.preventDefault();\n      }\n    }),\n    getOptionProps: ({\n      index,\n      option\n    }) => {\n      var _getOptionKey;\n      const selected = (multiple ? value : [value]).some(value2 => value2 != null && isOptionEqualToValue(option, value2));\n      const disabled = getOptionDisabled ? getOptionDisabled(option) : false;\n      return {\n        key: (_getOptionKey = getOptionKey == null ? void 0 : getOptionKey(option)) != null ? _getOptionKey : getOptionLabel(option),\n        tabIndex: -1,\n        role: 'option',\n        id: `${id}-option-${index}`,\n        onMouseMove: handleOptionMouseMove,\n        onClick: handleOptionClick,\n        onTouchStart: handleOptionTouchStart,\n        'data-option-index': index,\n        'aria-disabled': disabled,\n        'aria-selected': selected\n      };\n    },\n    id,\n    inputValue,\n    value,\n    dirty,\n    expanded: popupOpen && anchorEl,\n    popupOpen,\n    focused: focused || focusedTag !== -1,\n    anchorEl,\n    setAnchorEl,\n    focusedTag,\n    groupedOptions\n  };\n}","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_ownerDocument as ownerDocument, unstable_useControlled as useControlled, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useEventCallback as useEventCallback, unstable_useForkRef as useForkRef, unstable_useIsFocusVisible as useIsFocusVisible, visuallyHidden, clamp } from '@mui/utils';\nimport { areArraysEqual, extractEventHandlers } from '../utils';\nconst INTENTIONAL_DRAG_COUNT_THRESHOLD = 2;\nfunction asc(a, b) {\n  return a - b;\n}\nfunction findClosest(values, currentValue) {\n  var _values$reduce;\n  const {\n    index: closestIndex\n  } = (_values$reduce = values.reduce((acc, value, index) => {\n    const distance = Math.abs(currentValue - value);\n    if (acc === null || distance < acc.distance || distance === acc.distance) {\n      return {\n        distance,\n        index\n      };\n    }\n    return acc;\n  }, null)) != null ? _values$reduce : {};\n  return closestIndex;\n}\nfunction trackFinger(event, touchId) {\n  // The event is TouchEvent\n  if (touchId.current !== undefined && event.changedTouches) {\n    const touchEvent = event;\n    for (let i = 0; i < touchEvent.changedTouches.length; i += 1) {\n      const touch = touchEvent.changedTouches[i];\n      if (touch.identifier === touchId.current) {\n        return {\n          x: touch.clientX,\n          y: touch.clientY\n        };\n      }\n    }\n    return false;\n  }\n\n  // The event is MouseEvent\n  return {\n    x: event.clientX,\n    y: event.clientY\n  };\n}\nexport function valueToPercent(value, min, max) {\n  return (value - min) * 100 / (max - min);\n}\nfunction percentToValue(percent, min, max) {\n  return (max - min) * percent + min;\n}\nfunction getDecimalPrecision(num) {\n  // This handles the case when num is very small (0.00000001), js will turn this into 1e-8.\n  // When num is bigger than 1 or less than -1 it won't get converted to this notation so it's fine.\n  if (Math.abs(num) < 1) {\n    const parts = num.toExponential().split('e-');\n    const matissaDecimalPart = parts[0].split('.')[1];\n    return (matissaDecimalPart ? matissaDecimalPart.length : 0) + parseInt(parts[1], 10);\n  }\n  const decimalPart = num.toString().split('.')[1];\n  return decimalPart ? decimalPart.length : 0;\n}\nfunction roundValueToStep(value, step, min) {\n  const nearest = Math.round((value - min) / step) * step + min;\n  return Number(nearest.toFixed(getDecimalPrecision(step)));\n}\nfunction setValueIndex({\n  values,\n  newValue,\n  index\n}) {\n  const output = values.slice();\n  output[index] = newValue;\n  return output.sort(asc);\n}\nfunction focusThumb({\n  sliderRef,\n  activeIndex,\n  setActive\n}) {\n  var _sliderRef$current, _doc$activeElement;\n  const doc = ownerDocument(sliderRef.current);\n  if (!((_sliderRef$current = sliderRef.current) != null && _sliderRef$current.contains(doc.activeElement)) || Number(doc == null || (_doc$activeElement = doc.activeElement) == null ? void 0 : _doc$activeElement.getAttribute('data-index')) !== activeIndex) {\n    var _sliderRef$current2;\n    (_sliderRef$current2 = sliderRef.current) == null || _sliderRef$current2.querySelector(`[type=\"range\"][data-index=\"${activeIndex}\"]`).focus();\n  }\n  if (setActive) {\n    setActive(activeIndex);\n  }\n}\nfunction areValuesEqual(newValue, oldValue) {\n  if (typeof newValue === 'number' && typeof oldValue === 'number') {\n    return newValue === oldValue;\n  }\n  if (typeof newValue === 'object' && typeof oldValue === 'object') {\n    return areArraysEqual(newValue, oldValue);\n  }\n  return false;\n}\nconst axisProps = {\n  horizontal: {\n    offset: percent => ({\n      left: `${percent}%`\n    }),\n    leap: percent => ({\n      width: `${percent}%`\n    })\n  },\n  'horizontal-reverse': {\n    offset: percent => ({\n      right: `${percent}%`\n    }),\n    leap: percent => ({\n      width: `${percent}%`\n    })\n  },\n  vertical: {\n    offset: percent => ({\n      bottom: `${percent}%`\n    }),\n    leap: percent => ({\n      height: `${percent}%`\n    })\n  }\n};\nexport const Identity = x => x;\n\n// TODO: remove support for Safari < 13.\n// https://caniuse.com/#search=touch-action\n//\n// Safari, on iOS, supports touch action since v13.\n// Over 80% of the iOS phones are compatible\n// in August 2020.\n// Utilizing the CSS.supports method to check if touch-action is supported.\n// Since CSS.supports is supported on all but Edge@12 and IE and touch-action\n// is supported on both Edge@12 and IE if CSS.supports is not available that means that\n// touch-action will be supported\nlet cachedSupportsTouchActionNone;\nfunction doesSupportTouchActionNone() {\n  if (cachedSupportsTouchActionNone === undefined) {\n    if (typeof CSS !== 'undefined' && typeof CSS.supports === 'function') {\n      cachedSupportsTouchActionNone = CSS.supports('touch-action', 'none');\n    } else {\n      cachedSupportsTouchActionNone = true;\n    }\n  }\n  return cachedSupportsTouchActionNone;\n}\n/**\n *\n * Demos:\n *\n * - [Slider](https://mui.com/base-ui/react-slider/#hook)\n *\n * API:\n *\n * - [useSlider API](https://mui.com/base-ui/react-slider/hooks-api/#use-slider)\n */\nexport function useSlider(parameters) {\n  const {\n    'aria-labelledby': ariaLabelledby,\n    defaultValue,\n    disabled = false,\n    disableSwap = false,\n    isRtl = false,\n    marks: marksProp = false,\n    max = 100,\n    min = 0,\n    name,\n    onChange,\n    onChangeCommitted,\n    orientation = 'horizontal',\n    rootRef: ref,\n    scale = Identity,\n    step = 1,\n    shiftStep = 10,\n    tabIndex,\n    value: valueProp\n  } = parameters;\n  const touchId = React.useRef();\n  // We can't use the :active browser pseudo-classes.\n  // - The active state isn't triggered when clicking on the rail.\n  // - The active state isn't transferred when inversing a range slider.\n  const [active, setActive] = React.useState(-1);\n  const [open, setOpen] = React.useState(-1);\n  const [dragging, setDragging] = React.useState(false);\n  const moveCount = React.useRef(0);\n  const [valueDerived, setValueState] = useControlled({\n    controlled: valueProp,\n    default: defaultValue != null ? defaultValue : min,\n    name: 'Slider'\n  });\n  const handleChange = onChange && ((event, value, thumbIndex) => {\n    // Redefine target to allow name and value to be read.\n    // This allows seamless integration with the most popular form libraries.\n    // https://github.com/mui/material-ui/issues/13485#issuecomment-676048492\n    // Clone the event to not override `target` of the original event.\n    const nativeEvent = event.nativeEvent || event;\n    // @ts-ignore The nativeEvent is function, not object\n    const clonedEvent = new nativeEvent.constructor(nativeEvent.type, nativeEvent);\n    Object.defineProperty(clonedEvent, 'target', {\n      writable: true,\n      value: {\n        value,\n        name\n      }\n    });\n    onChange(clonedEvent, value, thumbIndex);\n  });\n  const range = Array.isArray(valueDerived);\n  let values = range ? valueDerived.slice().sort(asc) : [valueDerived];\n  values = values.map(value => value == null ? min : clamp(value, min, max));\n  const marks = marksProp === true && step !== null ? [...Array(Math.floor((max - min) / step) + 1)].map((_, index) => ({\n    value: min + step * index\n  })) : marksProp || [];\n  const marksValues = marks.map(mark => mark.value);\n  const {\n    isFocusVisibleRef,\n    onBlur: handleBlurVisible,\n    onFocus: handleFocusVisible,\n    ref: focusVisibleRef\n  } = useIsFocusVisible();\n  const [focusedThumbIndex, setFocusedThumbIndex] = React.useState(-1);\n  const sliderRef = React.useRef();\n  const handleFocusRef = useForkRef(focusVisibleRef, sliderRef);\n  const handleRef = useForkRef(ref, handleFocusRef);\n  const createHandleHiddenInputFocus = otherHandlers => event => {\n    var _otherHandlers$onFocu;\n    const index = Number(event.currentTarget.getAttribute('data-index'));\n    handleFocusVisible(event);\n    if (isFocusVisibleRef.current === true) {\n      setFocusedThumbIndex(index);\n    }\n    setOpen(index);\n    otherHandlers == null || (_otherHandlers$onFocu = otherHandlers.onFocus) == null || _otherHandlers$onFocu.call(otherHandlers, event);\n  };\n  const createHandleHiddenInputBlur = otherHandlers => event => {\n    var _otherHandlers$onBlur;\n    handleBlurVisible(event);\n    if (isFocusVisibleRef.current === false) {\n      setFocusedThumbIndex(-1);\n    }\n    setOpen(-1);\n    otherHandlers == null || (_otherHandlers$onBlur = otherHandlers.onBlur) == null || _otherHandlers$onBlur.call(otherHandlers, event);\n  };\n  const changeValue = (event, valueInput) => {\n    const index = Number(event.currentTarget.getAttribute('data-index'));\n    const value = values[index];\n    const marksIndex = marksValues.indexOf(value);\n    let newValue = valueInput;\n    if (marks && step == null) {\n      const maxMarksValue = marksValues[marksValues.length - 1];\n      if (newValue > maxMarksValue) {\n        newValue = maxMarksValue;\n      } else if (newValue < marksValues[0]) {\n        newValue = marksValues[0];\n      } else {\n        newValue = newValue < value ? marksValues[marksIndex - 1] : marksValues[marksIndex + 1];\n      }\n    }\n    newValue = clamp(newValue, min, max);\n    if (range) {\n      // Bound the new value to the thumb's neighbours.\n      if (disableSwap) {\n        newValue = clamp(newValue, values[index - 1] || -Infinity, values[index + 1] || Infinity);\n      }\n      const previousValue = newValue;\n      newValue = setValueIndex({\n        values,\n        newValue,\n        index\n      });\n      let activeIndex = index;\n\n      // Potentially swap the index if needed.\n      if (!disableSwap) {\n        activeIndex = newValue.indexOf(previousValue);\n      }\n      focusThumb({\n        sliderRef,\n        activeIndex\n      });\n    }\n    setValueState(newValue);\n    setFocusedThumbIndex(index);\n    if (handleChange && !areValuesEqual(newValue, valueDerived)) {\n      handleChange(event, newValue, index);\n    }\n    if (onChangeCommitted) {\n      onChangeCommitted(event, newValue);\n    }\n  };\n  const createHandleHiddenInputKeyDown = otherHandlers => event => {\n    var _otherHandlers$onKeyD;\n    // The Shift + Up/Down keyboard shortcuts for moving the slider makes sense to be supported\n    // only if the step is defined. If the step is null, this means tha the marks are used for specifying the valid values.\n    if (step !== null) {\n      const index = Number(event.currentTarget.getAttribute('data-index'));\n      const value = values[index];\n      let newValue = null;\n      if ((event.key === 'ArrowLeft' || event.key === 'ArrowDown') && event.shiftKey || event.key === 'PageDown') {\n        newValue = Math.max(value - shiftStep, min);\n      } else if ((event.key === 'ArrowRight' || event.key === 'ArrowUp') && event.shiftKey || event.key === 'PageUp') {\n        newValue = Math.min(value + shiftStep, max);\n      }\n      if (newValue !== null) {\n        changeValue(event, newValue);\n        event.preventDefault();\n      }\n    }\n    otherHandlers == null || (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);\n  };\n  useEnhancedEffect(() => {\n    if (disabled && sliderRef.current.contains(document.activeElement)) {\n      var _document$activeEleme;\n      // This is necessary because Firefox and Safari will keep focus\n      // on a disabled element:\n      // https://codesandbox.io/p/sandbox/mui-pr-22247-forked-h151h?file=/src/App.js\n      // @ts-ignore\n      (_document$activeEleme = document.activeElement) == null || _document$activeEleme.blur();\n    }\n  }, [disabled]);\n  if (disabled && active !== -1) {\n    setActive(-1);\n  }\n  if (disabled && focusedThumbIndex !== -1) {\n    setFocusedThumbIndex(-1);\n  }\n  const createHandleHiddenInputChange = otherHandlers => event => {\n    var _otherHandlers$onChan;\n    (_otherHandlers$onChan = otherHandlers.onChange) == null || _otherHandlers$onChan.call(otherHandlers, event);\n    // @ts-ignore\n    changeValue(event, event.target.valueAsNumber);\n  };\n  const previousIndex = React.useRef();\n  let axis = orientation;\n  if (isRtl && orientation === 'horizontal') {\n    axis += '-reverse';\n  }\n  const getFingerNewValue = ({\n    finger,\n    move = false\n  }) => {\n    const {\n      current: slider\n    } = sliderRef;\n    const {\n      width,\n      height,\n      bottom,\n      left\n    } = slider.getBoundingClientRect();\n    let percent;\n    if (axis.indexOf('vertical') === 0) {\n      percent = (bottom - finger.y) / height;\n    } else {\n      percent = (finger.x - left) / width;\n    }\n    if (axis.indexOf('-reverse') !== -1) {\n      percent = 1 - percent;\n    }\n    let newValue;\n    newValue = percentToValue(percent, min, max);\n    if (step) {\n      newValue = roundValueToStep(newValue, step, min);\n    } else {\n      const closestIndex = findClosest(marksValues, newValue);\n      newValue = marksValues[closestIndex];\n    }\n    newValue = clamp(newValue, min, max);\n    let activeIndex = 0;\n    if (range) {\n      if (!move) {\n        activeIndex = findClosest(values, newValue);\n      } else {\n        activeIndex = previousIndex.current;\n      }\n\n      // Bound the new value to the thumb's neighbours.\n      if (disableSwap) {\n        newValue = clamp(newValue, values[activeIndex - 1] || -Infinity, values[activeIndex + 1] || Infinity);\n      }\n      const previousValue = newValue;\n      newValue = setValueIndex({\n        values,\n        newValue,\n        index: activeIndex\n      });\n\n      // Potentially swap the index if needed.\n      if (!(disableSwap && move)) {\n        activeIndex = newValue.indexOf(previousValue);\n        previousIndex.current = activeIndex;\n      }\n    }\n    return {\n      newValue,\n      activeIndex\n    };\n  };\n  const handleTouchMove = useEventCallback(nativeEvent => {\n    const finger = trackFinger(nativeEvent, touchId);\n    if (!finger) {\n      return;\n    }\n    moveCount.current += 1;\n\n    // Cancel move in case some other element consumed a mouseup event and it was not fired.\n    // @ts-ignore buttons doesn't not exists on touch event\n    if (nativeEvent.type === 'mousemove' && nativeEvent.buttons === 0) {\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      handleTouchEnd(nativeEvent);\n      return;\n    }\n    const {\n      newValue,\n      activeIndex\n    } = getFingerNewValue({\n      finger,\n      move: true\n    });\n    focusThumb({\n      sliderRef,\n      activeIndex,\n      setActive\n    });\n    setValueState(newValue);\n    if (!dragging && moveCount.current > INTENTIONAL_DRAG_COUNT_THRESHOLD) {\n      setDragging(true);\n    }\n    if (handleChange && !areValuesEqual(newValue, valueDerived)) {\n      handleChange(nativeEvent, newValue, activeIndex);\n    }\n  });\n  const handleTouchEnd = useEventCallback(nativeEvent => {\n    const finger = trackFinger(nativeEvent, touchId);\n    setDragging(false);\n    if (!finger) {\n      return;\n    }\n    const {\n      newValue\n    } = getFingerNewValue({\n      finger,\n      move: true\n    });\n    setActive(-1);\n    if (nativeEvent.type === 'touchend') {\n      setOpen(-1);\n    }\n    if (onChangeCommitted) {\n      onChangeCommitted(nativeEvent, newValue);\n    }\n    touchId.current = undefined;\n\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    stopListening();\n  });\n  const handleTouchStart = useEventCallback(nativeEvent => {\n    if (disabled) {\n      return;\n    }\n    // If touch-action: none; is not supported we need to prevent the scroll manually.\n    if (!doesSupportTouchActionNone()) {\n      nativeEvent.preventDefault();\n    }\n    const touch = nativeEvent.changedTouches[0];\n    if (touch != null) {\n      // A number that uniquely identifies the current finger in the touch session.\n      touchId.current = touch.identifier;\n    }\n    const finger = trackFinger(nativeEvent, touchId);\n    if (finger !== false) {\n      const {\n        newValue,\n        activeIndex\n      } = getFingerNewValue({\n        finger\n      });\n      focusThumb({\n        sliderRef,\n        activeIndex,\n        setActive\n      });\n      setValueState(newValue);\n      if (handleChange && !areValuesEqual(newValue, valueDerived)) {\n        handleChange(nativeEvent, newValue, activeIndex);\n      }\n    }\n    moveCount.current = 0;\n    const doc = ownerDocument(sliderRef.current);\n    doc.addEventListener('touchmove', handleTouchMove, {\n      passive: true\n    });\n    doc.addEventListener('touchend', handleTouchEnd, {\n      passive: true\n    });\n  });\n  const stopListening = React.useCallback(() => {\n    const doc = ownerDocument(sliderRef.current);\n    doc.removeEventListener('mousemove', handleTouchMove);\n    doc.removeEventListener('mouseup', handleTouchEnd);\n    doc.removeEventListener('touchmove', handleTouchMove);\n    doc.removeEventListener('touchend', handleTouchEnd);\n  }, [handleTouchEnd, handleTouchMove]);\n  React.useEffect(() => {\n    const {\n      current: slider\n    } = sliderRef;\n    slider.addEventListener('touchstart', handleTouchStart, {\n      passive: doesSupportTouchActionNone()\n    });\n    return () => {\n      slider.removeEventListener('touchstart', handleTouchStart);\n      stopListening();\n    };\n  }, [stopListening, handleTouchStart]);\n  React.useEffect(() => {\n    if (disabled) {\n      stopListening();\n    }\n  }, [disabled, stopListening]);\n  const createHandleMouseDown = otherHandlers => event => {\n    var _otherHandlers$onMous;\n    (_otherHandlers$onMous = otherHandlers.onMouseDown) == null || _otherHandlers$onMous.call(otherHandlers, event);\n    if (disabled) {\n      return;\n    }\n    if (event.defaultPrevented) {\n      return;\n    }\n\n    // Only handle left clicks\n    if (event.button !== 0) {\n      return;\n    }\n\n    // Avoid text selection\n    event.preventDefault();\n    const finger = trackFinger(event, touchId);\n    if (finger !== false) {\n      const {\n        newValue,\n        activeIndex\n      } = getFingerNewValue({\n        finger\n      });\n      focusThumb({\n        sliderRef,\n        activeIndex,\n        setActive\n      });\n      setValueState(newValue);\n      if (handleChange && !areValuesEqual(newValue, valueDerived)) {\n        handleChange(event, newValue, activeIndex);\n      }\n    }\n    moveCount.current = 0;\n    const doc = ownerDocument(sliderRef.current);\n    doc.addEventListener('mousemove', handleTouchMove, {\n      passive: true\n    });\n    doc.addEventListener('mouseup', handleTouchEnd);\n  };\n  const trackOffset = valueToPercent(range ? values[0] : min, min, max);\n  const trackLeap = valueToPercent(values[values.length - 1], min, max) - trackOffset;\n  const getRootProps = (externalProps = {}) => {\n    const externalHandlers = extractEventHandlers(externalProps);\n    const ownEventHandlers = {\n      onMouseDown: createHandleMouseDown(externalHandlers || {})\n    };\n    const mergedEventHandlers = _extends({}, externalHandlers, ownEventHandlers);\n    return _extends({}, externalProps, {\n      ref: handleRef\n    }, mergedEventHandlers);\n  };\n  const createHandleMouseOver = otherHandlers => event => {\n    var _otherHandlers$onMous2;\n    (_otherHandlers$onMous2 = otherHandlers.onMouseOver) == null || _otherHandlers$onMous2.call(otherHandlers, event);\n    const index = Number(event.currentTarget.getAttribute('data-index'));\n    setOpen(index);\n  };\n  const createHandleMouseLeave = otherHandlers => event => {\n    var _otherHandlers$onMous3;\n    (_otherHandlers$onMous3 = otherHandlers.onMouseLeave) == null || _otherHandlers$onMous3.call(otherHandlers, event);\n    setOpen(-1);\n  };\n  const getThumbProps = (externalProps = {}) => {\n    const externalHandlers = extractEventHandlers(externalProps);\n    const ownEventHandlers = {\n      onMouseOver: createHandleMouseOver(externalHandlers || {}),\n      onMouseLeave: createHandleMouseLeave(externalHandlers || {})\n    };\n    return _extends({}, externalProps, externalHandlers, ownEventHandlers);\n  };\n  const getThumbStyle = index => {\n    return {\n      // So the non active thumb doesn't show its label on hover.\n      pointerEvents: active !== -1 && active !== index ? 'none' : undefined\n    };\n  };\n  const getHiddenInputProps = (externalProps = {}) => {\n    var _parameters$step;\n    const externalHandlers = extractEventHandlers(externalProps);\n    const ownEventHandlers = {\n      onChange: createHandleHiddenInputChange(externalHandlers || {}),\n      onFocus: createHandleHiddenInputFocus(externalHandlers || {}),\n      onBlur: createHandleHiddenInputBlur(externalHandlers || {}),\n      onKeyDown: createHandleHiddenInputKeyDown(externalHandlers || {})\n    };\n    const mergedEventHandlers = _extends({}, externalHandlers, ownEventHandlers);\n    return _extends({\n      tabIndex,\n      'aria-labelledby': ariaLabelledby,\n      'aria-orientation': orientation,\n      'aria-valuemax': scale(max),\n      'aria-valuemin': scale(min),\n      name,\n      type: 'range',\n      min: parameters.min,\n      max: parameters.max,\n      step: parameters.step === null && parameters.marks ? 'any' : (_parameters$step = parameters.step) != null ? _parameters$step : undefined,\n      disabled\n    }, externalProps, mergedEventHandlers, {\n      style: _extends({}, visuallyHidden, {\n        direction: isRtl ? 'rtl' : 'ltr',\n        // So that VoiceOver's focus indicator matches the thumb's dimensions\n        width: '100%',\n        height: '100%'\n      })\n    });\n  };\n  return {\n    active,\n    axis: axis,\n    axisProps,\n    dragging,\n    focusedThumbIndex,\n    getHiddenInputProps,\n    getRootProps,\n    getThumbProps,\n    marks: marks,\n    open,\n    range,\n    rootRef: handleRef,\n    trackLeap,\n    trackOffset,\n    values,\n    getThumbStyle\n  };\n}","export function areArraysEqual(array1, array2, itemComparer = (a, b) => a === b) {\n  return array1.length === array2.length && array1.every((value, index) => itemComparer(value, array2[index]));\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}"],"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","TextareaAutosize","onChange","maxRows","minRows","isControlled","inputRef","shadowRef","calculateTextareaStyles","input","computedStyle","getComputedStyle","width","outerHeightStyle","overflowing","inputShallow","placeholder","slice","boxSizing","padding","paddingBottom","paddingTop","border","borderBottomWidth","borderTopWidth","innerHeight","scrollHeight","singleRowHeight","outerHeight","Math","max","min","abs","syncHeight","textareaStyles","obj","Object","keys","handleResize","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","stripDiacritics","string","normalize","replace","findIndex","array","comp","defaultFilterOptions","config","ignoreAccents","ignoreCase","limit","matchFrom","stringify","trim","inputValue","getOptionLabel","filteredOptions","filter","option","candidate","createFilterOptions","pageSize","defaultIsActiveElementInListbox","listboxRef","_listboxRef$current$p","useAutocomplete","unstable_isActiveElementInListbox","unstable_classNamePrefix","autoComplete","autoHighlight","autoSelect","blurOnSelect","clearOnBlur","freeSolo","clearOnEscape","defaultValue","multiple","disableClearable","disableCloseOnSelect","disabledProp","disabledItemsFocusable","disableListWrap","filterOptions","filterSelectedOptions","getOptionDisabled","getOptionKey","getOptionLabelProp","_option$label","label","groupBy","handleHomeEndKeys","id","idProp","includeInputInList","inputValueProp","isOptionEqualToValue","onHighlightChange","onInputChange","onOpen","openProp","openOnFocus","selectOnFocus","valueProp","optionLabel","String","ignoreFocus","firstFocus","setAnchorEl","focusedTag","setFocusedTag","defaultHighlighted","highlightedIndexRef","setValueState","controlled","default","setInputValueState","focused","setFocused","resetInputValue","newValue","newInputValue","setOpenState","inputPristine","setInputPristine","inputValueIsSelectedValue","popupOpen","value2","previousProps","valueChange","listboxAvailable","focusTag","tagToFocus","setHighlightedIndex","reason","prev","classList","listboxNode","scrollBottom","elementBottom","offsetTop","offsetHeight","changeHighlightedIndex","diff","nextIndex","nextFocus","nextFocusDisabled","validOptionIndex","maxIndex","newIndex","getNextIndex","setSelectionRange","syncHighlightedIndex","previousHighlightedOptionIndex","every","val","value1","previousHighlightedOption","getPreviousHighlightedOptionIndex","valueItem","currentOption","itemIndex","optionItem","handleListboxRef","handleValue","details","isTouch","selectNewValue","reasonProp","origin","isArray","ctrlKey","metaKey","blur","handleFocusTag","nextTag","validTagIndex","handleClear","handleKeyDown","defaultMuiPrevented","preventDefault","handleFocus","handleBlur","handleInputChange","handleOptionMouseMove","handleOptionTouchStart","handleOptionClick","handleTagDelete","handlePopupIndicator","handleMouseDown","handleClick","selectionEnd","selectionStart","select","handleInputMouseDown","dirty","groupedOptions","Map","reduce","acc","group","onMouseDown","getInputLabelProps","htmlFor","getInputProps","onBlur","autoCapitalize","spellCheck","getClearProps","getPopupIndicatorProps","getTagProps","onDelete","getListboxProps","getOptionProps","_getOptionKey","selected","onMouseMove","onTouchStart","expanded","INTENTIONAL_DRAG_COUNT_THRESHOLD","asc","findClosest","values","currentValue","_values$reduce","closestIndex","distance","trackFinger","touchId","changedTouches","touch","identifier","x","y","valueToPercent","roundValueToStep","step","nearest","round","toFixed","num","parts","toExponential","split","matissaDecimalPart","decimalPart","toString","getDecimalPrecision","setValueIndex","output","focusThumb","sliderRef","activeIndex","setActive","_sliderRef$current","_doc$activeElement","_sliderRef$current2","areValuesEqual","oldValue","array1","array2","itemComparer","areArraysEqual","axisProps","horizontal","offset","percent","leap","right","vertical","bottom","Identity","cachedSupportsTouchActionNone","doesSupportTouchActionNone","CSS","supports","useSlider","ariaLabelledby","disableSwap","isRtl","marks","marksProp","onChangeCommitted","orientation","scale","shiftStep","active","setOpen","dragging","setDragging","moveCount","valueDerived","useControlled","handleChange","thumbIndex","clonedEvent","defineProperty","writable","range","clamp","floor","_","marksValues","mark","isFocusVisibleRef","handleBlurVisible","handleFocusVisible","focusVisibleRef","useIsFocusVisible","focusedThumbIndex","setFocusedThumbIndex","handleFocusRef","createHandleHiddenInputFocus","_otherHandlers$onFocu","createHandleHiddenInputBlur","_otherHandlers$onBlur","changeValue","valueInput","marksIndex","maxMarksValue","Infinity","previousValue","createHandleHiddenInputKeyDown","_document$activeEleme","previousIndex","axis","getFingerNewValue","finger","move","slider","getBoundingClientRect","percentToValue","buttons","handleTouchEnd","stopListening","handleTouchStart","passive","trackOffset","trackLeap","createHandleMouseLeave","_otherHandlers$onMous3","onMouseLeave","getHiddenInputProps","externalProps","_parameters$step","externalHandlers","ownEventHandlers","_otherHandlers$onChan","valueAsNumber","mergedEventHandlers","visuallyHidden","_otherHandlers$onMous","defaultPrevented","button","getThumbProps","onMouseOver","_otherHandlers$onMous2","getThumbStyle","pointerEvents","useSnackbar","autoHideDuration","disableWindowBlurListener","resumeHideDuration","timerAutoHide","setAutoHideTimer","autoHideDurationParam","start","handlePause","handleResume","createHandleFocus","onFocusCallback","createMouseEnter","onMouseEnterCallback","onMouseEnter","createMouseLeave","onMouseLeaveCallback","window","onBlurCallback","appendOwnerState","otherProps","object","excludeKeys","prop","match","includes","isHostComponent","omitEventHandlers","mergeSlotProps","getSlotProps","joinedClasses","clsx","mergedStyle","internalRef","eventHandlers","componentsPropsWithoutEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","resolveComponentProps","componentProps","slotState","_parameters$additiona","skipResolvingSlotProps","rest","resolvedComponentsProps","mergedProps"],"sourceRoot":""}