{"version":3,"sources":["../node_modules/@material-ui/core/esm/Unstable_TrapFocus/Unstable_TrapFocus.js","../node_modules/@material-ui/core/esm/styles/useTheme.js","../node_modules/@material-ui/core/esm/transitions/utils.js","../node_modules/react-transition-group/esm/utils/reflow.js","../node_modules/@material-ui/core/esm/Modal/ModalManager.js","../node_modules/@material-ui/core/esm/Modal/SimpleBackdrop.js","../node_modules/@material-ui/core/esm/Modal/Modal.js","../node_modules/@material-ui/core/esm/utils/getScrollbarSize.js","../node_modules/react-transition-group/esm/config.js","../node_modules/react-transition-group/esm/Transition.js","../node_modules/@material-ui/core/esm/Portal/Portal.js"],"names":["Unstable_TrapFocus","props","children","_props$disableAutoFoc","disableAutoFocus","_props$disableEnforce","disableEnforceFocus","_props$disableRestore","disableRestoreFocus","getDoc","isEnabled","open","ignoreNextEnforceFocus","React","sentinelStart","sentinelEnd","nodeToRestore","rootRef","handleOwnRef","instance","current","ReactDOM","handleRef","useForkRef","ref","prevOpenRef","window","activeElement","doc","ownerDocument","contains","hasAttribute","setAttribute","focus","contain","hasFocus","loopFocus","event","keyCode","shiftKey","addEventListener","interval","setInterval","clearInterval","removeEventListener","tabIndex","useTheme","useThemeWithoutDefault","defaultTheme","reflow","node","scrollTop","getTransitionProps","options","timeout","_props$style","style","duration","transitionDuration","mode","delay","transitionDelay","forceReflow","ariaHidden","show","removeAttribute","getPaddingRight","parseInt","getComputedStyle","ariaHiddenSiblings","container","mountNode","currentNode","nodesToExclude","arguments","length","undefined","blacklist","concat","_toConsumableArray","blacklistTagNames","forEach","call","nodeType","indexOf","tagName","findIndexOf","containerInfo","callback","idx","some","item","index","handleContainer","fixedNodes","restoreStyle","restorePaddings","disableScrollLock","body","ownerWindow","innerWidth","documentElement","clientWidth","scrollHeight","clientHeight","isOverflowing","scrollbarSize","getScrollbarSize","push","value","paddingRight","key","el","querySelectorAll","parent","parentElement","scrollContainer","nodeName","overflow","i","removeProperty","_ref","setProperty","ModalManager","_classCallCheck","this","modals","containers","_createClass","modal","modalIndex","modalRef","hiddenSiblingNodes","hiddenSiblings","getAttribute","getHiddenSiblings","containerIndex","restore","splice","nextTop","styles","root","zIndex","position","right","bottom","top","left","backgroundColor","WebkitTapHighlightColor","invisible","SimpleBackdrop","_props$invisible","other","_objectWithoutProperties","_extends","defaultManager","Modal","inProps","theme","getThemeProps","name","_props$BackdropCompon","BackdropComponent","BackdropProps","_props$closeAfterTran","closeAfterTransition","_props$disableBackdro","disableBackdropClick","_props$disableEscapeK","disableEscapeKeyDown","_props$disablePortal","disablePortal","_props$disableScrollL","_props$hideBackdrop","hideBackdrop","_props$keepMounted","keepMounted","_props$manager","manager","onBackdropClick","onClose","onEscapeKeyDown","onRendered","_React$useState","exited","setExited","mountNodeRef","hasTransition","hasOwnProperty","getHasTransition","getModal","handleMounted","mount","handleOpen","useEventCallback","resolvedContainer","getContainer","add","isTopModal","handlePortalRef","handleClose","remove","inlineStyle","hidden","visibility","childProps","onEnter","createChainedFunction","onExited","Portal","onKeyDown","stopPropagation","role","onClick","target","currentTarget","TrapFocus","scrollDiv","document","createElement","width","height","appendChild","offsetWidth","removeChild","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","Transition","_React$Component","context","_this","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","_inheritsLoose","getDerivedStateFromProps","prevState","_proto","prototype","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","mounting","nodeRef","findDOMNode","performEnter","performExit","setState","_this2","appearing","_ref2","maybeNode","maybeAppearing","timeouts","enterTimeout","config","safeSetState","onEntered","onEntering","onTransitionEnd","_this3","onExit","onExiting","cancel","nextState","setNextCallback","_this4","active","handler","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","setTimeout","render","_this$props","_objectWithoutPropertiesLoose","TransitionGroupContext","Provider","cloneElement","Children","only","Component","noop","contextType","propTypes","defaultProps","useEnhancedEffect","setMountNode","setRef"],"mappings":"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","file":"static/js/1.910c46f0.chunk.js","sourcesContent":["/* eslint-disable consistent-return, jsx-a11y/no-noninteractive-tabindex, camelcase */\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport PropTypes from 'prop-types';\nimport ownerDocument from '../utils/ownerDocument';\nimport useForkRef from '../utils/useForkRef';\nimport { exactProp } from '@material-ui/utils';\n/**\n * Utility component that locks focus inside the component.\n */\n\nfunction Unstable_TrapFocus(props) {\n  var children = props.children,\n      _props$disableAutoFoc = props.disableAutoFocus,\n      disableAutoFocus = _props$disableAutoFoc === void 0 ? false : _props$disableAutoFoc,\n      _props$disableEnforce = props.disableEnforceFocus,\n      disableEnforceFocus = _props$disableEnforce === void 0 ? false : _props$disableEnforce,\n      _props$disableRestore = props.disableRestoreFocus,\n      disableRestoreFocus = _props$disableRestore === void 0 ? false : _props$disableRestore,\n      getDoc = props.getDoc,\n      isEnabled = props.isEnabled,\n      open = props.open;\n  var ignoreNextEnforceFocus = React.useRef();\n  var sentinelStart = React.useRef(null);\n  var sentinelEnd = React.useRef(null);\n  var nodeToRestore = React.useRef();\n  var rootRef = React.useRef(null); // can be removed once we drop support for non ref forwarding class components\n\n  var handleOwnRef = React.useCallback(function (instance) {\n    // #StrictMode ready\n    rootRef.current = ReactDOM.findDOMNode(instance);\n  }, []);\n  var handleRef = useForkRef(children.ref, handleOwnRef);\n  var prevOpenRef = React.useRef();\n  React.useEffect(function () {\n    prevOpenRef.current = open;\n  }, [open]);\n\n  if (!prevOpenRef.current && open && typeof window !== 'undefined') {\n    // WARNING: Potentially unsafe in concurrent mode.\n    // The way the read on `nodeToRestore` is setup could make this actually safe.\n    // Say we render `open={false}` -> `open={true}` but never commit.\n    // We have now written a state that wasn't committed. But no committed effect\n    // will read this wrong value. We only read from `nodeToRestore` in effects\n    // that were committed on `open={true}`\n    // WARNING: Prevents the instance from being garbage collected. Should only\n    // hold a weak ref.\n    nodeToRestore.current = getDoc().activeElement;\n  }\n\n  React.useEffect(function () {\n    if (!open) {\n      return;\n    }\n\n    var doc = ownerDocument(rootRef.current); // We might render an empty child.\n\n    if (!disableAutoFocus && rootRef.current && !rootRef.current.contains(doc.activeElement)) {\n      if (!rootRef.current.hasAttribute('tabIndex')) {\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(['Material-UI: 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\n        rootRef.current.setAttribute('tabIndex', -1);\n      }\n\n      rootRef.current.focus();\n    }\n\n    var contain = function contain() {\n      var rootElement = rootRef.current; // 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\n      if (rootElement === null) {\n        return;\n      }\n\n      if (!doc.hasFocus() || disableEnforceFocus || !isEnabled() || ignoreNextEnforceFocus.current) {\n        ignoreNextEnforceFocus.current = false;\n        return;\n      }\n\n      if (rootRef.current && !rootRef.current.contains(doc.activeElement)) {\n        rootRef.current.focus();\n      }\n    };\n\n    var loopFocus = function loopFocus(event) {\n      // 9 = Tab\n      if (disableEnforceFocus || !isEnabled() || event.keyCode !== 9) {\n        return;\n      } // Make sure the next tab starts from the right place.\n\n\n      if (doc.activeElement === rootRef.current) {\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\n        if (event.shiftKey) {\n          sentinelEnd.current.focus();\n        } else {\n          sentinelStart.current.focus();\n        }\n      }\n    };\n\n    doc.addEventListener('focus', contain, true);\n    doc.addEventListener('keydown', loopFocus, true); // With Edge, Safari and Firefox, no focus related events are fired when the focused area stops being a focused area\n    // e.g. https://bugzilla.mozilla.org/show_bug.cgi?id=559561.\n    //\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\n    var interval = setInterval(function () {\n      contain();\n    }, 50);\n    return function () {\n      clearInterval(interval);\n      doc.removeEventListener('focus', contain, true);\n      doc.removeEventListener('keydown', loopFocus, true); // restoreLastFocus()\n\n      if (!disableRestoreFocus) {\n        // In IE 11 it is possible for document.activeElement to be null resulting\n        // in nodeToRestore.current being null.\n        // Not all elements in IE 11 have a focus method.\n        // Once IE 11 support is dropped the focus() call can be unconditional.\n        if (nodeToRestore.current && nodeToRestore.current.focus) {\n          nodeToRestore.current.focus();\n        }\n\n        nodeToRestore.current = null;\n      }\n    };\n  }, [disableAutoFocus, disableEnforceFocus, disableRestoreFocus, isEnabled, open]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"div\", {\n    tabIndex: 0,\n    ref: sentinelStart,\n    \"data-test\": \"sentinelStart\"\n  }), /*#__PURE__*/React.cloneElement(children, {\n    ref: handleRef\n  }), /*#__PURE__*/React.createElement(\"div\", {\n    tabIndex: 0,\n    ref: sentinelEnd,\n    \"data-test\": \"sentinelEnd\"\n  }));\n}\n\nprocess.env.NODE_ENV !== \"production\" ? Unstable_TrapFocus.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * A single child content element.\n   */\n  children: PropTypes.node,\n\n  /**\n   * If `true`, the trap focus 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 trap focus children that have the `disableAutoFocus` prop.\n   *\n   * Generally this should never be set to `true` as it makes the trap focus less\n   * accessible to assistive technologies, like screen readers.\n   */\n  disableAutoFocus: PropTypes.bool,\n\n  /**\n   * If `true`, the trap focus will not prevent focus from leaving the trap focus while open.\n   *\n   * Generally this should never be set to `true` as it makes the trap focus less\n   * accessible to assistive technologies, like screen readers.\n   */\n  disableEnforceFocus: PropTypes.bool,\n\n  /**\n   * If `true`, the trap focus will not restore focus to previously focused element once\n   * trap focus is hidden.\n   */\n  disableRestoreFocus: PropTypes.bool,\n\n  /**\n   * Return the document to consider.\n   * We use it to implement the restore focus between different browser documents.\n   */\n  getDoc: PropTypes.func.isRequired,\n\n  /**\n   * Do we still want to enforce the focus?\n   * This prop helps nesting TrapFocus elements.\n   */\n  isEnabled: PropTypes.func.isRequired,\n\n  /**\n   * If `true`, focus will be locked.\n   */\n  open: PropTypes.bool.isRequired\n} : void 0;\n\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  Unstable_TrapFocus['propTypes' + ''] = exactProp(Unstable_TrapFocus.propTypes);\n}\n\nexport default Unstable_TrapFocus;","import { useTheme as useThemeWithoutDefault } from '@material-ui/styles';\nimport React from 'react';\nimport defaultTheme from './defaultTheme';\nexport default function useTheme() {\n  var theme = useThemeWithoutDefault() || defaultTheme;\n\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useDebugValue(theme);\n  }\n\n  return theme;\n}","export var reflow = function reflow(node) {\n  return node.scrollTop;\n};\nexport function getTransitionProps(props, options) {\n  var timeout = props.timeout,\n      _props$style = props.style,\n      style = _props$style === void 0 ? {} : _props$style;\n  return {\n    duration: style.transitionDuration || typeof timeout === 'number' ? timeout : timeout[options.mode] || 0,\n    delay: style.transitionDelay\n  };\n}","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};","import _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport getScrollbarSize from '../utils/getScrollbarSize';\nimport ownerDocument from '../utils/ownerDocument';\nimport ownerWindow from '../utils/ownerWindow'; // Is a vertical scrollbar displayed?\n\nfunction isOverflowing(container) {\n  var doc = ownerDocument(container);\n\n  if (doc.body === container) {\n    return ownerWindow(doc).innerWidth > doc.documentElement.clientWidth;\n  }\n\n  return container.scrollHeight > container.clientHeight;\n}\n\nexport function ariaHidden(node, show) {\n  if (show) {\n    node.setAttribute('aria-hidden', 'true');\n  } else {\n    node.removeAttribute('aria-hidden');\n  }\n}\n\nfunction getPaddingRight(node) {\n  return parseInt(window.getComputedStyle(node)['padding-right'], 10) || 0;\n}\n\nfunction ariaHiddenSiblings(container, mountNode, currentNode) {\n  var nodesToExclude = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];\n  var show = arguments.length > 4 ? arguments[4] : undefined;\n  var blacklist = [mountNode, currentNode].concat(_toConsumableArray(nodesToExclude));\n  var blacklistTagNames = ['TEMPLATE', 'SCRIPT', 'STYLE'];\n  [].forEach.call(container.children, function (node) {\n    if (node.nodeType === 1 && blacklist.indexOf(node) === -1 && blacklistTagNames.indexOf(node.tagName) === -1) {\n      ariaHidden(node, show);\n    }\n  });\n}\n\nfunction findIndexOf(containerInfo, callback) {\n  var idx = -1;\n  containerInfo.some(function (item, index) {\n    if (callback(item)) {\n      idx = index;\n      return true;\n    }\n\n    return false;\n  });\n  return idx;\n}\n\nfunction handleContainer(containerInfo, props) {\n  var restoreStyle = [];\n  var restorePaddings = [];\n  var container = containerInfo.container;\n  var fixedNodes;\n\n  if (!props.disableScrollLock) {\n    if (isOverflowing(container)) {\n      // Compute the size before applying overflow hidden to avoid any scroll jumps.\n      var scrollbarSize = getScrollbarSize();\n      restoreStyle.push({\n        value: container.style.paddingRight,\n        key: 'padding-right',\n        el: container\n      }); // Use computed style, here to get the real padding to add our scrollbar width.\n\n      container.style['padding-right'] = \"\".concat(getPaddingRight(container) + scrollbarSize, \"px\"); // .mui-fixed is a global helper.\n\n      fixedNodes = ownerDocument(container).querySelectorAll('.mui-fixed');\n      [].forEach.call(fixedNodes, function (node) {\n        restorePaddings.push(node.style.paddingRight);\n        node.style.paddingRight = \"\".concat(getPaddingRight(node) + scrollbarSize, \"px\");\n      });\n    } // Improve Gatsby support\n    // https://css-tricks.com/snippets/css/force-vertical-scrollbar/\n\n\n    var parent = container.parentElement;\n    var scrollContainer = parent.nodeName === 'HTML' && window.getComputedStyle(parent)['overflow-y'] === 'scroll' ? parent : container; // Block the scroll even if no scrollbar is visible to account for mobile keyboard\n    // screensize shrink.\n\n    restoreStyle.push({\n      value: scrollContainer.style.overflow,\n      key: 'overflow',\n      el: scrollContainer\n    });\n    scrollContainer.style.overflow = 'hidden';\n  }\n\n  var restore = function restore() {\n    if (fixedNodes) {\n      [].forEach.call(fixedNodes, function (node, i) {\n        if (restorePaddings[i]) {\n          node.style.paddingRight = restorePaddings[i];\n        } else {\n          node.style.removeProperty('padding-right');\n        }\n      });\n    }\n\n    restoreStyle.forEach(function (_ref) {\n      var value = _ref.value,\n          el = _ref.el,\n          key = _ref.key;\n\n      if (value) {\n        el.style.setProperty(key, value);\n      } else {\n        el.style.removeProperty(key);\n      }\n    });\n  };\n\n  return restore;\n}\n\nfunction getHiddenSiblings(container) {\n  var hiddenSiblings = [];\n  [].forEach.call(container.children, function (node) {\n    if (node.getAttribute && node.getAttribute('aria-hidden') === 'true') {\n      hiddenSiblings.push(node);\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 */\n\n\nvar ModalManager = /*#__PURE__*/function () {\n  function ModalManager() {\n    _classCallCheck(this, ModalManager);\n\n    // this.modals[modalIndex] = modal\n    this.modals = []; // this.containers[containerIndex] = {\n    //   modals: [],\n    //   container,\n    //   restore: null,\n    // }\n\n    this.containers = [];\n  }\n\n  _createClass(ModalManager, [{\n    key: \"add\",\n    value: function add(modal, container) {\n      var modalIndex = this.modals.indexOf(modal);\n\n      if (modalIndex !== -1) {\n        return modalIndex;\n      }\n\n      modalIndex = this.modals.length;\n      this.modals.push(modal); // If the modal we are adding is already in the DOM.\n\n      if (modal.modalRef) {\n        ariaHidden(modal.modalRef, false);\n      }\n\n      var hiddenSiblingNodes = getHiddenSiblings(container);\n      ariaHiddenSiblings(container, modal.mountNode, modal.modalRef, hiddenSiblingNodes, true);\n      var containerIndex = findIndexOf(this.containers, function (item) {\n        return item.container === container;\n      });\n\n      if (containerIndex !== -1) {\n        this.containers[containerIndex].modals.push(modal);\n        return modalIndex;\n      }\n\n      this.containers.push({\n        modals: [modal],\n        container: container,\n        restore: null,\n        hiddenSiblingNodes: hiddenSiblingNodes\n      });\n      return modalIndex;\n    }\n  }, {\n    key: \"mount\",\n    value: function mount(modal, props) {\n      var containerIndex = findIndexOf(this.containers, function (item) {\n        return item.modals.indexOf(modal) !== -1;\n      });\n      var containerInfo = this.containers[containerIndex];\n\n      if (!containerInfo.restore) {\n        containerInfo.restore = handleContainer(containerInfo, props);\n      }\n    }\n  }, {\n    key: \"remove\",\n    value: function remove(modal) {\n      var modalIndex = this.modals.indexOf(modal);\n\n      if (modalIndex === -1) {\n        return modalIndex;\n      }\n\n      var containerIndex = findIndexOf(this.containers, function (item) {\n        return item.modals.indexOf(modal) !== -1;\n      });\n      var containerInfo = this.containers[containerIndex];\n      containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);\n      this.modals.splice(modalIndex, 1); // If that was the last modal in a container, clean up the container.\n\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\n        if (modal.modalRef) {\n          // In case the modal wasn't in the DOM yet.\n          ariaHidden(modal.modalRef, true);\n        }\n\n        ariaHiddenSiblings(containerInfo.container, modal.mountNode, modal.modalRef, containerInfo.hiddenSiblingNodes, false);\n        this.containers.splice(containerIndex, 1);\n      } else {\n        // Otherwise make sure the next top modal is visible to a screen reader.\n        var nextTop = containerInfo.modals[containerInfo.modals.length - 1]; // 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\n        if (nextTop.modalRef) {\n          ariaHidden(nextTop.modalRef, false);\n        }\n      }\n\n      return modalIndex;\n    }\n  }, {\n    key: \"isTopModal\",\n    value: function isTopModal(modal) {\n      return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;\n    }\n  }]);\n\n  return ModalManager;\n}();\n\nexport { ModalManager as default };","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nexport var styles = {\n  /* Styles applied to the root element. */\n  root: {\n    zIndex: -1,\n    position: 'fixed',\n    right: 0,\n    bottom: 0,\n    top: 0,\n    left: 0,\n    backgroundColor: 'rgba(0, 0, 0, 0.5)',\n    WebkitTapHighlightColor: 'transparent'\n  },\n\n  /* Styles applied to the root element if `invisible={true}`. */\n  invisible: {\n    backgroundColor: 'transparent'\n  }\n};\n/**\n * @ignore - internal component.\n */\n\nvar SimpleBackdrop = /*#__PURE__*/React.forwardRef(function SimpleBackdrop(props, ref) {\n  var _props$invisible = props.invisible,\n      invisible = _props$invisible === void 0 ? false : _props$invisible,\n      open = props.open,\n      other = _objectWithoutProperties(props, [\"invisible\", \"open\"]);\n\n  return open ? /*#__PURE__*/React.createElement(\"div\", _extends({\n    \"aria-hidden\": true,\n    ref: ref\n  }, other, {\n    style: _extends({}, styles.root, invisible ? styles.invisible : {}, other.style)\n  })) : null;\n});\nprocess.env.NODE_ENV !== \"production\" ? SimpleBackdrop.propTypes = {\n  /**\n   * If `true`, the backdrop is invisible.\n   * It can be used when rendering a popover or a custom select component.\n   */\n  invisible: PropTypes.bool,\n\n  /**\n   * If `true`, the backdrop is open.\n   */\n  open: PropTypes.bool.isRequired\n} : void 0;\nexport default SimpleBackdrop;","import _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport PropTypes from 'prop-types';\nimport { getThemeProps, useTheme } from '@material-ui/styles';\nimport { elementAcceptingRef, HTMLElementType } from '@material-ui/utils';\nimport deprecatedPropType from '../utils/deprecatedPropType';\nimport ownerDocument from '../utils/ownerDocument';\nimport Portal from '../Portal';\nimport createChainedFunction from '../utils/createChainedFunction';\nimport useForkRef from '../utils/useForkRef';\nimport useEventCallback from '../utils/useEventCallback';\nimport zIndex from '../styles/zIndex';\nimport ModalManager, { ariaHidden } from './ModalManager';\nimport TrapFocus from '../Unstable_TrapFocus';\nimport SimpleBackdrop from './SimpleBackdrop';\n\nfunction getContainer(container) {\n  container = typeof container === 'function' ? container() : container;\n  return ReactDOM.findDOMNode(container);\n}\n\nfunction getHasTransition(props) {\n  return props.children ? props.children.props.hasOwnProperty('in') : false;\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.\n\n\nvar defaultManager = new ModalManager();\nexport var styles = function styles(theme) {\n  return {\n    /* Styles applied to the root element. */\n    root: {\n      position: 'fixed',\n      zIndex: theme.zIndex.modal,\n      right: 0,\n      bottom: 0,\n      top: 0,\n      left: 0\n    },\n\n    /* Styles applied to the root element if the `Modal` has exited. */\n    hidden: {\n      visibility: 'hidden'\n    }\n  };\n};\n/**\n * Modal is a lower-level construct that is leveraged by the following components:\n *\n * - [Dialog](/api/dialog/)\n * - [Drawer](/api/drawer/)\n * - [Menu](/api/menu/)\n * - [Popover](/api/popover/)\n *\n * If you are creating a modal dialog, you probably want to use the [Dialog](/api/dialog/) component\n * rather than directly using Modal.\n *\n * This component shares many concepts with [react-overlays](https://react-bootstrap.github.io/react-overlays/#modals).\n */\n\nvar Modal = /*#__PURE__*/React.forwardRef(function Modal(inProps, ref) {\n  var theme = useTheme();\n  var props = getThemeProps({\n    name: 'MuiModal',\n    props: _extends({}, inProps),\n    theme: theme\n  });\n\n  var _props$BackdropCompon = props.BackdropComponent,\n      BackdropComponent = _props$BackdropCompon === void 0 ? SimpleBackdrop : _props$BackdropCompon,\n      BackdropProps = props.BackdropProps,\n      children = props.children,\n      _props$closeAfterTran = props.closeAfterTransition,\n      closeAfterTransition = _props$closeAfterTran === void 0 ? false : _props$closeAfterTran,\n      container = props.container,\n      _props$disableAutoFoc = props.disableAutoFocus,\n      disableAutoFocus = _props$disableAutoFoc === void 0 ? false : _props$disableAutoFoc,\n      _props$disableBackdro = props.disableBackdropClick,\n      disableBackdropClick = _props$disableBackdro === void 0 ? false : _props$disableBackdro,\n      _props$disableEnforce = props.disableEnforceFocus,\n      disableEnforceFocus = _props$disableEnforce === void 0 ? false : _props$disableEnforce,\n      _props$disableEscapeK = props.disableEscapeKeyDown,\n      disableEscapeKeyDown = _props$disableEscapeK === void 0 ? false : _props$disableEscapeK,\n      _props$disablePortal = props.disablePortal,\n      disablePortal = _props$disablePortal === void 0 ? false : _props$disablePortal,\n      _props$disableRestore = props.disableRestoreFocus,\n      disableRestoreFocus = _props$disableRestore === void 0 ? false : _props$disableRestore,\n      _props$disableScrollL = props.disableScrollLock,\n      disableScrollLock = _props$disableScrollL === void 0 ? false : _props$disableScrollL,\n      _props$hideBackdrop = props.hideBackdrop,\n      hideBackdrop = _props$hideBackdrop === void 0 ? false : _props$hideBackdrop,\n      _props$keepMounted = props.keepMounted,\n      keepMounted = _props$keepMounted === void 0 ? false : _props$keepMounted,\n      _props$manager = props.manager,\n      manager = _props$manager === void 0 ? defaultManager : _props$manager,\n      onBackdropClick = props.onBackdropClick,\n      onClose = props.onClose,\n      onEscapeKeyDown = props.onEscapeKeyDown,\n      onRendered = props.onRendered,\n      open = props.open,\n      other = _objectWithoutProperties(props, [\"BackdropComponent\", \"BackdropProps\", \"children\", \"closeAfterTransition\", \"container\", \"disableAutoFocus\", \"disableBackdropClick\", \"disableEnforceFocus\", \"disableEscapeKeyDown\", \"disablePortal\", \"disableRestoreFocus\", \"disableScrollLock\", \"hideBackdrop\", \"keepMounted\", \"manager\", \"onBackdropClick\", \"onClose\", \"onEscapeKeyDown\", \"onRendered\", \"open\"]);\n\n  var _React$useState = React.useState(true),\n      exited = _React$useState[0],\n      setExited = _React$useState[1];\n\n  var modal = React.useRef({});\n  var mountNodeRef = React.useRef(null);\n  var modalRef = React.useRef(null);\n  var handleRef = useForkRef(modalRef, ref);\n  var hasTransition = getHasTransition(props);\n\n  var getDoc = function getDoc() {\n    return ownerDocument(mountNodeRef.current);\n  };\n\n  var getModal = function getModal() {\n    modal.current.modalRef = modalRef.current;\n    modal.current.mountNode = mountNodeRef.current;\n    return modal.current;\n  };\n\n  var handleMounted = function handleMounted() {\n    manager.mount(getModal(), {\n      disableScrollLock: disableScrollLock\n    }); // Fix a bug on Chrome where the scroll isn't initially 0.\n\n    modalRef.current.scrollTop = 0;\n  };\n\n  var handleOpen = useEventCallback(function () {\n    var resolvedContainer = getContainer(container) || getDoc().body;\n    manager.add(getModal(), resolvedContainer); // The element was already mounted.\n\n    if (modalRef.current) {\n      handleMounted();\n    }\n  });\n  var isTopModal = React.useCallback(function () {\n    return manager.isTopModal(getModal());\n  }, [manager]);\n  var handlePortalRef = useEventCallback(function (node) {\n    mountNodeRef.current = node;\n\n    if (!node) {\n      return;\n    }\n\n    if (onRendered) {\n      onRendered();\n    }\n\n    if (open && isTopModal()) {\n      handleMounted();\n    } else {\n      ariaHidden(modalRef.current, true);\n    }\n  });\n  var handleClose = React.useCallback(function () {\n    manager.remove(getModal());\n  }, [manager]);\n  React.useEffect(function () {\n    return function () {\n      handleClose();\n    };\n  }, [handleClose]);\n  React.useEffect(function () {\n    if (open) {\n      handleOpen();\n    } else if (!hasTransition || !closeAfterTransition) {\n      handleClose();\n    }\n  }, [open, handleClose, hasTransition, closeAfterTransition, handleOpen]);\n\n  if (!keepMounted && !open && (!hasTransition || exited)) {\n    return null;\n  }\n\n  var handleEnter = function handleEnter() {\n    setExited(false);\n  };\n\n  var handleExited = function handleExited() {\n    setExited(true);\n\n    if (closeAfterTransition) {\n      handleClose();\n    }\n  };\n\n  var handleBackdropClick = function handleBackdropClick(event) {\n    if (event.target !== event.currentTarget) {\n      return;\n    }\n\n    if (onBackdropClick) {\n      onBackdropClick(event);\n    }\n\n    if (!disableBackdropClick && onClose) {\n      onClose(event, 'backdropClick');\n    }\n  };\n\n  var handleKeyDown = function handleKeyDown(event) {\n    // The handler doesn't take event.defaultPrevented into account:\n    //\n    // event.preventDefault() is meant to stop default behaviours 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' || !isTopModal()) {\n      return;\n    }\n\n    if (onEscapeKeyDown) {\n      onEscapeKeyDown(event);\n    }\n\n    if (!disableEscapeKeyDown) {\n      // Swallow the event, in case someone is listening for the escape key on the body.\n      event.stopPropagation();\n\n      if (onClose) {\n        onClose(event, 'escapeKeyDown');\n      }\n    }\n  };\n\n  var inlineStyle = styles(theme || {\n    zIndex: zIndex\n  });\n  var childProps = {};\n\n  if (children.props.tabIndex === undefined) {\n    childProps.tabIndex = children.props.tabIndex || '-1';\n  } // It's a Transition like component\n\n\n  if (hasTransition) {\n    childProps.onEnter = createChainedFunction(handleEnter, children.props.onEnter);\n    childProps.onExited = createChainedFunction(handleExited, children.props.onExited);\n  }\n\n  return /*#__PURE__*/React.createElement(Portal, {\n    ref: handlePortalRef,\n    container: container,\n    disablePortal: disablePortal\n  }, /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: handleRef,\n    onKeyDown: handleKeyDown,\n    role: \"presentation\"\n  }, other, {\n    style: _extends({}, inlineStyle.root, !open && exited ? inlineStyle.hidden : {}, other.style)\n  }), hideBackdrop ? null : /*#__PURE__*/React.createElement(BackdropComponent, _extends({\n    open: open,\n    onClick: handleBackdropClick\n  }, BackdropProps)), /*#__PURE__*/React.createElement(TrapFocus, {\n    disableEnforceFocus: disableEnforceFocus,\n    disableAutoFocus: disableAutoFocus,\n    disableRestoreFocus: disableRestoreFocus,\n    getDoc: getDoc,\n    isEnabled: isTopModal,\n    open: open\n  }, /*#__PURE__*/React.cloneElement(children, childProps))));\n});\nprocess.env.NODE_ENV !== \"production\" ? Modal.propTypes = {\n  /**\n   * A backdrop component. This prop enables custom backdrop rendering.\n   */\n  BackdropComponent: PropTypes.elementType,\n\n  /**\n   * Props applied to the [`Backdrop`](/api/backdrop/) element.\n   */\n  BackdropProps: PropTypes.object,\n\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef.isRequired,\n\n  /**\n   * When set to true the Modal waits until a nested Transition is completed before closing.\n   */\n  closeAfterTransition: PropTypes.bool,\n\n  /**\n   * A HTML element, component instance, or function that returns either.\n   * The `container` will have the portal children appended to it.\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\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([HTMLElementType, PropTypes.instanceOf(React.Component), PropTypes.func]),\n\n  /**\n   * If `true`, the modal will not automatically shift focus to itself when it opens, and\n   * replace it to the last focused element when it closes.\n   * This also works correctly with any modal children that have the `disableAutoFocus` prop.\n   *\n   * Generally this should never be set to `true` as it makes the modal less\n   * accessible to assistive technologies, like screen readers.\n   */\n  disableAutoFocus: PropTypes.bool,\n\n  /**\n   * If `true`, clicking the backdrop will not fire `onClose`.\n   */\n  disableBackdropClick: deprecatedPropType(PropTypes.bool, 'Use the onClose prop with the `reason` argument to filter the `backdropClick` events.'),\n\n  /**\n   * If `true`, the modal will not prevent focus from leaving the modal while open.\n   *\n   * Generally this should never be set to `true` as it makes the modal less\n   * accessible to assistive technologies, like screen readers.\n   */\n  disableEnforceFocus: PropTypes.bool,\n\n  /**\n   * If `true`, hitting escape will not fire `onClose`.\n   */\n  disableEscapeKeyDown: PropTypes.bool,\n\n  /**\n   * Disable the portal behavior.\n   * The children stay within it's parent DOM hierarchy.\n   */\n  disablePortal: PropTypes.bool,\n\n  /**\n   * If `true`, the modal will not restore focus to previously focused element once\n   * modal is hidden.\n   */\n  disableRestoreFocus: PropTypes.bool,\n\n  /**\n   * Disable the scroll lock behavior.\n   */\n  disableScrollLock: PropTypes.bool,\n\n  /**\n   * If `true`, the backdrop is not rendered.\n   */\n  hideBackdrop: PropTypes.bool,\n\n  /**\n   * Always keep the children in the DOM.\n   * This prop can be useful in SEO situation or\n   * when you want to maximize the responsiveness of the Modal.\n   */\n  keepMounted: PropTypes.bool,\n\n  /**\n   * @ignore\n   */\n  manager: PropTypes.object,\n\n  /**\n   * Callback fired when the backdrop is clicked.\n   */\n  onBackdropClick: deprecatedPropType(PropTypes.func, 'Use the onClose prop with the `reason` argument to handle the `backdropClick` events.'),\n\n  /**\n   * Callback fired when the component requests to be closed.\n   * The `reason` parameter can optionally be used to control the response to `onClose`.\n   *\n   * @param {object} event The event source of the callback.\n   * @param {string} reason Can be: `\"escapeKeyDown\"`, `\"backdropClick\"`.\n   */\n  onClose: PropTypes.func,\n\n  /**\n   * Callback fired when the escape key is pressed,\n   * `disableEscapeKeyDown` is false and the modal is in focus.\n   */\n  onEscapeKeyDown: deprecatedPropType(PropTypes.func, 'Use the onClose prop with the `reason` argument to handle the `escapeKeyDown` events.'),\n\n  /**\n   * Callback fired once the children has been mounted into the `container`.\n   * It signals that the `open={true}` prop took effect.\n   *\n   * This prop will be removed in v5, the ref can be used instead.\n   */\n  onRendered: deprecatedPropType(PropTypes.func, 'Use the ref instead.'),\n\n  /**\n   * If `true`, the modal is open.\n   */\n  open: PropTypes.bool.isRequired\n} : void 0;\nexport default Modal;","// A change of the browser zoom change the scrollbar size.\n// Credit https://github.com/twbs/bootstrap/blob/3ffe3a5d82f6f561b82ff78d82b32a7d14aed558/js/src/modal.js#L512-L519\nexport default function getScrollbarSize() {\n  var scrollDiv = document.createElement('div');\n  scrollDiv.style.width = '99px';\n  scrollDiv.style.height = '99px';\n  scrollDiv.style.position = 'absolute';\n  scrollDiv.style.top = '-9999px';\n  scrollDiv.style.overflow = 'scroll';\n  document.body.appendChild(scrollDiv);\n  var scrollbarSize = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n  document.body.removeChild(scrollDiv);\n  return scrollbarSize;\n}","export default {\n  disabled: false\n};","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { forceReflow } from './utils/reflow';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        if (this.props.unmountOnExit || this.props.mountOnEnter) {\n          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749\n          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.\n          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.\n\n          if (node) forceReflow(node);\n        }\n\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {\n      var value = propValue[key];\n      return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);\n    }\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport PropTypes from 'prop-types';\nimport { exactProp, HTMLElementType } from '@material-ui/utils';\nimport deprecatedPropType from '../utils/deprecatedPropType';\nimport setRef from '../utils/setRef';\nimport useForkRef from '../utils/useForkRef';\n\nfunction getContainer(container) {\n  container = typeof container === 'function' ? container() : container; // #StrictMode ready\n\n  return ReactDOM.findDOMNode(container);\n}\n\nvar useEnhancedEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\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\nvar Portal = /*#__PURE__*/React.forwardRef(function Portal(props, ref) {\n  var children = props.children,\n      container = props.container,\n      _props$disablePortal = props.disablePortal,\n      disablePortal = _props$disablePortal === void 0 ? false : _props$disablePortal,\n      onRendered = props.onRendered;\n\n  var _React$useState = React.useState(null),\n      mountNode = _React$useState[0],\n      setMountNode = _React$useState[1];\n\n  var handleRef = useForkRef( /*#__PURE__*/React.isValidElement(children) ? children.ref : null, ref);\n  useEnhancedEffect(function () {\n    if (!disablePortal) {\n      setMountNode(getContainer(container) || document.body);\n    }\n  }, [container, disablePortal]);\n  useEnhancedEffect(function () {\n    if (mountNode && !disablePortal) {\n      setRef(ref, mountNode);\n      return function () {\n        setRef(ref, null);\n      };\n    }\n\n    return undefined;\n  }, [ref, mountNode, disablePortal]);\n  useEnhancedEffect(function () {\n    if (onRendered && (mountNode || disablePortal)) {\n      onRendered();\n    }\n  }, [onRendered, mountNode, disablePortal]);\n\n  if (disablePortal) {\n    if ( /*#__PURE__*/React.isValidElement(children)) {\n      return /*#__PURE__*/React.cloneElement(children, {\n        ref: handleRef\n      });\n    }\n\n    return children;\n  }\n\n  return mountNode ? /*#__PURE__*/ReactDOM.createPortal(children, mountNode) : mountNode;\n});\nprocess.env.NODE_ENV !== \"production\" ? Portal.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The children to render into the `container`.\n   */\n  children: PropTypes.node,\n\n  /**\n   * A HTML element, component instance, or function that returns either.\n   * The `container` will have the portal children appended to it.\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\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([HTMLElementType, PropTypes.instanceOf(React.Component), PropTypes.func]),\n\n  /**\n   * Disable the portal behavior.\n   * The children stay within it's parent DOM hierarchy.\n   */\n  disablePortal: PropTypes.bool,\n\n  /**\n   * Callback fired once the children has been mounted into the `container`.\n   *\n   * This prop will be removed in v5, the ref can be used instead.\n   * @deprecated Use the ref instead.\n   */\n  onRendered: deprecatedPropType(PropTypes.func, 'Use the ref instead.')\n} : void 0;\n\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  Portal['propTypes' + ''] = exactProp(Portal.propTypes);\n}\n\nexport default Portal;"],"sourceRoot":""}