{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack:///./node_modules/dom-helpers/esm/removeClass.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/dom-helpers/esm/addClass.js","webpack:///./node_modules/dom-helpers/esm/hasClass.js","webpack:///./node_modules/classnames/index.js","webpack:///./node_modules/react-animate-height/lib/AnimateHeight.js"],"names":["_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","__proto__","replaceClassName","origClass","classToRemove","replace","RegExp","createContext","_React$Component","Transition","props","context","_this","call","this","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","getDerivedStateFromProps","_ref","prevState","_proto","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","timeout","undefined","mounting","performEnter","performExit","setState","_this2","appearing","_ref2","nodeRef","findDOMNode","maybeNode","maybeAppearing","timeouts","enterTimeout","config","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","_this3","onExit","onExiting","onExited","cancel","nextState","callback","setNextCallback","_this4","active","event","handler","node","current","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","setTimeout","render","_this$props","children","childProps","createElement","TransitionGroupContext","Provider","value","cloneElement","Children","only","Component","noop","contextType","propTypes","defaultProps","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","classes","split","forEach","c","className","element","classList","remove","setAttribute","baseVal","CSSTransition","_len","arguments","length","args","Array","_key","apply","concat","appliedClasses","_this$resolveArgument","resolveArguments","removeClasses","addClass","_this$resolveArgument2","type","_this$resolveArgument3","getClassNames","classNames","isStringClassNames","baseClassName","activeClassName","doneClassName","phase","scrollTop","add","contains","indexOf","hasClass","_addClass","_this$appliedClasses$","base","done","hasOwn","hasOwnProperty","i","arg","argType","push","isArray","inner","key","join","module","exports","default","defineProperty","_typeof","Symbol","iterator","obj","_extends","assign","target","source","_createClass","defineProperties","descriptor","enumerable","configurable","writable","Constructor","protoProps","staticProps","_react2","_interopRequireDefault","_propTypes2","_classnames2","__esModule","_defineProperty","ANIMATION_STATE_CLASSES","animating","animatingUp","animatingDown","animatingToHeightZero","animatingToHeightAuto","animatingToHeightSpecific","static","staticHeightZero","staticHeightAuto","staticHeightSpecific","PROPS_TO_OMIT","omit","keys","res","objectKeys","cancelAnimationFrames","requestAnimationFrameIDs","id","cancelAnimationFrame","isNumber","n","isNaN","parseFloat","isFinite","isPercentage","height","search","substr","runCallback","params","AnimateHeight","instance","TypeError","_classCallCheck","self","ReferenceError","_possibleConstructorReturn","getPrototypeOf","animationFrameIDs","overflow","animationStateClasses","getStaticStateClasses","shouldUseTransitions","setPrototypeOf","_inherits","contentElement","style","hideContent","_props","delay","duration","onAnimationEnd","onAnimationStart","_cx","showContent","contentHeight","offsetHeight","totalDuration","newHeight","timeoutState","isCurrentHeightAuto","timeoutAnimationStateClasses","clearTimeout","timeoutID","animationClassesTimeoutID","requestAnimationFrame","display","_cx2","_cx3","_props2","animateOpacity","applyInlineTransitions","contentClassName","easing","_state","componentStyle","transition","WebkitTransition","contentStyle","opacity","componentClasses","ariaHidden","ref","el","bool","object","any","isRequired","string","number","propName","componentName","func"],"mappings":"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","file":"37.fe463e5760d5366027b0.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}","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\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    ;\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\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 = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : PropTypes.instanceOf(Element)\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import _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](https://docs.angularjs.org/api/ngAnimate) library, you should\n * use it if you're 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**, so it's\n * important to add `transition` declaration only to them, otherwise transitions\n * might not behave as intended! This might not be obvious when the transitions\n * are symmetrical, i.e. when `*-enter-active` is the same as `*-exit`, like in\n * the example above (minus `transition`), but it becomes apparent in more\n * complex transitions.\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 = /*#__PURE__*/function (_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 (maybeNode, maybeAppearing) {\n      var _this$resolveArgument = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument[0],\n          appearing = _this$resolveArgument[1];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');\n\n      if (_this.props.onEnter) {\n        _this.props.onEnter(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntering = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument2 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument2[0],\n          appearing = _this$resolveArgument2[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.addClass(node, type, 'active');\n\n      if (_this.props.onEntering) {\n        _this.props.onEntering(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntered = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument3 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument3[0],\n          appearing = _this$resolveArgument3[1];\n\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(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onExit = function (maybeNode) {\n      var _this$resolveArgument4 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument4[0];\n\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(maybeNode);\n      }\n    };\n\n    _this.onExiting = function (maybeNode) {\n      var _this$resolveArgument5 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument5[0];\n\n      _this.addClass(node, 'exit', 'active');\n\n      if (_this.props.onExiting) {\n        _this.props.onExiting(maybeNode);\n      }\n    };\n\n    _this.onExited = function (maybeNode) {\n      var _this$resolveArgument6 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument6[0];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, 'exit', 'done');\n\n      if (_this.props.onExited) {\n        _this.props.onExited(maybeNode);\n      }\n    };\n\n    _this.resolveArguments = function (maybeNode, maybeAppearing) {\n      return _this.props.nodeRef ? [_this.props.nodeRef.current, maybeNode] // here `maybeNode` is actually `appearing`\n      : [maybeNode, maybeAppearing];\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    var _this$getClassNames = this.getClassNames('enter'),\n        doneClassName = _this$getClassNames.doneClassName;\n\n    if (type === 'appear' && phase === 'done' && doneClassName) {\n      className += \" \" + 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    if (className) {\n      this.appliedClasses[type][phase] = className;\n\n      _addClass(node, className);\n    }\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 /*#__PURE__*/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, which\n   * will be suffixed for each stage, e.g. `classNames=\"fade\"` applies:\n   *\n   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`\n   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`\n   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`\n   *\n   * A few details to note about how these classes are applied:\n   *\n   * 1. They are _joined_ with the ones that are already defined on the child\n   *    component, so if you want to add some base styles, you can use\n   *    `className` without worrying that it will be overridden.\n   *\n   * 2. If the transition component mounts with `in={false}`, no classes are\n   *    applied yet. You might be expecting `*-exit-done`, but if you think\n   *    about it, a component cannot finish exiting if it hasn't entered yet.\n   *\n   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This\n   *    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\n   *    an 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   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\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   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * 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   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\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   * **Note**: when `nodeRef` prop is passed, `node` is not passed\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   * **Note**: when `nodeRef` prop is passed, `node` is not passed\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   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExited: PropTypes.func\n}) : {};\nexport default CSSTransition;","import hasClass from './hasClass';\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}","export 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}","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg) && arg.length) {\n\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\tif (inner) {\n\t\t\t\t\tclasses.push(inner);\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar ANIMATION_STATE_CLASSES = {\n  animating: 'rah-animating',\n  animatingUp: 'rah-animating--up',\n  animatingDown: 'rah-animating--down',\n  animatingToHeightZero: 'rah-animating--to-height-zero',\n  animatingToHeightAuto: 'rah-animating--to-height-auto',\n  animatingToHeightSpecific: 'rah-animating--to-height-specific',\n  static: 'rah-static',\n  staticHeightZero: 'rah-static--height-zero',\n  staticHeightAuto: 'rah-static--height-auto',\n  staticHeightSpecific: 'rah-static--height-specific'\n};\n\nvar PROPS_TO_OMIT = ['animateOpacity', 'animationStateClasses', 'applyInlineTransitions', 'children', 'contentClassName', 'delay', 'duration', 'easing', 'height', 'onAnimationEnd', 'onAnimationStart'];\n\nfunction omit(obj) {\n  for (var _len = arguments.length, keys = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    keys[_key - 1] = arguments[_key];\n  }\n\n  if (!keys.length) {\n    return obj;\n  }\n\n  var res = {};\n  var objectKeys = Object.keys(obj);\n\n  for (var i = 0; i < objectKeys.length; i++) {\n    var key = objectKeys[i];\n\n    if (keys.indexOf(key) === -1) {\n      res[key] = obj[key];\n    }\n  }\n\n  return res;\n}\n\n// Start animation helper using nested requestAnimationFrames\nfunction startAnimationHelper(callback) {\n  var requestAnimationFrameIDs = [];\n\n  requestAnimationFrameIDs[0] = requestAnimationFrame(function () {\n    requestAnimationFrameIDs[1] = requestAnimationFrame(function () {\n      callback();\n    });\n  });\n\n  return requestAnimationFrameIDs;\n}\n\nfunction cancelAnimationFrames(requestAnimationFrameIDs) {\n  requestAnimationFrameIDs.forEach(function (id) {\n    return cancelAnimationFrame(id);\n  });\n}\n\nfunction isNumber(n) {\n  return !isNaN(parseFloat(n)) && isFinite(n);\n}\n\nfunction isPercentage(height) {\n  // Percentage height\n  return typeof height === 'string' && height.search('%') === height.length - 1 && isNumber(height.substr(0, height.length - 1));\n}\n\nfunction runCallback(callback, params) {\n  if (callback && typeof callback === 'function') {\n    callback(params);\n  }\n}\n\nvar AnimateHeight = function (_React$Component) {\n  _inherits(AnimateHeight, _React$Component);\n\n  function AnimateHeight(props) {\n    _classCallCheck(this, AnimateHeight);\n\n    var _this = _possibleConstructorReturn(this, (AnimateHeight.__proto__ || Object.getPrototypeOf(AnimateHeight)).call(this, props));\n\n    _this.animationFrameIDs = [];\n\n    var height = 'auto';\n    var overflow = 'visible';\n\n    if (isNumber(props.height)) {\n      // If value is string \"0\" make sure we convert it to number 0\n      height = props.height < 0 || props.height === '0' ? 0 : props.height;\n      overflow = 'hidden';\n    } else if (isPercentage(props.height)) {\n      // If value is string \"0%\" make sure we convert it to number 0\n      height = props.height === '0%' ? 0 : props.height;\n      overflow = 'hidden';\n    }\n\n    _this.animationStateClasses = _extends({}, ANIMATION_STATE_CLASSES, props.animationStateClasses);\n\n    var animationStateClasses = _this.getStaticStateClasses(height);\n\n    _this.state = {\n      animationStateClasses: animationStateClasses,\n      height: height,\n      overflow: overflow,\n      shouldUseTransitions: false\n    };\n    return _this;\n  }\n\n  _createClass(AnimateHeight, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var height = this.state.height;\n\n      // Hide content if height is 0 (to prevent tabbing into it)\n      // Check for contentElement is added cause this would fail in tests (react-test-renderer)\n      // Read more here: https://github.com/Stanko/react-animate-height/issues/17\n\n      if (this.contentElement && this.contentElement.style) {\n        this.hideContent(height);\n      }\n    }\n  }, {\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this2 = this;\n\n      var _props = this.props,\n          delay = _props.delay,\n          duration = _props.duration,\n          height = _props.height,\n          onAnimationEnd = _props.onAnimationEnd,\n          onAnimationStart = _props.onAnimationStart;\n\n      // Check if 'height' prop has changed\n\n      if (this.contentElement && height !== prevProps.height) {\n        var _cx;\n\n        // Remove display: none from the content div\n        // if it was hidden to prevent tabbing into it\n        this.showContent(prevState.height);\n\n        // Cache content height\n        this.contentElement.style.overflow = 'hidden';\n        var contentHeight = this.contentElement.offsetHeight;\n        this.contentElement.style.overflow = '';\n\n        // set total animation time\n        var totalDuration = duration + delay;\n\n        var newHeight = null;\n        var timeoutState = {\n          height: null, // it will be always set to either 'auto' or specific number\n          overflow: 'hidden'\n        };\n        var isCurrentHeightAuto = prevState.height === 'auto';\n\n        if (isNumber(height)) {\n          // If value is string \"0\" make sure we convert it to number 0\n          newHeight = height < 0 || height === '0' ? 0 : height;\n          timeoutState.height = newHeight;\n        } else if (isPercentage(height)) {\n          // If value is string \"0%\" make sure we convert it to number 0\n          newHeight = height === '0%' ? 0 : height;\n          timeoutState.height = newHeight;\n        } else {\n          // If not, animate to content height\n          // and then reset to auto\n          newHeight = contentHeight; // TODO solve contentHeight = 0\n          timeoutState.height = 'auto';\n          timeoutState.overflow = null;\n        }\n\n        if (isCurrentHeightAuto) {\n          // This is the height to be animated to\n          timeoutState.height = newHeight;\n\n          // If previous height was 'auto'\n          // set starting height explicitly to be able to use transition\n          newHeight = contentHeight;\n        }\n\n        // Animation classes\n        var animationStateClasses = (0, _classnames2.default)((_cx = {}, _defineProperty(_cx, this.animationStateClasses.animating, true), _defineProperty(_cx, this.animationStateClasses.animatingUp, prevProps.height === 'auto' || height < prevProps.height), _defineProperty(_cx, this.animationStateClasses.animatingDown, height === 'auto' || height > prevProps.height), _defineProperty(_cx, this.animationStateClasses.animatingToHeightZero, timeoutState.height === 0), _defineProperty(_cx, this.animationStateClasses.animatingToHeightAuto, timeoutState.height === 'auto'), _defineProperty(_cx, this.animationStateClasses.animatingToHeightSpecific, timeoutState.height > 0), _cx));\n\n        // Animation classes to be put after animation is complete\n        var timeoutAnimationStateClasses = this.getStaticStateClasses(timeoutState.height);\n\n        // Set starting height and animating classes\n        // We are safe to call set state as it will not trigger infinite loop\n        // because of the \"height !== prevProps.height\" check\n        this.setState({ // eslint-disable-line react/no-did-update-set-state\n          animationStateClasses: animationStateClasses,\n          height: newHeight,\n          overflow: 'hidden',\n          // When animating from 'auto' we first need to set fixed height\n          // that change should be animated\n          shouldUseTransitions: !isCurrentHeightAuto\n        });\n\n        // Clear timeouts\n        clearTimeout(this.timeoutID);\n        clearTimeout(this.animationClassesTimeoutID);\n\n        if (isCurrentHeightAuto) {\n          // When animating from 'auto' we use a short timeout to start animation\n          // after setting fixed height above\n          timeoutState.shouldUseTransitions = true;\n\n          cancelAnimationFrames(this.animationFrameIDs);\n          this.animationFrameIDs = startAnimationHelper(function () {\n            _this2.setState(timeoutState);\n\n            // ANIMATION STARTS, run a callback if it exists\n            runCallback(onAnimationStart, { newHeight: timeoutState.height });\n          });\n\n          // Set static classes and remove transitions when animation ends\n          this.animationClassesTimeoutID = setTimeout(function () {\n            _this2.setState({\n              animationStateClasses: timeoutAnimationStateClasses,\n              shouldUseTransitions: false\n            });\n\n            // ANIMATION ENDS\n            // Hide content if height is 0 (to prevent tabbing into it)\n            _this2.hideContent(timeoutState.height);\n            // Run a callback if it exists\n            runCallback(onAnimationEnd, { newHeight: timeoutState.height });\n          }, totalDuration);\n        } else {\n          // ANIMATION STARTS, run a callback if it exists\n          runCallback(onAnimationStart, { newHeight: newHeight });\n\n          // Set end height, classes and remove transitions when animation is complete\n          this.timeoutID = setTimeout(function () {\n            timeoutState.animationStateClasses = timeoutAnimationStateClasses;\n            timeoutState.shouldUseTransitions = false;\n\n            _this2.setState(timeoutState);\n\n            // ANIMATION ENDS\n            // If height is auto, don't hide the content\n            // (case when element is empty, therefore height is 0)\n            if (height !== 'auto') {\n              // Hide content if height is 0 (to prevent tabbing into it)\n              _this2.hideContent(newHeight); // TODO solve newHeight = 0\n            }\n            // Run a callback if it exists\n            runCallback(onAnimationEnd, { newHeight: newHeight });\n          }, totalDuration);\n        }\n      }\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      cancelAnimationFrames(this.animationFrameIDs);\n\n      clearTimeout(this.timeoutID);\n      clearTimeout(this.animationClassesTimeoutID);\n\n      this.timeoutID = null;\n      this.animationClassesTimeoutID = null;\n      this.animationStateClasses = null;\n    }\n  }, {\n    key: 'showContent',\n    value: function showContent(height) {\n      if (height === 0) {\n        this.contentElement.style.display = '';\n      }\n    }\n  }, {\n    key: 'hideContent',\n    value: function hideContent(newHeight) {\n      if (newHeight === 0) {\n        this.contentElement.style.display = 'none';\n      }\n    }\n  }, {\n    key: 'getStaticStateClasses',\n    value: function getStaticStateClasses(height) {\n      var _cx2;\n\n      return (0, _classnames2.default)((_cx2 = {}, _defineProperty(_cx2, this.animationStateClasses.static, true), _defineProperty(_cx2, this.animationStateClasses.staticHeightZero, height === 0), _defineProperty(_cx2, this.animationStateClasses.staticHeightSpecific, height > 0), _defineProperty(_cx2, this.animationStateClasses.staticHeightAuto, height === 'auto'), _cx2));\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _cx3,\n          _this3 = this;\n\n      var _props2 = this.props,\n          animateOpacity = _props2.animateOpacity,\n          applyInlineTransitions = _props2.applyInlineTransitions,\n          children = _props2.children,\n          className = _props2.className,\n          contentClassName = _props2.contentClassName,\n          delay = _props2.delay,\n          duration = _props2.duration,\n          easing = _props2.easing,\n          id = _props2.id,\n          style = _props2.style;\n      var _state = this.state,\n          height = _state.height,\n          overflow = _state.overflow,\n          animationStateClasses = _state.animationStateClasses,\n          shouldUseTransitions = _state.shouldUseTransitions;\n\n\n      var componentStyle = _extends({}, style, {\n        height: height,\n        overflow: overflow || style.overflow\n      });\n\n      if (shouldUseTransitions && applyInlineTransitions) {\n        componentStyle.transition = 'height ' + duration + 'ms ' + easing + ' ' + delay + 'ms';\n\n        // Include transition passed through styles\n        if (style.transition) {\n          componentStyle.transition = style.transition + ', ' + componentStyle.transition;\n        }\n\n        // Add webkit vendor prefix still used by opera, blackberry...\n        componentStyle.WebkitTransition = componentStyle.transition;\n      }\n\n      var contentStyle = {};\n\n      if (animateOpacity) {\n        contentStyle.transition = 'opacity ' + duration + 'ms ' + easing + ' ' + delay + 'ms';\n        // Add webkit vendor prefix still used by opera, blackberry...\n        contentStyle.WebkitTransition = contentStyle.transition;\n\n        if (height === 0) {\n          contentStyle.opacity = 0;\n        }\n      }\n\n      var componentClasses = (0, _classnames2.default)((_cx3 = {}, _defineProperty(_cx3, animationStateClasses, true), _defineProperty(_cx3, className, className), _cx3));\n\n      // Check if user passed aria-hidden prop\n      var hasAriaHiddenProp = typeof this.props['aria-hidden'] !== 'undefined';\n      var ariaHidden = hasAriaHiddenProp ? this.props['aria-hidden'] : height === 0;\n\n      return _react2.default.createElement(\n        'div',\n        _extends({}, omit.apply(undefined, [this.props].concat(PROPS_TO_OMIT)), {\n          'aria-hidden': ariaHidden,\n          className: componentClasses,\n          id: id,\n          style: componentStyle\n        }),\n        _react2.default.createElement(\n          'div',\n          {\n            className: contentClassName,\n            style: contentStyle,\n            ref: function ref(el) {\n              return _this3.contentElement = el;\n            }\n          },\n          children\n        )\n      );\n    }\n  }]);\n\n  return AnimateHeight;\n}(_react2.default.Component);\n\nvar heightPropType = function heightPropType(props, propName, componentName) {\n  var value = props[propName];\n\n  if (typeof value === 'number' && value >= 0 || isPercentage(value) || value === 'auto') {\n    return null;\n  }\n\n  return new TypeError('value \"' + value + '\" of type \"' + (typeof value === 'undefined' ? 'undefined' : _typeof(value)) + '\" is invalid type for ' + propName + ' in ' + componentName + '. ' + 'It needs to be a positive number, string \"auto\" or percentage string (e.g. \"15%\").');\n};\n\nAnimateHeight.propTypes = {\n  'aria-hidden': _propTypes2.default.bool,\n  animateOpacity: _propTypes2.default.bool,\n  animationStateClasses: _propTypes2.default.object,\n  applyInlineTransitions: _propTypes2.default.bool,\n  children: _propTypes2.default.any.isRequired,\n  className: _propTypes2.default.string,\n  contentClassName: _propTypes2.default.string,\n  delay: _propTypes2.default.number,\n  duration: _propTypes2.default.number,\n  easing: _propTypes2.default.string,\n  height: heightPropType,\n  id: _propTypes2.default.string,\n  onAnimationEnd: _propTypes2.default.func,\n  onAnimationStart: _propTypes2.default.func,\n  style: _propTypes2.default.object\n};\n\nAnimateHeight.defaultProps = {\n  animateOpacity: false,\n  animationStateClasses: ANIMATION_STATE_CLASSES,\n  applyInlineTransitions: true,\n  duration: 250,\n  delay: 0,\n  easing: 'ease',\n  style: {}\n};\n\nexports.default = AnimateHeight;"],"sourceRoot":""}