{"version":3,"file":"static/js/28151.f68d9802.chunk.js","mappings":"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","sources":["webpack:///./node_modules/@mui/base/Portal/Portal.js","webpack:///./node_modules/@mui/base/utils/appendOwnerState.js","webpack:///./node_modules/@mui/base/utils/extractEventHandlers.js","webpack:///./node_modules/@mui/base/utils/isHostComponent.js","webpack:///./node_modules/@mui/base/utils/omitEventHandlers.js","webpack:///./node_modules/@mui/base/utils/mergeSlotProps.js","webpack:///./node_modules/@mui/base/utils/resolveComponentProps.js","webpack:///./node_modules/@mui/base/utils/useSlotProps.js","webpack:///./node_modules/@mui/material/styles/useTheme.js","webpack:///./node_modules/@mui/material/transitions/utils.js","webpack:///./node_modules/@mui/utils/HTMLElementType/HTMLElementType.js","webpack:///./node_modules/@mui/utils/elementAcceptingRef/elementAcceptingRef.js","webpack:///./node_modules/@mui/utils/exactProp/exactProp.js","webpack:///./node_modules/react-transition-group/esm/utils/PropTypes.js","webpack:///./node_modules/react-transition-group/esm/Transition.js","webpack:///./node_modules/react-transition-group/esm/utils/reflow.js"],"sourcesContent":["'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 };","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}","'use client';\n\nimport * as React from 'react';\nimport { useTheme as useThemeSystem } from '@mui/system';\nimport defaultTheme from './defaultTheme';\nimport THEME_ID from './identifier';\nexport default function useTheme() {\n  const theme = useThemeSystem(defaultTheme);\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useDebugValue(theme);\n  }\n  return theme[THEME_ID] || theme;\n}","export const reflow = node => node.scrollTop;\nexport function getTransitionProps(props, options) {\n  var _style$transitionDura, _style$transitionTimi;\n  const {\n    timeout,\n    easing,\n    style = {}\n  } = props;\n  return {\n    duration: (_style$transitionDura = style.transitionDuration) != null ? _style$transitionDura : typeof timeout === 'number' ? timeout : timeout[options.mode] || 0,\n    easing: (_style$transitionTimi = style.transitionTimingFunction) != null ? _style$transitionTimi : typeof easing === 'object' ? easing[options.mode] : easing,\n    delay: style.transitionDelay\n  };\n}","export default function HTMLElementType(props, propName, componentName, location, propFullName) {\n  if (process.env.NODE_ENV === 'production') {\n    return null;\n  }\n  const propValue = props[propName];\n  const safePropName = propFullName || propName;\n  if (propValue == null) {\n    return null;\n  }\n  if (propValue && propValue.nodeType !== 1) {\n    return new Error(`Invalid ${location} \\`${safePropName}\\` supplied to \\`${componentName}\\`. ` + `Expected an HTMLElement.`);\n  }\n  return null;\n}","import PropTypes from 'prop-types';\nimport chainPropTypes from '../chainPropTypes';\nfunction isClassComponent(elementType) {\n  // elementType.prototype?.isReactComponent\n  const {\n    prototype = {}\n  } = elementType;\n  return Boolean(prototype.isReactComponent);\n}\nfunction acceptingRef(props, propName, componentName, location, propFullName) {\n  const element = props[propName];\n  const safePropName = propFullName || propName;\n  if (element == null ||\n  // When server-side rendering React doesn't warn either.\n  // This is not an accurate check for SSR.\n  // This is only in place for Emotion compat.\n  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.\n  typeof window === 'undefined') {\n    return null;\n  }\n  let warningHint;\n  const elementType = element.type;\n  /**\n   * Blacklisting instead of whitelisting\n   *\n   * Blacklisting will miss some components, such as React.Fragment. Those will at least\n   * trigger a warning in React.\n   * We can't whitelist because there is no safe way to detect React.forwardRef\n   * or class components. \"Safe\" means there's no public API.\n   *\n   */\n  if (typeof elementType === 'function' && !isClassComponent(elementType)) {\n    warningHint = 'Did you accidentally use a plain function component for an element instead?';\n  }\n  if (warningHint !== undefined) {\n    return new Error(`Invalid ${location} \\`${safePropName}\\` supplied to \\`${componentName}\\`. ` + `Expected an element that can hold a ref. ${warningHint} ` + 'For more information see https://mui.com/r/caveat-with-refs-guide');\n  }\n  return null;\n}\nconst elementAcceptingRef = chainPropTypes(PropTypes.element, acceptingRef);\nelementAcceptingRef.isRequired = chainPropTypes(PropTypes.element.isRequired, acceptingRef);\nexport default elementAcceptingRef;","import _extends from \"@babel/runtime/helpers/esm/extends\";\n// This module is based on https://github.com/airbnb/prop-types-exact repository.\n// However, in order to reduce the number of dependencies and to remove some extra safe checks\n// the module was forked.\n\nconst specialProperty = 'exact-prop: \\u200b';\nexport default function exactProp(propTypes) {\n  if (process.env.NODE_ENV === 'production') {\n    return propTypes;\n  }\n  return _extends({}, propTypes, {\n    [specialProperty]: props => {\n      const unsupportedProps = Object.keys(props).filter(prop => !propTypes.hasOwnProperty(prop));\n      if (unsupportedProps.length > 0) {\n        return new Error(`The following props are not supported: ${unsupportedProps.map(prop => `\\`${prop}\\``).join(', ')}. Please remove them.`);\n      }\n      return null;\n    }\n  });\n}","import PropTypes from 'prop-types';\nexport var timeoutsShape = process.env.NODE_ENV !== 'production' ? PropTypes.oneOfType([PropTypes.number, PropTypes.shape({\n  enter: PropTypes.number,\n  exit: PropTypes.number,\n  appear: PropTypes.number\n}).isRequired]) : null;\nexport var classNamesShape = process.env.NODE_ENV !== 'production' ? PropTypes.oneOfType([PropTypes.string, PropTypes.shape({\n  enter: PropTypes.string,\n  exit: PropTypes.string,\n  active: PropTypes.string\n}), PropTypes.shape({\n  enter: PropTypes.string,\n  enterDone: PropTypes.string,\n  enterActive: PropTypes.string,\n  exit: PropTypes.string,\n  exitDone: PropTypes.string,\n  exitActive: PropTypes.string\n})]) : null;","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;","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};"],"names":["Portal","props","forwardedRef","children","container","disablePortal","mountNode","setMountNode","handleRef","ref","getContainer","document","body","newProps","propTypes","appendOwnerState","elementType","otherProps","ownerState","undefined","extractEventHandlers","object","excludeKeys","result","Object","keys","filter","prop","match","includes","forEach","isHostComponent","element","omitEventHandlers","mergeSlotProps","parameters","getSlotProps","additionalProps","externalSlotProps","externalForwardedProps","className","joinedClasses","clsx","mergedStyle","style","length","internalRef","eventHandlers","componentsPropsWithoutEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","resolveComponentProps","componentProps","slotState","_excluded","useSlotProps","_parameters$additiona","skipResolvingSlotProps","rest","resolvedComponentsProps","mergedProps","useTheme","theme","reflow","node","scrollTop","getTransitionProps","options","_style$transitionDura","_style$transitionTimi","timeout","easing","duration","transitionDuration","mode","transitionTimingFunction","delay","transitionDelay","HTMLElementType","propName","componentName","location","propFullName","propValue","safePropName","nodeType","Error","acceptingRef","window","warningHint","type","prototype","Boolean","isReactComponent","isClassComponent","elementAcceptingRef","isRequired","specialProperty","exactProp","unsupportedProps","hasOwnProperty","map","join","timeoutsShape","enter","exit","appear","active","enterDone","enterActive","exitDone","exitActive","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","Transition","_React$Component","context","_this","call","this","initialStatus","isMounting","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","getDerivedStateFromProps","_ref","prevState","_proto","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","mounting","nodeRef","current","forceReflow","performEnter","performExit","setState","_this2","appearing","_ref2","maybeNode","maybeAppearing","timeouts","enterTimeout","onEnter","safeSetState","onEntering","onTransitionEnd","onEntered","_this3","onExit","onExiting","onExited","cancel","nextState","callback","setNextCallback","_this4","event","handler","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","setTimeout","render","_this$props","childProps","TransitionGroupContext","Provider","value","only","noop","contextType","Element","key","secret","ownerDocument","defaultView","pt","_len","arguments","args","Array","_key","apply","concat","defaultProps"],"sourceRoot":""}