{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack:///./node_modules/dom-helpers/class/addClass.js","webpack:///./node_modules/dom-helpers/node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack:///./node_modules/dom-helpers/class/hasClass.js","webpack:///./node_modules/dom-helpers/class/removeClass.js","webpack:///./node_modules/lodash-es/throttle.js","webpack:///./node_modules/react-transition-group/esm/config.js","webpack:///./node_modules/react-transition-group/esm/TransitionGroupContext.js","webpack:///./node_modules/react-transition-group/esm/Transition.js","webpack:///./node_modules/react-transition-group/esm/CSSTransition.js","webpack:///./node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js"],"names":["_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","__proto__","__webpack_require__","d","__webpack_exports__","_interopRequireDefault","exports","__esModule","default","element","className","classList","add","_hasClass","setAttribute","baseVal","module","obj","contains","indexOf","replaceClassName","origClass","classToRemove","replace","RegExp","remove","_debounce_js__WEBPACK_IMPORTED_MODULE_0__","_isObject_js__WEBPACK_IMPORTED_MODULE_1__","FUNC_ERROR_TEXT","throttle","func","wait","options","leading","trailing","TypeError","isObject","debounce","maxWait","config","TransitionGroupContext","react_default","a","createContext","UNMOUNTED","EXITED","ENTERING","ENTERED","Transition_Transition","_React$Component","Transition","props","context","_this","call","this","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","inheritsLoose","getDerivedStateFromProps","_ref","prevState","_proto","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","timeout","undefined","mounting","node","react_dom_default","findDOMNode","performEnter","performExit","setState","_this2","appearing","timeouts","enterTimeout","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","_this3","onExit","onExiting","onExited","cancel","nextState","callback","setNextCallback","_this4","active","event","handler","doesNotHaveTimeoutOrListener","addEndListener","setTimeout","render","_this$props","children","childProps","objectWithoutPropertiesLoose","createElement","Provider","value","child","Children","only","cloneElement","Component","noop","contextType","propTypes","defaultProps","EXITING","esm_Transition","CSSTransition_removeClass","classes","split","forEach","c","removeClass_default","CSSTransition_CSSTransition","CSSTransition","_len","arguments","length","args","Array","_key","apply","concat","appliedClasses","removeClasses","addClass","type","getClassNames","classNames","isStringClassNames","baseClassName","activeClassName","doneClassName","phase","scrollTop","addClass_default","_addClass","_this$appliedClasses$","base","done","esm_extends","_extends","assign","target","i","source","key","hasOwnProperty","_objectWithoutPropertiesLoose","excluded","sourceKeys","keys"],"mappings":"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","file":"vendors~search-af1f8f8ae7b49f95d12a.js","sourcesContent":["export default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = addClass;\n\nvar _hasClass = _interopRequireDefault(require(\"./hasClass\"));\n\nfunction addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + ' ' + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + ' ' + className);\n}\n\nmodule.exports = exports[\"default\"];","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = hasClass;\n\nfunction hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);else return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}\n\nmodule.exports = exports[\"default\"];","'use strict';\n\nfunction replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp('(^|\\\\s)' + classToRemove + '(?:\\\\s|$)', 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n\nmodule.exports = function removeClass(element, className) {\n  if (element.classList) element.classList.remove(className);else if (typeof element.className === 'string') element.className = replaceClassName(element.className, className);else element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n};","import debounce from './debounce.js';\nimport isObject from './isObject.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nexport default throttle;\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 * as 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 `<Transition>` component mounts.\n   * If you want to transition on the first mount set `appear` to `true`, and the\n   * component will transition in as soon as the `<Transition>` mounts.\n   *\n   * > Note: there are no specific \"appear\" states. `appear` only adds an additional `enter` transition.\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;","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 * as PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/class/addClass';\nimport removeOneClass from 'dom-helpers/class/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\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 enters, exits or\n   * has finished the transition. A single name can be provided and it will be\n   * suffixed for each stage: e.g.\n   *\n   * `classNames=\"fade\"` applies `fade-enter`, `fade-enter-active`,\n   * `fade-enter-done`, `fade-exit`, `fade-exit-active`, `fade-exit-done`,\n   * `fade-appear`, `fade-appear-active`, and `fade-appear-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;","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}"],"sourceRoot":""}