{"version":3,"file":"TransitionGroup-CSju2Hd7.js","sources":["../../Client/node_modules/react-transition-group/node_modules/dom-helpers/esm/hasClass.js","../../Client/node_modules/react-transition-group/node_modules/dom-helpers/esm/addClass.js","../../Client/node_modules/react-transition-group/node_modules/dom-helpers/esm/removeClass.js","../../Client/node_modules/react-transition-group/esm/CSSTransition.js","../../Client/node_modules/react-transition-group/esm/utils/ChildMapping.js","../../Client/node_modules/react-transition-group/esm/TransitionGroup.js"],"sourcesContent":["/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/addClass';\nimport removeOneClass from 'dom-helpers/removeClass';\nimport React from 'react';\nimport Transition from './Transition';\nimport { classNamesShape } from './utils/PropTypes';\nimport { forceReflow } from './utils/reflow';\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 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      if (node) forceReflow(node);\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 { Children, cloneElement, isValidElement } from 'react';\n/**\n * Given `this.props.children`, return an object mapping key to child.\n *\n * @param {*} children `this.props.children`\n * @return {object} Mapping of key to child\n */\n\nexport function getChildMapping(children, mapFn) {\n  var mapper = function mapper(child) {\n    return mapFn && isValidElement(child) ? mapFn(child) : child;\n  };\n\n  var result = Object.create(null);\n  if (children) Children.map(children, function (c) {\n    return c;\n  }).forEach(function (child) {\n    // run the map function here instead so that the key is the computed one\n    result[child.key] = mapper(child);\n  });\n  return result;\n}\n/**\n * When you're adding or removing children some may be added or removed in the\n * same render pass. We want to show *both* since we want to simultaneously\n * animate elements in and out. This function takes a previous set of keys\n * and a new set of keys and merges them with its best guess of the correct\n * ordering. In the future we may expose some of the utilities in\n * ReactMultiChild to make this easy, but for now React itself does not\n * directly have this concept of the union of prevChildren and nextChildren\n * so we implement it here.\n *\n * @param {object} prev prev children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @param {object} next next children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @return {object} a key set that contains all keys in `prev` and all keys\n * in `next` in a reasonable order.\n */\n\nexport function mergeChildMappings(prev, next) {\n  prev = prev || {};\n  next = next || {};\n\n  function getValueForKey(key) {\n    return key in next ? next[key] : prev[key];\n  } // For each key of `next`, the list of keys to insert before that key in\n  // the combined list\n\n\n  var nextKeysPending = Object.create(null);\n  var pendingKeys = [];\n\n  for (var prevKey in prev) {\n    if (prevKey in next) {\n      if (pendingKeys.length) {\n        nextKeysPending[prevKey] = pendingKeys;\n        pendingKeys = [];\n      }\n    } else {\n      pendingKeys.push(prevKey);\n    }\n  }\n\n  var i;\n  var childMapping = {};\n\n  for (var nextKey in next) {\n    if (nextKeysPending[nextKey]) {\n      for (i = 0; i < nextKeysPending[nextKey].length; i++) {\n        var pendingNextKey = nextKeysPending[nextKey][i];\n        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);\n      }\n    }\n\n    childMapping[nextKey] = getValueForKey(nextKey);\n  } // Finally, add the keys which didn't appear before any key in `next`\n\n\n  for (i = 0; i < pendingKeys.length; i++) {\n    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);\n  }\n\n  return childMapping;\n}\n\nfunction getProp(child, prop, props) {\n  return props[prop] != null ? props[prop] : child.props[prop];\n}\n\nexport function getInitialChildMapping(props, onExited) {\n  return getChildMapping(props.children, function (child) {\n    return cloneElement(child, {\n      onExited: onExited.bind(null, child),\n      in: true,\n      appear: getProp(child, 'appear', props),\n      enter: getProp(child, 'enter', props),\n      exit: getProp(child, 'exit', props)\n    });\n  });\n}\nexport function getNextChildMapping(nextProps, prevChildMapping, onExited) {\n  var nextChildMapping = getChildMapping(nextProps.children);\n  var children = mergeChildMappings(prevChildMapping, nextChildMapping);\n  Object.keys(children).forEach(function (key) {\n    var child = children[key];\n    if (!isValidElement(child)) return;\n    var hasPrev = (key in prevChildMapping);\n    var hasNext = (key in nextChildMapping);\n    var prevChild = prevChildMapping[key];\n    var isLeaving = isValidElement(prevChild) && !prevChild.props.in; // item is new (entering)\n\n    if (hasNext && (!hasPrev || isLeaving)) {\n      // console.log('entering', key)\n      children[key] = cloneElement(child, {\n        onExited: onExited.bind(null, child),\n        in: true,\n        exit: getProp(child, 'exit', nextProps),\n        enter: getProp(child, 'enter', nextProps)\n      });\n    } else if (!hasNext && hasPrev && !isLeaving) {\n      // item is old (exiting)\n      // console.log('leaving', key)\n      children[key] = cloneElement(child, {\n        in: false\n      });\n    } else if (hasNext && hasPrev && isValidElement(prevChild)) {\n      // item hasn't changed transition states\n      // copy over the last transition props;\n      // console.log('unchanged', key)\n      children[key] = cloneElement(child, {\n        onExited: onExited.bind(null, child),\n        in: prevChild.props.in,\n        exit: getProp(child, 'exit', nextProps),\n        enter: getProp(child, 'enter', nextProps)\n      });\n    }\n  });\n  return children;\n}","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { getChildMapping, getInitialChildMapping, getNextChildMapping } from './utils/ChildMapping';\n\nvar values = Object.values || function (obj) {\n  return Object.keys(obj).map(function (k) {\n    return obj[k];\n  });\n};\n\nvar defaultProps = {\n  component: 'div',\n  childFactory: function childFactory(child) {\n    return child;\n  }\n};\n/**\n * The `<TransitionGroup>` component manages a set of transition components\n * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition\n * components, `<TransitionGroup>` is a state machine for managing the mounting\n * and unmounting of components over time.\n *\n * Consider the example below. As items are removed or added to the TodoList the\n * `in` prop is toggled automatically by the `<TransitionGroup>`.\n *\n * Note that `<TransitionGroup>`  does not define any animation behavior!\n * Exactly _how_ a list item animates is up to the individual transition\n * component. This means you can mix and match animations across different list\n * items.\n */\n\nvar TransitionGroup = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(TransitionGroup, _React$Component);\n\n  function TransitionGroup(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n\n    var handleExited = _this.handleExited.bind(_assertThisInitialized(_this)); // Initial children should all be entering, dependent on appear\n\n\n    _this.state = {\n      contextValue: {\n        isMounting: true\n      },\n      handleExited: handleExited,\n      firstRender: true\n    };\n    return _this;\n  }\n\n  var _proto = TransitionGroup.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.mounted = true;\n    this.setState({\n      contextValue: {\n        isMounting: false\n      }\n    });\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.mounted = false;\n  };\n\n  TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {\n    var prevChildMapping = _ref.children,\n        handleExited = _ref.handleExited,\n        firstRender = _ref.firstRender;\n    return {\n      children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),\n      firstRender: false\n    };\n  } // node is `undefined` when user provided `nodeRef` prop\n  ;\n\n  _proto.handleExited = function handleExited(child, node) {\n    var currentChildMapping = getChildMapping(this.props.children);\n    if (child.key in currentChildMapping) return;\n\n    if (child.props.onExited) {\n      child.props.onExited(node);\n    }\n\n    if (this.mounted) {\n      this.setState(function (state) {\n        var children = _extends({}, state.children);\n\n        delete children[child.key];\n        return {\n          children: children\n        };\n      });\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        Component = _this$props.component,\n        childFactory = _this$props.childFactory,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"component\", \"childFactory\"]);\n\n    var contextValue = this.state.contextValue;\n    var children = values(this.state.children).map(childFactory);\n    delete props.appear;\n    delete props.enter;\n    delete props.exit;\n\n    if (Component === null) {\n      return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n        value: contextValue\n      }, children);\n    }\n\n    return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n      value: contextValue\n    }, /*#__PURE__*/React.createElement(Component, props, children));\n  };\n\n  return TransitionGroup;\n}(React.Component);\n\nTransitionGroup.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * `<TransitionGroup>` renders a `<div>` by default. You can change this\n   * behavior by providing a `component` prop.\n   * If you use React v16+ and would like to avoid a wrapping `<div>` element\n   * you can pass in `component={null}`. This is useful if the wrapping div\n   * borks your css styles.\n   */\n  component: PropTypes.any,\n\n  /**\n   * A set of `<Transition>` components, that are toggled `in` and out as they\n   * leave. the `<TransitionGroup>` will inject specific transition props, so\n   * remember to spread them through if you are wrapping the `<Transition>` as\n   * with our `<Fade>` example.\n   *\n   * While this component is meant for multiple `Transition` or `CSSTransition`\n   * children, sometimes you may want to have a single transition child with\n   * content that you want to be transitioned out and in when you change it\n   * (e.g. routes, images etc.) In that case you can change the `key` prop of\n   * the transition child as you change its content, this will cause\n   * `TransitionGroup` to transition the child out and back in.\n   */\n  children: PropTypes.node,\n\n  /**\n   * A convenience prop that enables or disables appear animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * A convenience prop that enables or disables enter animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * A convenience prop that enables or disables exit animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * You may need to apply reactive updates to a child as it is exiting.\n   * This is generally done by using `cloneElement` however in the case of an exiting\n   * child the element has already been removed and not accessible to the consumer.\n   *\n   * If you do need to update a child as it leaves you can provide a `childFactory`\n   * to wrap every child, even the ones that are leaving.\n   *\n   * @type Function(child: ReactElement) -> ReactElement\n   */\n  childFactory: PropTypes.func\n} : {};\nTransitionGroup.defaultProps = defaultProps;\nexport default TransitionGroup;"],"names":["hasClass","element","className","addClass","replaceClassName","origClass","classToRemove","removeClass","_addClass","node","classes","c","addOneClass","removeOneClass","CSSTransition","_React$Component","_inheritsLoose","_this","_len","args","_key","maybeNode","maybeAppearing","_this$resolveArgument","appearing","_this$resolveArgument2","type","_this$resolveArgument3","_this$resolveArgument4","_this$resolveArgument5","_this$resolveArgument6","classNames","isStringClassNames","prefix","baseClassName","activeClassName","doneClassName","_proto","phase","_this$getClassNames","_this$appliedClasses$","_this$props","props","_objectWithoutPropertiesLoose","Transition","_extends","React","getChildMapping","children","mapFn","mapper","child","isValidElement","result","Children","mergeChildMappings","prev","next","getValueForKey","key","nextKeysPending","pendingKeys","prevKey","i","childMapping","nextKey","pendingNextKey","getProp","prop","getInitialChildMapping","onExited","cloneElement","getNextChildMapping","nextProps","prevChildMapping","nextChildMapping","hasPrev","hasNext","prevChild","isLeaving","values","obj","k","defaultProps","TransitionGroup","context","handleExited","_assertThisInitialized","_ref","firstRender","currentChildMapping","state","Component","childFactory","contextValue","TransitionGroupContext"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5]}