{"version":3,"sources":["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","webpack:///./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js"],"names":["_interopRequireDefault","__webpack_require__","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","Object","inheritsLoose","getDerivedStateFromProps","_ref","prevState","_proto","prototype","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","__webpack_exports__","_extends","assign","target","i","source","key","hasOwnProperty","d","_objectWithoutPropertiesLoose","excluded","sourceKeys","keys","_inheritsLoose","subClass","superClass","create","constructor","__proto__"],"mappings":"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","file":"vendors~search-cc79aa91aa7e92744273.js","sourcesContent":["\"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}","export default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}"],"sourceRoot":""}