{"version":3,"sources":["webpack:///./node_modules/classnames/index.js","webpack:///./node_modules/react-animate-height/lib/AnimateHeight.js","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"],"names":["hasOwn","hasOwnProperty","classNames","classes","i","arguments","length","arg","argType","push","Array","isArray","inner","apply","key","call","join","module","exports","default","Object","defineProperty","value","_typeof","Symbol","iterator","obj","constructor","prototype","_extends","assign","target","source","_createClass","defineProperties","props","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","_len","keys","_key","res","objectKeys","indexOf","cancelAnimationFrames","requestAnimationFrameIDs","forEach","id","cancelAnimationFrame","isNumber","n","isNaN","parseFloat","isFinite","isPercentage","height","search","substr","runCallback","callback","params","AnimateHeight","_React$Component","instance","TypeError","_classCallCheck","this","_this","self","ReferenceError","_possibleConstructorReturn","__proto__","getPrototypeOf","animationFrameIDs","overflow","animationStateClasses","getStaticStateClasses","state","shouldUseTransitions","subClass","superClass","create","setPrototypeOf","_inherits","contentElement","style","hideContent","prevProps","prevState","_this2","_props","delay","duration","onAnimationEnd","onAnimationStart","_cx","showContent","contentHeight","offsetHeight","totalDuration","newHeight","timeoutState","isCurrentHeightAuto","timeoutAnimationStateClasses","setState","clearTimeout","timeoutID","animationClassesTimeoutID","requestAnimationFrame","setTimeout","display","_cx2","_cx3","_this3","_props2","animateOpacity","applyInlineTransitions","children","className","contentClassName","easing","_state","componentStyle","transition","WebkitTransition","contentStyle","opacity","componentClasses","ariaHidden","createElement","undefined","concat","ref","el","Component","propTypes","bool","object","any","isRequired","string","number","propName","componentName","func","defaultProps","_inheritsLoose","replaceClassName","origClass","classToRemove","replace","RegExp","createContext","Transition","context","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","status","nextCallback","getDerivedStateFromProps","_ref","_proto","componentDidMount","updateStatus","componentDidUpdate","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","timeout","mounting","performEnter","performExit","appearing","_ref2","nodeRef","findDOMNode","maybeNode","maybeAppearing","timeouts","enterTimeout","config","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","onExit","onExiting","onExited","cancel","nextState","setNextCallback","_this4","active","event","handler","node","current","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","render","_this$props","childProps","TransitionGroupContext","Provider","cloneElement","Children","only","noop","contextType","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","split","c","element","classList","remove","setAttribute","baseVal","CSSTransition","args","appliedClasses","_this$resolveArgument","resolveArguments","removeClasses","addClass","_this$resolveArgument2","type","_this$resolveArgument3","getClassNames","isStringClassNames","baseClassName","activeClassName","doneClassName","phase","scrollTop","add","contains","hasClass","_addClass","_this$appliedClasses$","base","done"],"mappings":"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","file":"36.40046c7b418a4b4a6754.js","sourcesContent":["/*!\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;","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}"],"sourceRoot":""}