{"version":3,"file":"static/chunks/8665.c0a8008c88b3ceb8.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://_N_E/./node_modules/dom-helpers/esm/removeClass.js","webpack://_N_E/./node_modules/react-transition-group/esm/CSSTransition.js","webpack://_N_E/./node_modules/dom-helpers/esm/addClass.js","webpack://_N_E/./node_modules/dom-helpers/esm/hasClass.js","webpack://_N_E/./node_modules/react-transition-group/esm/config.js","webpack://_N_E/./node_modules/react-transition-group/esm/TransitionGroupContext.js","webpack://_N_E/./node_modules/react-transition-group/esm/Transition.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack://_N_E/<anon>"],"sourcesContent":["export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/addClass';\nimport removeOneClass from 'dom-helpers/removeClass';\nimport React from 'react';\nimport Transition from './Transition';\nimport { classNamesShape } from './utils/PropTypes';\n\nvar _addClass = function addClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return addOneClass(node, c);\n  });\n};\n\nvar removeClass = function removeClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return removeOneClass(node, c);\n  });\n};\n/**\n * A transition component inspired by the excellent\n * [ng-animate](http://www.nganimate.org/) library, you should use it if you're\n * using CSS transitions or animations. It's built upon the\n * [`Transition`](https://reactcommunity.org/react-transition-group/transition)\n * component, so it inherits all of its props.\n *\n * `CSSTransition` applies a pair of class names during the `appear`, `enter`,\n * and `exit` states of the transition. The first class is applied and then a\n * second `*-active` class in order to activate the CSS transition. After the\n * transition, matching `*-done` class names are applied to persist the\n * transition state.\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <CSSTransition in={inProp} timeout={200} classNames=\"my-node\">\n *         <div>\n *           {\"I'll receive my-node-* classes\"}\n *         </div>\n *       </CSSTransition>\n *       <button type=\"button\" onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the `in` prop is set to `true`, the child component will first receive\n * the class `example-enter`, then the `example-enter-active` will be added in\n * the next tick. `CSSTransition` [forces a\n * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * between before adding the `example-enter-active`. This is an important trick\n * because it allows us to transition between `example-enter` and\n * `example-enter-active` even though they were added immediately one after\n * another. Most notably, this is what makes it possible for us to animate\n * _appearance_.\n *\n * ```css\n * .my-node-enter {\n *   opacity: 0;\n * }\n * .my-node-enter-active {\n *   opacity: 1;\n *   transition: opacity 200ms;\n * }\n * .my-node-exit {\n *   opacity: 1;\n * }\n * .my-node-exit-active {\n *   opacity: 0;\n *   transition: opacity 200ms;\n * }\n * ```\n *\n * `*-active` classes represent which styles you want to animate **to**.\n *\n * **Note**: If you're using the\n * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear)\n * prop, make sure to define styles for `.appear-*` classes as well.\n */\n\n\nvar CSSTransition =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(CSSTransition, _React$Component);\n\n  function CSSTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.appliedClasses = {\n      appear: {},\n      enter: {},\n      exit: {}\n    };\n\n    _this.onEnter = function (node, appearing) {\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');\n\n      if (_this.props.onEnter) {\n        _this.props.onEnter(node, appearing);\n      }\n    };\n\n    _this.onEntering = function (node, appearing) {\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.addClass(node, type, 'active');\n\n      if (_this.props.onEntering) {\n        _this.props.onEntering(node, appearing);\n      }\n    };\n\n    _this.onEntered = function (node, appearing) {\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.removeClasses(node, type);\n\n      _this.addClass(node, type, 'done');\n\n      if (_this.props.onEntered) {\n        _this.props.onEntered(node, appearing);\n      }\n    };\n\n    _this.onExit = function (node) {\n      _this.removeClasses(node, 'appear');\n\n      _this.removeClasses(node, 'enter');\n\n      _this.addClass(node, 'exit', 'base');\n\n      if (_this.props.onExit) {\n        _this.props.onExit(node);\n      }\n    };\n\n    _this.onExiting = function (node) {\n      _this.addClass(node, 'exit', 'active');\n\n      if (_this.props.onExiting) {\n        _this.props.onExiting(node);\n      }\n    };\n\n    _this.onExited = function (node) {\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, 'exit', 'done');\n\n      if (_this.props.onExited) {\n        _this.props.onExited(node);\n      }\n    };\n\n    _this.getClassNames = function (type) {\n      var classNames = _this.props.classNames;\n      var isStringClassNames = typeof classNames === 'string';\n      var prefix = isStringClassNames && classNames ? classNames + \"-\" : '';\n      var baseClassName = isStringClassNames ? \"\" + prefix + type : classNames[type];\n      var activeClassName = isStringClassNames ? baseClassName + \"-active\" : classNames[type + \"Active\"];\n      var doneClassName = isStringClassNames ? baseClassName + \"-done\" : classNames[type + \"Done\"];\n      return {\n        baseClassName: baseClassName,\n        activeClassName: activeClassName,\n        doneClassName: doneClassName\n      };\n    };\n\n    return _this;\n  }\n\n  var _proto = CSSTransition.prototype;\n\n  _proto.addClass = function addClass(node, type, phase) {\n    var className = this.getClassNames(type)[phase + \"ClassName\"];\n\n    if (type === 'appear' && phase === 'done') {\n      className += \" \" + this.getClassNames('enter').doneClassName;\n    } // This is for to force a repaint,\n    // which is necessary in order to transition styles when adding a class name.\n\n\n    if (phase === 'active') {\n      /* eslint-disable no-unused-expressions */\n      node && node.scrollTop;\n    }\n\n    this.appliedClasses[type][phase] = className;\n\n    _addClass(node, className);\n  };\n\n  _proto.removeClasses = function removeClasses(node, type) {\n    var _this$appliedClasses$ = this.appliedClasses[type],\n        baseClassName = _this$appliedClasses$.base,\n        activeClassName = _this$appliedClasses$.active,\n        doneClassName = _this$appliedClasses$.done;\n    this.appliedClasses[type] = {};\n\n    if (baseClassName) {\n      removeClass(node, baseClassName);\n    }\n\n    if (activeClassName) {\n      removeClass(node, activeClassName);\n    }\n\n    if (doneClassName) {\n      removeClass(node, doneClassName);\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        _ = _this$props.classNames,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"classNames\"]);\n\n    return React.createElement(Transition, _extends({}, props, {\n      onEnter: this.onEnter,\n      onEntered: this.onEntered,\n      onEntering: this.onEntering,\n      onExit: this.onExit,\n      onExiting: this.onExiting,\n      onExited: this.onExited\n    }));\n  };\n\n  return CSSTransition;\n}(React.Component);\n\nCSSTransition.defaultProps = {\n  classNames: ''\n};\nCSSTransition.propTypes = process.env.NODE_ENV !== \"production\" ? _extends({}, Transition.propTypes, {\n  /**\n   * The animation classNames applied to the component as it appears, enters,\n   * exits or has finished the transition. A single name can be provided and it\n   * will be suffixed for each stage: e.g.\n   *\n   * `classNames=\"fade\"` applies `fade-appear`, `fade-appear-active`,\n   * `fade-appear-done`, `fade-enter`, `fade-enter-active`, `fade-enter-done`,\n   * `fade-exit`, `fade-exit-active`, and `fade-exit-done`.\n   *\n   * **Note**: `fade-appear-done` and `fade-enter-done` will _both_ be applied.\n   * This allows you to define different behavior for when appearing is done and\n   * when regular entering is done, using selectors like\n   * `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply an\n   * epic entrance animation when element first appears in the DOM using\n   * [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can\n   * simply use `fade-enter-done` for defining both cases.\n   *\n   * Each individual classNames can also be specified independently like:\n   *\n   * ```js\n   * classNames={{\n   *  appear: 'my-appear',\n   *  appearActive: 'my-active-appear',\n   *  appearDone: 'my-done-appear',\n   *  enter: 'my-enter',\n   *  enterActive: 'my-active-enter',\n   *  enterDone: 'my-done-enter',\n   *  exit: 'my-exit',\n   *  exitActive: 'my-active-exit',\n   *  exitDone: 'my-done-exit',\n   * }}\n   * ```\n   *\n   * If you want to set these classes using CSS Modules:\n   *\n   * ```js\n   * import styles from './styles.css';\n   * ```\n   *\n   * you might want to use camelCase in your CSS file, that way could simply\n   * spread them instead of listing them one by one:\n   *\n   * ```js\n   * classNames={{ ...styles }}\n   * ```\n   *\n   * @type {string | {\n   *  appear?: string,\n   *  appearActive?: string,\n   *  appearDone?: string,\n   *  enter?: string,\n   *  enterActive?: string,\n   *  enterDone?: string,\n   *  exit?: string,\n   *  exitActive?: string,\n   *  exitDone?: string,\n   * }}\n   */\n  classNames: classNamesShape,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is\n   * applied.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter-active' or\n   * 'appear-active' class is applied.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or\n   * 'appear' classes are **removed** and the `done` class is added to the DOM node.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' class is\n   * applied.\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' classes\n   * are **removed** and the `exit-done` class is added to the DOM node.\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExited: PropTypes.func\n}) : {};\nexport default CSSTransition;","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","export default {\n  disabled: false\n};","import React from 'react';\nexport default React.createContext(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';\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 =\n/*#__PURE__*/\nfunction (_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      var node = ReactDOM.findDOMNode(this);\n\n      if (nextStatus === ENTERING) {\n        this.performEnter(node, mounting);\n      } else {\n        this.performExit(node);\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(node, mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\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(node);\n      });\n      return;\n    }\n\n    this.props.onEnter(node, appearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(node, appearing);\n\n      _this2.onTransitionEnd(node, enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(node, appearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit(node) {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts(); // 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(node);\n      });\n      return;\n    }\n\n    this.props.onExit(node);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(node);\n\n      _this3.onTransitionEnd(node, timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(node);\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(node, timeout, handler) {\n    this.setNextCallback(handler);\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      this.props.addEndListener(node, this.nextCallback);\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        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\"]); // filter props for Transtition\n\n\n    delete childProps.in;\n    delete childProps.mountOnEnter;\n    delete childProps.unmountOnExit;\n    delete childProps.appear;\n    delete childProps.enter;\n    delete childProps.exit;\n    delete childProps.timeout;\n    delete childProps.addEndListener;\n    delete childProps.onEnter;\n    delete childProps.onEntering;\n    delete childProps.onEntered;\n    delete childProps.onExit;\n    delete childProps.onExiting;\n    delete childProps.onExited;\n\n    if (typeof children === 'function') {\n      // allows for nested Transitions\n      return React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, children(status, childProps));\n    }\n\n    var child = React.Children.only(children);\n    return (// allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, React.cloneElement(child, childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\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   * Normally a component is not transitioned if it is shown when the\n   * `<Transition>` component mounts. If you want to transition on the first\n   * mount set `appear` to `true`, and the component will transition in as soon\n   * as the `<Transition>` mounts.\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. **Note:** Timeouts are still used as a fallback if provided.\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   * @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   * @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   * @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   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\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   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func // Name the function so it is clearer in the documentation\n\n} : {};\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 = 0;\nTransition.EXITED = 1;\nTransition.ENTERING = 2;\nTransition.ENTERED = 3;\nTransition.EXITING = 4;\nexport default Transition;","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  for (var key in source) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      if (excluded.indexOf(key) >= 0) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}","\"use strict\";(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[8665],{68665:function(t,e,n){function s(){return(s=Object.assign?Object.assign.bind():function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var s in n)Object.prototype.hasOwnProperty.call(n,s)&&(t[s]=n[s])}return t}).apply(this,arguments)}n.d(e,{Z:function(){return c}});var a=n(63366),i=n(75068);n(45697);function r(t,e){return t.replace(new RegExp(\"(^|\\\\s)\"+e+\"(?:\\\\s|$)\",\"g\"),\"$1\").replace(/\\s+/g,\" \").replace(/^\\s*|\\s*$/g,\"\")}var o=n(67294),l=n(39325),u=function(t,e){return t&&e&&e.split(\" \").forEach((function(e){return s=e,void((n=t).classList?n.classList.remove(s):\"string\"==typeof n.className?n.className=r(n.className,s):n.setAttribute(\"class\",r(n.className&&n.className.baseVal||\"\",s)));var n,s}))},p=function(t){function e(){for(var e,n=arguments.length,s=new Array(n),a=0;a<n;a++)s[a]=arguments[a];return(e=t.call.apply(t,[this].concat(s))||this).appliedClasses={appear:{},enter:{},exit:{}},e.onEnter=function(t,n){e.removeClasses(t,\"exit\"),e.addClass(t,n?\"appear\":\"enter\",\"base\"),e.props.onEnter&&e.props.onEnter(t,n)},e.onEntering=function(t,n){var s=n?\"appear\":\"enter\";e.addClass(t,s,\"active\"),e.props.onEntering&&e.props.onEntering(t,n)},e.onEntered=function(t,n){var s=n?\"appear\":\"enter\";e.removeClasses(t,s),e.addClass(t,s,\"done\"),e.props.onEntered&&e.props.onEntered(t,n)},e.onExit=function(t){e.removeClasses(t,\"appear\"),e.removeClasses(t,\"enter\"),e.addClass(t,\"exit\",\"base\"),e.props.onExit&&e.props.onExit(t)},e.onExiting=function(t){e.addClass(t,\"exit\",\"active\"),e.props.onExiting&&e.props.onExiting(t)},e.onExited=function(t){e.removeClasses(t,\"exit\"),e.addClass(t,\"exit\",\"done\"),e.props.onExited&&e.props.onExited(t)},e.getClassNames=function(t){var n=e.props.classNames,s=\"string\"==typeof n,a=s?\"\"+(s&&n?n+\"-\":\"\")+t:n[t];return{baseClassName:a,activeClassName:s?a+\"-active\":n[t+\"Active\"],doneClassName:s?a+\"-done\":n[t+\"Done\"]}},e}(0,i.Z)(e,t);var n=e.prototype;return n.addClass=function(t,e,n){var s=this.getClassNames(e)[n+\"ClassName\"];\"appear\"===e&&\"done\"===n&&(s+=\" \"+this.getClassNames(\"enter\").doneClassName),\"active\"===n&&t&&t.scrollTop,this.appliedClasses[e][n]=s,function(t,e){t&&e&&e.split(\" \").forEach((function(e){return s=e,void((n=t).classList?n.classList.add(s):function(t,e){return t.classList?!!e&&t.classList.contains(e):-1!==(\" \"+(t.className.baseVal||t.className)+\" \").indexOf(\" \"+e+\" \")}(n,s)||(\"string\"==typeof n.className?n.className=n.className+\" \"+s:n.setAttribute(\"class\",(n.className&&n.className.baseVal||\"\")+\" \"+s)));var n,s}))}(t,s)},n.removeClasses=function(t,e){var n=this.appliedClasses[e],s=n.base,a=n.active,i=n.done;this.appliedClasses[e]={},s&&u(t,s),a&&u(t,a),i&&u(t,i)},n.render=function(){var t=this.props,e=(t.classNames,(0,a.Z)(t,[\"classNames\"]));return o.createElement(l.ZP,s({},e,{onEnter:this.onEnter,onEntered:this.onEntered,onEntering:this.onEntering,onExit:this.onExit,onExiting:this.onExiting,onExited:this.onExited}))},e}(o.Component);p.defaultProps={classNames:\"\"},p.propTypes={};var c=p},39325:function(t,e,n){n.d(e,{ZP:function(){return c}});var s=n(63366),a=n(75068),i=(n(45697),n(67294)),r=n(73935),o=!1,l=i.createContext(null),u=function(t){function e(e,n){var s;s=t.call(this,e,n)||this;var a,i=n&&!n.isMounting?e.enter:e.appear;return s.appearStatus=null,e.in?i?(a=\"exited\",s.appearStatus=\"entering\"):a=\"entered\":a=e.unmountOnExit||e.mountOnEnter?\"unmounted\":\"exited\",s.state={status:a},s.nextCallback=null,s}(0,a.Z)(e,t),e.getDerivedStateFromProps=function(t,e){return t.in&&\"unmounted\"===e.status?{status:\"exited\"}:null};var n=e.prototype;return n.componentDidMount=function(){this.updateStatus(!0,this.appearStatus)},n.componentDidUpdate=function(t){var e=null;if(t!==this.props){var n=this.state.status;this.props.in?\"entering\"!==n&&\"entered\"!==n&&(e=\"entering\"):\"entering\"!==n&&\"entered\"!==n||(e=\"exiting\")}this.updateStatus(!1,e)},n.componentWillUnmount=function(){this.cancelNextCallback()},n.getTimeouts=function(){var t,e,n,s=this.props.timeout;return t=e=n=s,null!=s&&\"number\"!=typeof s&&(t=s.exit,e=s.enter,n=void 0!==s.appear?s.appear:e),{exit:t,enter:e,appear:n}},n.updateStatus=function(t,e){if(void 0===t&&(t=!1),null!==e){this.cancelNextCallback();var n=r.findDOMNode(this);\"entering\"===e?this.performEnter(n,t):this.performExit(n)}else this.props.unmountOnExit&&\"exited\"===this.state.status&&this.setState({status:\"unmounted\"})},n.performEnter=function(t,e){var n=this,s=this.props.enter,a=this.context?this.context.isMounting:e,i=this.getTimeouts(),r=a?i.appear:i.enter;!e&&!s||o?this.safeSetState({status:\"entered\"},(function(){n.props.onEntered(t)})):(this.props.onEnter(t,a),this.safeSetState({status:\"entering\"},(function(){n.props.onEntering(t,a),n.onTransitionEnd(t,r,(function(){n.safeSetState({status:\"entered\"},(function(){n.props.onEntered(t,a)}))}))})))},n.performExit=function(t){var e=this,n=this.props.exit,s=this.getTimeouts();n&&!o?(this.props.onExit(t),this.safeSetState({status:\"exiting\"},(function(){e.props.onExiting(t),e.onTransitionEnd(t,s.exit,(function(){e.safeSetState({status:\"exited\"},(function(){e.props.onExited(t)}))}))}))):this.safeSetState({status:\"exited\"},(function(){e.props.onExited(t)}))},n.cancelNextCallback=function(){null!==this.nextCallback&&(this.nextCallback.cancel(),this.nextCallback=null)},n.safeSetState=function(t,e){e=this.setNextCallback(e),this.setState(t,e)},n.setNextCallback=function(t){var e=this,n=!0;return this.nextCallback=function(s){n&&(n=!1,e.nextCallback=null,t(s))},this.nextCallback.cancel=function(){n=!1},this.nextCallback},n.onTransitionEnd=function(t,e,n){this.setNextCallback(n);var s=null==e&&!this.props.addEndListener;t&&!s?(this.props.addEndListener&&this.props.addEndListener(t,this.nextCallback),null!=e&&setTimeout(this.nextCallback,e)):setTimeout(this.nextCallback,0)},n.render=function(){var t=this.state.status;if(\"unmounted\"===t)return null;var e=this.props,n=e.children,a=(0,s.Z)(e,[\"children\"]);if(delete a.in,delete a.mountOnEnter,delete a.unmountOnExit,delete a.appear,delete a.enter,delete a.exit,delete a.timeout,delete a.addEndListener,delete a.onEnter,delete a.onEntering,delete a.onEntered,delete a.onExit,delete a.onExiting,delete a.onExited,\"function\"==typeof n)return i.createElement(l.Provider,{value:null},n(t,a));var r=i.Children.only(n);return i.createElement(l.Provider,{value:null},i.cloneElement(r,a))},e}(i.Component);function p(){}u.contextType=l,u.propTypes={},u.defaultProps={in:!1,mountOnEnter:!1,unmountOnExit:!1,appear:!1,enter:!0,exit:!0,onEnter:p,onEntering:p,onEntered:p,onExit:p,onExiting:p,onExited:p},u.UNMOUNTED=0,u.EXITED=1,u.ENTERING=2,u.ENTERED=3,u.EXITING=4;var c=u},75068:function(t,e,n){function s(t,e){return(s=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t})(t,e)}function a(t,e){t.prototype=Object.create(e.prototype),t.prototype.constructor=t,s(t,e)}n.d(e,{Z:function(){return a}})},63366:function(t,e,n){function s(t,e){if(null==t)return{};var n={};for(var s in t)if(Object.prototype.hasOwnProperty.call(t,s)){if(e.indexOf(s)>=0)continue;n[s]=t[s]}return n}n.d(e,{Z:function(){return s}})}}]);"],"names":["self","webpackChunk_N_E","push","t","e","n","s","Object","assign","bind","arguments","length","prototype","hasOwnProperty","call","apply","d","Z","c","a","i","r","replace","o","l","u","split","forEach","classList","remove","className","setAttribute","baseVal","p","concat","appliedClasses","appear","enter","exit","onEnter","removeClasses","addClass","props","onEntering","onEntered","onExit","onExiting","onExited","getClassNames","classNames","baseClassName","activeClassName","doneClassName","scrollTop","add","contains","indexOf","base","active","done","render","createElement","ZP","Component","defaultProps","propTypes","createContext","isMounting","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","getDerivedStateFromProps","componentDidMount","updateStatus","componentDidUpdate","componentWillUnmount","cancelNextCallback","getTimeouts","timeout","findDOMNode","performEnter","performExit","setState","context","safeSetState","onTransitionEnd","cancel","setNextCallback","addEndListener","setTimeout","children","Provider","value","Children","only","cloneElement","contextType","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","setPrototypeOf","__proto__","create","constructor"],"sourceRoot":""}