{"version":3,"sources":["webpack:////home/jenkins/agent/workspace/rAlWnROk32481EutLuZS/node_modules/react-flip-move/dist/react-flip-move.es.js"],"names":["warnOnce","msg","hasWarned","console","warn","parentNodePositionStatic","childIsDisabled","enterPresets","elevator","from","transform","opacity","to","fade","accordionVertical","transformOrigin","accordionHorizontal","none","leavePresets","appearPresets","find","predicate","arr","i","length","_isArray","Array","isArray","arg","Object","prototype","toString","call","fn","cache","hyphenate","str","replace","toLowerCase","_typeof","Symbol","iterator","obj","constructor","classCallCheck","instance","Constructor","TypeError","_extends","assign","target","arguments","source","key","hasOwnProperty","inherits","subClass","superClass","create","value","enumerable","writable","configurable","setPrototypeOf","__proto__","possibleConstructorReturn","self","ReferenceError","propConverter","ComposedComponent","_class","_temp","_Component","FlipMovePropConverter","this","apply","checkChildren","children","convertProps","props","workingProps","easing","onStart","onFinish","onStartAll","onFinishAll","typeName","disableAllAnimations","getPosition","maintainContainerHeight","verticalAlignment","duration","convertTimingProp","delay","staggerDurationBy","staggerDelayBy","appearAnimation","convertAnimationProp","enterAnimation","leaveAnimation","delegated","primaryPropKeys","keys","delegatedProps","attrs","undefined","result","forEach","indexOf","omit","style","position","prop","rawValue","parseInt","isNaN","defaultProps","animation","presets","render","createElement","node","getBoundingClientRect","applyStylesToDOMNode","_ref","domNode","styles","setProperty","getPositionDelta","_ref3","childDomNode","defaultBox","top","left","right","bottom","height","width","oldRelativeBox","childBoundingBox","parentBox","parentBoundingBox","newAbsoluteBox","newRelativeBox","createTransitionString","index","map","join","transitionEnd","transitions","transition","document","el","match","t","getPropertyValue","whichTransitionEvent","noBrowserSupport","getKey","childData","getElementChildren","toArray","enhancedFlipMove","FlipMove","_this","_len","args","_key","concat","state","element","appearing","childrenData","parentData","boundingBox","heightPlaceholderData","remainingAnimations","childrenToAnimate","findDOMContainer","findDOMNode","parentNode","HTMLElement","window","getComputedStyle","runAnimation","dynamicChildren","filter","doesChildNeedToBeAnimated","childrenInitialStyles","child","computeInitialStyles","push","animateChild","callChildrenHook","getChildData","_this$props","isAppearingWithAnimation","isEnteringWithAnimation","entering","isLeavingWithAnimation","leaving","_getPositionDelta","dX","dY","componentDidMount","isAnimationDisabled","prepForAnimation","componentDidUpdate","previousProps","a","b","notBothArrays","differentLengths","every","arraysEqual","d","calculateNextSetOfChildren","nextChildren","_this2","updatedChildren","nextChild","findChildByKey","isEntering","numOfChildrenLeaving","nextChildIndex","splice","_this3","_props","leavingChild","disabled","computed","margins","reduce","acc","margin","_babelHelpers$extends","propertyVal","Number","removeNodeFromDOMFlow","_ref4","parentDomNode","reductionInHeight","updateHeightPlaceholder","UNSAFE_componentWillReceiveProps","nextProps","updateBoundingBoxCaches","setState","childInitialStyles","_this4","requestAnimationFrame","bindTransitionEndHandler","_this5","addEventListener","transitionEndHandler","ev","triggerFinishHooks","removeEventListener","removeChildData","_this6","_ref2","item","hook","_this7","elements","domNodes","childKey","hasChildData","_this8","childrenBoundingBoxes","_getPosition","getRelativeBoundingBox","setChildData","_getPositionDelta2","data","prevState","createHeightPlaceholder","_this9","placeholderType","ref","visibility","childrenWithRefs","_this10","foundNode","nodeType","Node","TEXT_NODE","getNativeNode","_this11","_props2"],"mappings":"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","file":"default~multi-recipient-redux~recipient-redux~request-page~request-preview~request-success~send-page.esm.js","sourcesContent":["import React, { Children, Component, cloneElement, createElement } from 'react';\nimport ReactDOM, { findDOMNode } from 'react-dom';\n\nfunction warnOnce(msg) {\n  var hasWarned = false;\n  return function () {\n    if (!hasWarned) {\n      console.warn(msg);\n      hasWarned = true;\n    }\n  };\n}\n\n\nvar statelessFunctionalComponentSupplied = warnOnce('\\n>> Error, via react-flip-move <<\\n\\nYou provided a stateless functional component as a child to <FlipMove>. Unfortunately, SFCs aren\\'t supported, because Flip Move needs access to the backing instances via refs, and SFCs don\\'t have a public instance that holds that info.\\n\\nPlease wrap your components in a native element (eg. <div>), or a non-functional component.\\n');\n\nvar primitiveNodeSupplied = warnOnce('\\n>> Error, via react-flip-move <<\\n\\nYou provided a primitive (text or number) node as a child to <FlipMove>. Flip Move needs containers with unique keys to move children around.\\n\\nPlease wrap your value in a native element (eg. <span>), or a component.\\n');\n\nvar invalidTypeForTimingProp = function invalidTypeForTimingProp(args\n// prettier-ignore\n) {\n  return console.error('\\n>> Error, via react-flip-move <<\\n\\nThe prop you provided for \\'' + args.prop + '\\' is invalid. It needs to be a positive integer, or a string that can be resolved to a number. The value you provided is \\'' + args.value + '\\'.\\n\\nAs a result,  the default value for this parameter will be used, which is \\'' + args.defaultValue + '\\'.\\n');\n};\n\nvar invalidEnterLeavePreset = function invalidEnterLeavePreset(args\n// prettier-ignore\n) {\n  return console.error('\\n>> Error, via react-flip-move <<\\n\\nThe enter/leave preset you provided is invalid. We don\\'t currently have a \\'' + args.value + ' preset.\\'\\n\\nAcceptable values are ' + args.acceptableValues + '. The default value of \\'' + args.defaultValue + '\\' will be used.\\n');\n};\n\nvar parentNodePositionStatic = warnOnce('\\n>> Warning, via react-flip-move <<\\n\\nWhen using \"wrapperless\" mode (by supplying \\'typeName\\' of \\'null\\'), strange things happen when the direct parent has the default \"static\" position.\\n\\nFlipMove has added \\'position: relative\\' to this node, to ensure Flip Move animates correctly.\\n\\nTo avoid seeing this warning, simply apply a non-static position to that parent node.\\n');\n\nvar childIsDisabled = warnOnce('\\n>> Warning, via react-flip-move <<\\n\\nOne or more of Flip Move\\'s child elements have the html attribute \\'disabled\\' set to true.\\n\\nPlease note that this will cause animations to break in Internet Explorer 11 and below. Either remove the disabled attribute or set \\'animation\\' to false.\\n');\n\nvar enterPresets = {\n  elevator: {\n    from: { transform: 'scale(0)', opacity: '0' },\n    to: { transform: '', opacity: '' }\n  },\n  fade: {\n    from: { opacity: '0' },\n    to: { opacity: '' }\n  },\n  accordionVertical: {\n    from: { transform: 'scaleY(0)', transformOrigin: 'center top' },\n    to: { transform: '', transformOrigin: 'center top' }\n  },\n  accordionHorizontal: {\n    from: { transform: 'scaleX(0)', transformOrigin: 'left center' },\n    to: { transform: '', transformOrigin: 'left center' }\n  },\n  none: null\n};\n/**\n * React Flip Move | enterLeavePresets\n * (c) 2016-present Joshua Comeau\n *\n * This contains the master list of presets available for enter/leave animations,\n * along with the mapping between preset and styles.\n */\n\n\nvar leavePresets = {\n  elevator: {\n    from: { transform: 'scale(1)', opacity: '1' },\n    to: { transform: 'scale(0)', opacity: '0' }\n  },\n  fade: {\n    from: { opacity: '1' },\n    to: { opacity: '0' }\n  },\n  accordionVertical: {\n    from: { transform: 'scaleY(1)', transformOrigin: 'center top' },\n    to: { transform: 'scaleY(0)', transformOrigin: 'center top' }\n  },\n  accordionHorizontal: {\n    from: { transform: 'scaleX(1)', transformOrigin: 'left center' },\n    to: { transform: 'scaleX(0)', transformOrigin: 'left center' }\n  },\n  none: null\n};\n\n// For now, appearPresets will be identical to enterPresets.\n// Assigning a custom export in case we ever want to add appear-specific ones.\nvar appearPresets = enterPresets;\n\nvar defaultPreset = 'elevator';\nvar disablePreset = 'none';\n\nvar find = function find(predicate, arr) {\n  for (var i = 0; i < arr.length; i++) {\n    if (predicate(arr[i], i, arr)) {\n      return arr[i];\n    }\n  }\n\n  return undefined;\n};\n\n\nvar every = function every(predicate, arr) {\n  for (var i = 0; i < arr.length; i++) {\n    if (!predicate(arr[i], i, arr)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n// eslint-disable-next-line import/no-mutable-exports\nvar _isArray = function isArray(arr) {\n  _isArray = Array.isArray || function (arg) {\n    return Object.prototype.toString.call(arg) === '[object Array]';\n  };\n  return _isArray(arr);\n};\n\nvar isElementAnSFC = function isElementAnSFC(element) {\n  var isNativeDOMElement = typeof element.type === 'string';\n\n  if (isNativeDOMElement) {\n    return false;\n  }\n\n  return typeof element.type === 'function' && !element.type.prototype.isReactComponent;\n};\n\nfunction omit(obj) {\n  var attrs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n\n  var result = {};\n  Object.keys(obj).forEach(function (key) {\n    if (attrs.indexOf(key) === -1) {\n      result[key] = obj[key];\n    }\n  });\n  return result;\n}\n\nfunction arraysEqual(a, b) {\n  var sameObject = a === b;\n  if (sameObject) {\n    return true;\n  }\n\n  var notBothArrays = !_isArray(a) || !_isArray(b);\n  var differentLengths = a.length !== b.length;\n\n  if (notBothArrays || differentLengths) {\n    return false;\n  }\n\n  return every(function (element, index) {\n    return element === b[index];\n  }, a);\n}\n\nfunction memoizeString(fn) {\n  var cache = {};\n\n  return function (str) {\n    if (!cache[str]) {\n      cache[str] = fn(str);\n    }\n    return cache[str];\n  };\n}\n\nvar hyphenate = memoizeString(function (str) {\n  return str.replace(/([A-Z])/g, '-$1').toLowerCase();\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\n\n\n\n\n\n\n\n\n\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n\n\n\n\n\n\n\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\n\n\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\n\n\n\n\n\n\n\n\n\n\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\n/**\n * React Flip Move | propConverter\n * (c) 2016-present Joshua Comeau\n *\n * Abstracted away a bunch of the messy business with props.\n *   - props flow types and defaultProps\n *   - Type conversion (We accept 'string' and 'number' values for duration,\n *     delay, and other fields, but we actually need them to be ints.)\n *   - Children conversion (we need the children to be an array. May not always\n *     be, if a single child is passed in.)\n *   - Resolving animation presets into their base CSS styles\n */\n/* eslint-disable block-scoped-var */\n\n// eslint-disable-next-line no-duplicate-imports\n\n\nfunction propConverter(ComposedComponent) {\n  var _class, _temp;\n\n  return _temp = _class = function (_Component) {\n    inherits(FlipMovePropConverter, _Component);\n\n    function FlipMovePropConverter() {\n      classCallCheck(this, FlipMovePropConverter);\n      return possibleConstructorReturn(this, _Component.apply(this, arguments));\n    }\n\n    // eslint-disable-next-line class-methods-use-this\n    FlipMovePropConverter.prototype.checkChildren = function checkChildren(children) {\n      // Skip all console warnings in production.\n      // Bail early, to avoid unnecessary work.\n      if (process.env.NODE_ENV === 'production') {\n        return;\n      }\n\n      // same as React.Node, but without fragments, see https://github.com/facebook/flow/issues/4781\n\n\n      // FlipMove does not support stateless functional components.\n      // Check to see if any supplied components won't work.\n      // If the child doesn't have a key, it means we aren't animating it.\n      // It's allowed to be an SFC, since we ignore it.\n      Children.forEach(children, function (child) {\n        // null, undefined, and booleans will be filtered out by Children.toArray\n        if (child == null || typeof child === 'boolean') {\n          return;\n        }\n\n        if ((typeof child === 'undefined' ? 'undefined' : _typeof(child)) !== 'object') {\n          primitiveNodeSupplied();\n          return;\n        }\n\n        if (isElementAnSFC(child) && child.key != null) {\n          statelessFunctionalComponentSupplied();\n        }\n      });\n    };\n\n    FlipMovePropConverter.prototype.convertProps = function convertProps(props) {\n      var workingProps = {\n        // explicitly bypass the props that don't need conversion\n        children: props.children,\n        easing: props.easing,\n        onStart: props.onStart,\n        onFinish: props.onFinish,\n        onStartAll: props.onStartAll,\n        onFinishAll: props.onFinishAll,\n        typeName: props.typeName,\n        disableAllAnimations: props.disableAllAnimations,\n        getPosition: props.getPosition,\n        maintainContainerHeight: props.maintainContainerHeight,\n        verticalAlignment: props.verticalAlignment,\n\n        // Do string-to-int conversion for all timing-related props\n        duration: this.convertTimingProp('duration'),\n        delay: this.convertTimingProp('delay'),\n        staggerDurationBy: this.convertTimingProp('staggerDurationBy'),\n        staggerDelayBy: this.convertTimingProp('staggerDelayBy'),\n\n        // Our enter/leave animations can be specified as boolean (default or\n        // disabled), string (preset name), or object (actual animation values).\n        // Let's standardize this so that they're always objects\n        appearAnimation: this.convertAnimationProp(props.appearAnimation, appearPresets),\n        enterAnimation: this.convertAnimationProp(props.enterAnimation, enterPresets),\n        leaveAnimation: this.convertAnimationProp(props.leaveAnimation, leavePresets),\n\n        delegated: {}\n      };\n\n      this.checkChildren(workingProps.children);\n\n      // Gather any additional props;\n      // they will be delegated to the ReactElement created.\n      var primaryPropKeys = Object.keys(workingProps);\n      var delegatedProps = omit(this.props, primaryPropKeys);\n\n      // The FlipMove container element needs to have a non-static position.\n      // We use `relative` by default, but it can be overridden by the user.\n      // Now that we're delegating props, we need to merge this in.\n      delegatedProps.style = _extends({\n        position: 'relative'\n      }, delegatedProps.style);\n\n      workingProps.delegated = delegatedProps;\n\n      return workingProps;\n    };\n\n    FlipMovePropConverter.prototype.convertTimingProp = function convertTimingProp(prop) {\n      var rawValue = this.props[prop];\n\n      var value = typeof rawValue === 'number' ? rawValue : parseInt(rawValue, 10);\n\n      if (isNaN(value)) {\n        var defaultValue = FlipMovePropConverter.defaultProps[prop];\n\n        if (process.env.NODE_ENV !== 'production') {\n          invalidTypeForTimingProp({\n            prop: prop,\n            value: rawValue,\n            defaultValue: defaultValue\n          });\n        }\n\n        return defaultValue;\n      }\n\n      return value;\n    };\n\n    // eslint-disable-next-line class-methods-use-this\n\n\n    FlipMovePropConverter.prototype.convertAnimationProp = function convertAnimationProp(animation, presets) {\n      switch (typeof animation === 'undefined' ? 'undefined' : _typeof(animation)) {\n        case 'boolean':\n          {\n            // If it's true, we want to use the default preset.\n            // If it's false, we want to use the 'none' preset.\n            return presets[animation ? defaultPreset : disablePreset];\n          }\n\n        case 'string':\n          {\n            var presetKeys = Object.keys(presets);\n\n            if (presetKeys.indexOf(animation) === -1) {\n              if (process.env.NODE_ENV !== 'production') {\n                invalidEnterLeavePreset({\n                  value: animation,\n                  acceptableValues: presetKeys.join(', '),\n                  defaultValue: defaultPreset\n                });\n              }\n\n              return presets[defaultPreset];\n            }\n\n            return presets[animation];\n          }\n\n        default:\n          {\n            return animation;\n          }\n      }\n    };\n\n    FlipMovePropConverter.prototype.render = function render() {\n      return React.createElement(ComposedComponent, this.convertProps(this.props));\n    };\n\n    return FlipMovePropConverter;\n  }(Component), _class.defaultProps = {\n    easing: 'ease-in-out',\n    duration: 350,\n    delay: 0,\n    staggerDurationBy: 0,\n    staggerDelayBy: 0,\n    typeName: 'div',\n    enterAnimation: defaultPreset,\n    leaveAnimation: defaultPreset,\n    disableAllAnimations: false,\n    getPosition: function getPosition(node) {\n      return node.getBoundingClientRect();\n    },\n    maintainContainerHeight: false,\n    verticalAlignment: 'top'\n  }, _temp;\n}\n\n/**\n * React Flip Move\n * (c) 2016-present Joshua Comeau\n *\n * These methods read from and write to the DOM.\n * They almost always have side effects, and will hopefully become the\n * only spot in the codebase with impure functions.\n */\nfunction applyStylesToDOMNode(_ref) {\n  var domNode = _ref.domNode,\n      styles = _ref.styles;\n\n  // Can't just do an object merge because domNode.styles is no regular object.\n  // Need to do it this way for the engine to fire its `set` listeners.\n  Object.keys(styles).forEach(function (key) {\n    domNode.style.setProperty(hyphenate(key), styles[key]);\n  });\n}\n\n// Modified from Modernizr\nfunction whichTransitionEvent() {\n  var transitions = {\n    transition: 'transitionend',\n    '-o-transition': 'oTransitionEnd',\n    '-moz-transition': 'transitionend',\n    '-webkit-transition': 'webkitTransitionEnd'\n  };\n\n  // If we're running in a browserless environment (eg. SSR), it doesn't apply.\n  // Return a placeholder string, for consistent type return.\n  if (typeof document === 'undefined') return '';\n\n  var el = document.createElement('fakeelement');\n\n  var match = find(function (t) {\n    return el.style.getPropertyValue(t) !== undefined;\n  }, Object.keys(transitions));\n\n  // If no `transition` is found, we must be running in a browser so ancient,\n  // React itself won't run. Return an empty string, for consistent type return\n  return match ? transitions[match] : '';\n}\n\nvar getRelativeBoundingBox = function getRelativeBoundingBox(_ref2) {\n  var childDomNode = _ref2.childDomNode,\n      parentDomNode = _ref2.parentDomNode,\n      getPosition = _ref2.getPosition;\n\n  var parentBox = getPosition(parentDomNode);\n\n  var _getPosition = getPosition(childDomNode),\n      top = _getPosition.top,\n      left = _getPosition.left,\n      right = _getPosition.right,\n      bottom = _getPosition.bottom,\n      width = _getPosition.width,\n      height = _getPosition.height;\n\n  return {\n    top: top - parentBox.top,\n    left: left - parentBox.left,\n    right: parentBox.right - right,\n    bottom: parentBox.bottom - bottom,\n    width: width,\n    height: height\n  };\n};\n\n/** getPositionDelta\n * This method returns the delta between two bounding boxes, to figure out\n * how many pixels on each axis the element has moved.\n *\n */\nvar getPositionDelta = function getPositionDelta(_ref3) {\n  var childDomNode = _ref3.childDomNode,\n      childBoundingBox = _ref3.childBoundingBox,\n      parentBoundingBox = _ref3.parentBoundingBox,\n      getPosition = _ref3.getPosition;\n\n  // TEMP: A mystery bug is sometimes causing unnecessary boundingBoxes to\n  var defaultBox = {\n    top: 0,\n    left: 0,\n    right: 0,\n    bottom: 0,\n    height: 0,\n    width: 0\n  };\n\n  // Our old box is its last calculated position, derived on mount or at the\n  // start of the previous animation.\n  var oldRelativeBox = childBoundingBox || defaultBox;\n  var parentBox = parentBoundingBox || defaultBox;\n\n  // Our new box is the new final resting place: Where we expect it to wind up\n  // after the animation. First we get the box in absolute terms (AKA relative\n  // to the viewport), and then we calculate its relative box (relative to the\n  // parent container)\n  var newAbsoluteBox = getPosition(childDomNode);\n  var newRelativeBox = {\n    top: newAbsoluteBox.top - parentBox.top,\n    left: newAbsoluteBox.left - parentBox.left\n  };\n\n  return [oldRelativeBox.left - newRelativeBox.left, oldRelativeBox.top - newRelativeBox.top];\n};\n\n/** removeNodeFromDOMFlow\n * This method does something very sneaky: it removes a DOM node from the\n * document flow, but without actually changing its on-screen position.\n *\n * It works by calculating where the node is, and then applying styles\n * so that it winds up being positioned absolutely, but in exactly the\n * same place.\n *\n * This is a vital part of the FLIP technique.\n */\nvar removeNodeFromDOMFlow = function removeNodeFromDOMFlow(childData, verticalAlignment) {\n  var domNode = childData.domNode,\n      boundingBox = childData.boundingBox;\n\n\n  if (!domNode || !boundingBox) {\n    return;\n  }\n\n  // For this to work, we have to offset any given `margin`.\n  var computed = window.getComputedStyle(domNode);\n\n  // We need to clean up margins, by converting and removing suffix:\n  // eg. '21px' -> 21\n  var marginAttrs = ['margin-top', 'margin-left', 'margin-right'];\n  var margins = marginAttrs.reduce(function (acc, margin) {\n    var _babelHelpers$extends;\n\n    var propertyVal = computed.getPropertyValue(margin);\n\n    return _extends({}, acc, (_babelHelpers$extends = {}, _babelHelpers$extends[margin] = Number(propertyVal.replace('px', '')), _babelHelpers$extends));\n  }, {});\n\n  // If we're bottom-aligned, we need to add the height of the child to its\n  // top offset. This is because, when the container is bottom-aligned, its\n  // height shrinks from the top, not the bottom. We're removing this node\n  // from the flow, so the top is going to drop by its height.\n  var topOffset = verticalAlignment === 'bottom' ? boundingBox.top - boundingBox.height : boundingBox.top;\n\n  var styles = {\n    position: 'absolute',\n    top: topOffset - margins['margin-top'] + 'px',\n    left: boundingBox.left - margins['margin-left'] + 'px',\n    right: boundingBox.right - margins['margin-right'] + 'px'\n  };\n\n  applyStylesToDOMNode({ domNode: domNode, styles: styles });\n};\n\n/** updateHeightPlaceholder\n * An optional property to FlipMove is a `maintainContainerHeight` boolean.\n * This property creates a node that fills space, so that the parent\n * container doesn't collapse when its children are removed from the\n * document flow.\n */\nvar updateHeightPlaceholder = function updateHeightPlaceholder(_ref4) {\n  var domNode = _ref4.domNode,\n      parentData = _ref4.parentData,\n      getPosition = _ref4.getPosition;\n\n  var parentDomNode = parentData.domNode;\n  var parentBoundingBox = parentData.boundingBox;\n\n  if (!parentDomNode || !parentBoundingBox) {\n    return;\n  }\n\n  // We need to find the height of the container *without* the placeholder.\n  // Since it's possible that the placeholder might already be present,\n  // we first set its height to 0.\n  // This allows the container to collapse down to the size of just its\n  // content (plus container padding or borders if any).\n  applyStylesToDOMNode({ domNode: domNode, styles: { height: '0' } });\n\n  // Find the distance by which the container would be collapsed by elements\n  // leaving. We compare the freshly-available parent height with the original,\n  // cached container height.\n  var originalParentHeight = parentBoundingBox.height;\n  var collapsedParentHeight = getPosition(parentDomNode).height;\n  var reductionInHeight = originalParentHeight - collapsedParentHeight;\n\n  // If the container has become shorter, update the padding element's\n  // height to take up the difference. Otherwise set its height to zero,\n  // so that it has no effect.\n  var styles = {\n    height: reductionInHeight > 0 ? reductionInHeight + 'px' : '0'\n  };\n\n  applyStylesToDOMNode({ domNode: domNode, styles: styles });\n};\n\nvar getNativeNode = function getNativeNode(element) {\n  // When running in a windowless environment, abort!\n  if (typeof HTMLElement === 'undefined') {\n    return null;\n  }\n\n  // `element` may already be a native node.\n  if (element instanceof HTMLElement) {\n    return element;\n  }\n\n  // While ReactDOM's `findDOMNode` is discouraged, it's the only\n  // publicly-exposed way to find the underlying DOM node for\n  // composite components.\n  var foundNode = findDOMNode(element);\n\n  if (foundNode && foundNode.nodeType === Node.TEXT_NODE) {\n    // Text nodes are not supported\n    return null;\n  }\n  // eslint-disable-next-line flowtype/no-weak-types\n  return foundNode;\n};\n\nvar createTransitionString = function createTransitionString(index, props) {\n  var delay = props.delay,\n      duration = props.duration;\n  var staggerDurationBy = props.staggerDurationBy,\n      staggerDelayBy = props.staggerDelayBy,\n      easing = props.easing;\n\n\n  delay += index * staggerDelayBy;\n  duration += index * staggerDurationBy;\n\n  var cssProperties = ['transform', 'opacity'];\n\n  return cssProperties.map(function (prop) {\n    return prop + ' ' + duration + 'ms ' + easing + ' ' + delay + 'ms';\n  }).join(', ');\n};\n\n/**\n * React Flip Move\n * (c) 2016-present Joshua Comeau\n *\n * For information on how this code is laid out, check out CODE_TOUR.md\n */\n\n/* eslint-disable react/prop-types */\n\n// eslint-disable-next-line no-duplicate-imports\n\n\nvar transitionEnd = whichTransitionEvent();\nvar noBrowserSupport = !transitionEnd;\n\nfunction getKey(childData) {\n  return childData.key || '';\n}\n\nfunction getElementChildren(children) {\n  // Fix incomplete typing of Children.toArray\n  // eslint-disable-next-line flowtype/no-weak-types\n  return Children.toArray(children);\n}\n\nvar FlipMove$1 = function (_Component) {\n  inherits(FlipMove, _Component);\n\n  function FlipMove() {\n    var _temp, _this, _ret;\n\n    classCallCheck(this, FlipMove);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {\n      children: getElementChildren(\n      // `this.props` ought to always be defined at this point, but a report\n      // was made about it not being defined in IE10.\n      // TODO: Test in IE10, to see if there's an underlying cause that can\n      // be addressed.\n      _this.props ? _this.props.children : []).map(function (element) {\n        return _extends({}, element, {\n          element: element,\n          appearing: true\n        });\n      })\n    }, _this.childrenData = {}, _this.parentData = {\n      domNode: null,\n      boundingBox: null\n    }, _this.heightPlaceholderData = {\n      domNode: null\n    }, _this.remainingAnimations = 0, _this.childrenToAnimate = [], _this.findDOMContainer = function () {\n      // eslint-disable-next-line react/no-find-dom-node\n      var domNode = ReactDOM.findDOMNode(_this);\n      var parentNode = domNode && domNode.parentNode;\n\n      // This ought to be impossible, but handling it for Flow's sake.\n      if (!parentNode || !(parentNode instanceof HTMLElement)) {\n        return;\n      }\n\n      // If the parent node has static positioning, leave animations might look\n      // really funky. Let's automatically apply `position: relative` in this\n      // case, to prevent any quirkiness.\n      if (window.getComputedStyle(parentNode).position === 'static') {\n        parentNode.style.position = 'relative';\n        parentNodePositionStatic();\n      }\n\n      _this.parentData.domNode = parentNode;\n    }, _this.runAnimation = function () {\n      var dynamicChildren = _this.state.children.filter(_this.doesChildNeedToBeAnimated);\n\n      // Splitting DOM reads and writes to be peformed in batches\n      var childrenInitialStyles = dynamicChildren.map(function (child) {\n        return _this.computeInitialStyles(child);\n      });\n      dynamicChildren.forEach(function (child, index) {\n        _this.remainingAnimations += 1;\n        _this.childrenToAnimate.push(getKey(child));\n        _this.animateChild(child, index, childrenInitialStyles[index]);\n      });\n\n      if (typeof _this.props.onStartAll === 'function') {\n        _this.callChildrenHook(_this.props.onStartAll);\n      }\n    }, _this.doesChildNeedToBeAnimated = function (child) {\n      // If the child doesn't have a key, it's an immovable child (one that we\n      // do not want to do FLIP stuff to.)\n      if (!getKey(child)) {\n        return false;\n      }\n\n      var childData = _this.getChildData(getKey(child));\n      var childDomNode = childData.domNode;\n      var childBoundingBox = childData.boundingBox;\n      var parentBoundingBox = _this.parentData.boundingBox;\n\n      if (!childDomNode) {\n        return false;\n      }\n\n      var _this$props = _this.props,\n          appearAnimation = _this$props.appearAnimation,\n          enterAnimation = _this$props.enterAnimation,\n          leaveAnimation = _this$props.leaveAnimation,\n          getPosition = _this$props.getPosition;\n\n\n      var isAppearingWithAnimation = child.appearing && appearAnimation;\n      var isEnteringWithAnimation = child.entering && enterAnimation;\n      var isLeavingWithAnimation = child.leaving && leaveAnimation;\n\n      if (isAppearingWithAnimation || isEnteringWithAnimation || isLeavingWithAnimation) {\n        return true;\n      }\n\n      // If it isn't entering/leaving, we want to animate it if it's\n      // on-screen position has changed.\n\n      var _getPositionDelta = getPositionDelta({\n        childDomNode: childDomNode,\n        childBoundingBox: childBoundingBox,\n        parentBoundingBox: parentBoundingBox,\n        getPosition: getPosition\n      }),\n          dX = _getPositionDelta[0],\n          dY = _getPositionDelta[1];\n\n      return dX !== 0 || dY !== 0;\n    }, _temp), possibleConstructorReturn(_this, _ret);\n  }\n  // Copy props.children into state.\n  // To understand why this is important (and not an anti-pattern), consider\n  // how \"leave\" animations work. An item has \"left\" when the component\n  // receives a new set of props that do NOT contain the item.\n  // If we just render the props as-is, the item would instantly disappear.\n  // We want to keep the item rendered for a little while, until its animation\n  // can complete. Because we cannot mutate props, we make `state` the source\n  // of truth.\n\n\n  // FlipMove needs to know quite a bit about its children in order to do\n  // its job. We store these as a property on the instance. We're not using\n  // state, because we don't want changes to trigger re-renders, we just\n  // need a place to keep the data for reference, when changes happen.\n  // This field should not be accessed directly. Instead, use getChildData,\n  // putChildData, etc...\n\n\n  // Similarly, track the dom node and box of our parent element.\n\n\n  // If `maintainContainerHeight` prop is set to true, we'll create a\n  // placeholder element which occupies space so that the parent height\n  // doesn't change when items are removed from the document flow (which\n  // happens during leave animations)\n\n\n  // Keep track of remaining animations so we know when to fire the\n  // all-finished callback, and clean up after ourselves.\n  // NOTE: we can't simply use childrenToAnimate.length to track remaining\n  // animations, because we need to maintain the list of animating children,\n  // to pass to the `onFinishAll` handler.\n\n\n  FlipMove.prototype.componentDidMount = function componentDidMount() {\n    // Because React 16 no longer requires wrapping elements, Flip Move can opt\n    // to not wrap the children in an element. In that case, find the parent\n    // element using `findDOMNode`.\n    if (this.props.typeName === null) {\n      this.findDOMContainer();\n    }\n\n    // Run our `appearAnimation` if it was requested, right after the\n    // component mounts.\n    var shouldTriggerFLIP = this.props.appearAnimation && !this.isAnimationDisabled(this.props);\n\n    if (shouldTriggerFLIP) {\n      this.prepForAnimation();\n      this.runAnimation();\n    }\n  };\n\n  FlipMove.prototype.componentDidUpdate = function componentDidUpdate(previousProps) {\n    if (this.props.typeName === null) {\n      this.findDOMContainer();\n    }\n    // If the children have been re-arranged, moved, or added/removed,\n    // trigger the main FLIP animation.\n    //\n    // IMPORTANT: We need to make sure that the children have actually changed.\n    // At the end of the transition, we clean up nodes that need to be removed.\n    // We DON'T want this cleanup to trigger another update.\n\n    var oldChildrenKeys = getElementChildren(this.props.children).map(function (d) {\n      return d.key;\n    });\n    var nextChildrenKeys = getElementChildren(previousProps.children).map(function (d) {\n      return d.key;\n    });\n\n    var shouldTriggerFLIP = !arraysEqual(oldChildrenKeys, nextChildrenKeys) && !this.isAnimationDisabled(this.props);\n\n    if (shouldTriggerFLIP) {\n      this.prepForAnimation();\n      this.runAnimation();\n    }\n  };\n\n  FlipMove.prototype.calculateNextSetOfChildren = function calculateNextSetOfChildren(nextChildren) {\n    var _this2 = this;\n\n    // We want to:\n    //   - Mark all new children as `entering`\n    //   - Pull in previous children that aren't in nextChildren, and mark them\n    //     as `leaving`\n    //   - Preserve the nextChildren list order, with leaving children in their\n    //     appropriate places.\n    //\n\n    var updatedChildren = nextChildren.map(function (nextChild) {\n      var child = _this2.findChildByKey(nextChild.key);\n\n      // If the current child did exist, but it was in the midst of leaving,\n      // we want to treat it as though it's entering\n      var isEntering = !child || child.leaving;\n\n      return _extends({}, nextChild, { element: nextChild, entering: isEntering });\n    });\n\n    // This is tricky. We want to keep the nextChildren's ordering, but with\n    // any just-removed items maintaining their original position.\n    // eg.\n    //   this.state.children  = [ 1, 2, 3, 4 ]\n    //   nextChildren         = [ 3, 1 ]\n    //\n    // In this example, we've removed the '2' & '4'\n    // We want to end up with:  [ 2, 3, 1, 4 ]\n    //\n    // To accomplish that, we'll iterate through this.state.children. whenever\n    // we find a match, we'll append our `leaving` flag to it, and insert it\n    // into the nextChildren in its ORIGINAL position. Note that, as we keep\n    // inserting old items into the new list, the \"original\" position will\n    // keep incrementing.\n    var numOfChildrenLeaving = 0;\n    this.state.children.forEach(function (child, index) {\n      var isLeaving = !find(function (_ref) {\n        var key = _ref.key;\n        return key === getKey(child);\n      }, nextChildren);\n\n      // If the child isn't leaving (or, if there is no leave animation),\n      // we don't need to add it into the state children.\n      if (!isLeaving || !_this2.props.leaveAnimation) return;\n\n      var nextChild = _extends({}, child, { leaving: true });\n      var nextChildIndex = index + numOfChildrenLeaving;\n\n      updatedChildren.splice(nextChildIndex, 0, nextChild);\n      numOfChildrenLeaving += 1;\n    });\n\n    return updatedChildren;\n  };\n\n  FlipMove.prototype.prepForAnimation = function prepForAnimation() {\n    var _this3 = this;\n\n    // Our animation prep consists of:\n    // - remove children that are leaving from the DOM flow, so that the new\n    //   layout can be accurately calculated,\n    // - update the placeholder container height, if needed, to ensure that\n    //   the parent's height doesn't collapse.\n\n    var _props = this.props,\n        leaveAnimation = _props.leaveAnimation,\n        maintainContainerHeight = _props.maintainContainerHeight,\n        getPosition = _props.getPosition;\n\n    // we need to make all leaving nodes \"invisible\" to the layout calculations\n    // that will take place in the next step (this.runAnimation).\n\n    if (leaveAnimation) {\n      var leavingChildren = this.state.children.filter(function (child) {\n        return child.leaving;\n      });\n\n      leavingChildren.forEach(function (leavingChild) {\n        var childData = _this3.getChildData(getKey(leavingChild));\n\n        // Warn if child is disabled\n        if (!_this3.isAnimationDisabled(_this3.props) && childData.domNode && childData.domNode.disabled) {\n          childIsDisabled();\n        }\n\n        // We need to take the items out of the \"flow\" of the document, so that\n        // its siblings can move to take its place.\n        if (childData.boundingBox) {\n          removeNodeFromDOMFlow(childData, _this3.props.verticalAlignment);\n        }\n      });\n\n      if (maintainContainerHeight && this.heightPlaceholderData.domNode) {\n        updateHeightPlaceholder({\n          domNode: this.heightPlaceholderData.domNode,\n          parentData: this.parentData,\n          getPosition: getPosition\n        });\n      }\n    }\n\n    // For all children not in the middle of entering or leaving,\n    // we need to reset the transition, so that the NEW shuffle starts from\n    // the right place.\n    this.state.children.forEach(function (child) {\n      var _getChildData = _this3.getChildData(getKey(child)),\n          domNode = _getChildData.domNode;\n\n      // Ignore children that don't render DOM nodes (eg. by returning null)\n\n\n      if (!domNode) {\n        return;\n      }\n\n      if (!child.entering && !child.leaving) {\n        applyStylesToDOMNode({\n          domNode: domNode,\n          styles: {\n            transition: ''\n          }\n        });\n      }\n    });\n  };\n\n  // eslint-disable-next-line camelcase\n\n\n  FlipMove.prototype.UNSAFE_componentWillReceiveProps = function UNSAFE_componentWillReceiveProps(nextProps) {\n    // When the component is handed new props, we need to figure out the\n    // \"resting\" position of all currently-rendered DOM nodes.\n    // We store that data in this.parent and this.children,\n    // so it can be used later to work out the animation.\n    this.updateBoundingBoxCaches();\n\n    // Convert opaque children object to array.\n    var nextChildren = getElementChildren(nextProps.children);\n\n    // Next, we need to update our state, so that it contains our new set of\n    // children. If animation is disabled or unsupported, this is easy;\n    // we just copy our props into state.\n    // Assuming that we can animate, though, we have to do some work.\n    // Essentially, we want to keep just-deleted nodes in the DOM for a bit\n    // longer, so that we can animate them away.\n    this.setState({\n      children: this.isAnimationDisabled(nextProps) ? nextChildren.map(function (element) {\n        return _extends({}, element, { element: element });\n      }) : this.calculateNextSetOfChildren(nextChildren)\n    });\n  };\n\n  FlipMove.prototype.animateChild = function animateChild(child, index, childInitialStyles) {\n    var _this4 = this;\n\n    var _getChildData2 = this.getChildData(getKey(child)),\n        domNode = _getChildData2.domNode;\n\n    if (!domNode) {\n      return;\n    }\n\n    // Apply the relevant style for this DOM node\n    // This is the offset from its actual DOM position.\n    // eg. if an item has been re-rendered 20px lower, we want to apply a\n    // style of 'transform: translate(-20px)', so that it appears to be where\n    // it started.\n    // In FLIP terminology, this is the 'Invert' stage.\n    applyStylesToDOMNode({\n      domNode: domNode,\n      styles: childInitialStyles\n    });\n\n    // Start by invoking the onStart callback for this child.\n    if (this.props.onStart) this.props.onStart(child, domNode);\n\n    // Next, animate the item from it's artificially-offset position to its\n    // new, natural position.\n    requestAnimationFrame(function () {\n      requestAnimationFrame(function () {\n        // NOTE, RE: the double-requestAnimationFrame:\n        // Sadly, this is the most browser-compatible way to do this I've found.\n        // Essentially we need to set the initial styles outside of any request\n        // callbacks to avoid batching them. Then, a frame needs to pass with\n        // the styles above rendered. Then, on the second frame, we can apply\n        // our final styles to perform the animation.\n\n        // Our first order of business is to \"undo\" the styles applied in the\n        // previous frames, while also adding a `transition` property.\n        // This way, the item will smoothly transition from its old position\n        // to its new position.\n\n        // eslint-disable-next-line flowtype/require-variable-type\n        var styles = {\n          transition: createTransitionString(index, _this4.props),\n          transform: '',\n          opacity: ''\n        };\n\n        if (child.appearing && _this4.props.appearAnimation) {\n          styles = _extends({}, styles, _this4.props.appearAnimation.to);\n        } else if (child.entering && _this4.props.enterAnimation) {\n          styles = _extends({}, styles, _this4.props.enterAnimation.to);\n        } else if (child.leaving && _this4.props.leaveAnimation) {\n          styles = _extends({}, styles, _this4.props.leaveAnimation.to);\n        }\n\n        // In FLIP terminology, this is the 'Play' stage.\n        applyStylesToDOMNode({ domNode: domNode, styles: styles });\n      });\n    });\n\n    this.bindTransitionEndHandler(child);\n  };\n\n  FlipMove.prototype.bindTransitionEndHandler = function bindTransitionEndHandler(child) {\n    var _this5 = this;\n\n    var _getChildData3 = this.getChildData(getKey(child)),\n        domNode = _getChildData3.domNode;\n\n    if (!domNode) {\n      return;\n    }\n\n    // The onFinish callback needs to be bound to the transitionEnd event.\n    // We also need to unbind it when the transition completes, so this ugly\n    // inline function is required (we need it here so it closes over\n    // dependent variables `child` and `domNode`)\n    var transitionEndHandler = function transitionEndHandler(ev) {\n      // It's possible that this handler is fired not on our primary transition,\n      // but on a nested transition (eg. a hover effect). Ignore these cases.\n      if (ev.target !== domNode) return;\n\n      // Remove the 'transition' inline style we added. This is cleanup.\n      domNode.style.transition = '';\n\n      // Trigger any applicable onFinish/onFinishAll hooks\n      _this5.triggerFinishHooks(child, domNode);\n\n      domNode.removeEventListener(transitionEnd, transitionEndHandler);\n\n      if (child.leaving) {\n        _this5.removeChildData(getKey(child));\n      }\n    };\n\n    domNode.addEventListener(transitionEnd, transitionEndHandler);\n  };\n\n  FlipMove.prototype.triggerFinishHooks = function triggerFinishHooks(child, domNode) {\n    var _this6 = this;\n\n    if (this.props.onFinish) this.props.onFinish(child, domNode);\n\n    // Reduce the number of children we need to animate by 1,\n    // so that we can tell when all children have finished.\n    this.remainingAnimations -= 1;\n\n    if (this.remainingAnimations === 0) {\n      // Remove any items from the DOM that have left, and reset `entering`.\n      var nextChildren = this.state.children.filter(function (_ref2) {\n        var leaving = _ref2.leaving;\n        return !leaving;\n      }).map(function (item) {\n        return _extends({}, item, {\n          // fix for Flow\n          element: item.element,\n          appearing: false,\n          entering: false\n        });\n      });\n\n      this.setState({ children: nextChildren }, function () {\n        if (typeof _this6.props.onFinishAll === 'function') {\n          _this6.callChildrenHook(_this6.props.onFinishAll);\n        }\n\n        // Reset our variables for the next iteration\n        _this6.childrenToAnimate = [];\n      });\n\n      // If the placeholder was holding the container open while elements were\n      // leaving, we we can now set its height to zero.\n      if (this.heightPlaceholderData.domNode) {\n        this.heightPlaceholderData.domNode.style.height = '0';\n      }\n    }\n  };\n\n  FlipMove.prototype.callChildrenHook = function callChildrenHook(hook) {\n    var _this7 = this;\n\n    var elements = [];\n    var domNodes = [];\n\n    this.childrenToAnimate.forEach(function (childKey) {\n      // If this was an exit animation, the child may no longer exist.\n      // If so, skip it.\n      var child = _this7.findChildByKey(childKey);\n\n      if (!child) {\n        return;\n      }\n\n      elements.push(child);\n\n      if (_this7.hasChildData(childKey)) {\n        domNodes.push(_this7.getChildData(childKey).domNode);\n      }\n    });\n\n    hook(elements, domNodes);\n  };\n\n  FlipMove.prototype.updateBoundingBoxCaches = function updateBoundingBoxCaches() {\n    var _this8 = this;\n\n    // This is the ONLY place that parentData and childrenData's\n    // bounding boxes are updated. They will be calculated at other times\n    // to be compared to this value, but it's important that the cache is\n    // updated once per update.\n    var parentDomNode = this.parentData.domNode;\n\n    if (!parentDomNode) {\n      return;\n    }\n\n    this.parentData.boundingBox = this.props.getPosition(parentDomNode);\n\n    // Splitting DOM reads and writes to be peformed in batches\n    var childrenBoundingBoxes = [];\n\n    this.state.children.forEach(function (child) {\n      var childKey = getKey(child);\n\n      // It is possible that a child does not have a `key` property;\n      // Ignore these children, they don't need to be moved.\n      if (!childKey) {\n        childrenBoundingBoxes.push(null);\n        return;\n      }\n\n      // In very rare circumstances, for reasons unknown, the ref is never\n      // populated for certain children. In this case, avoid doing this update.\n      // see: https://github.com/joshwcomeau/react-flip-move/pull/91\n      if (!_this8.hasChildData(childKey)) {\n        childrenBoundingBoxes.push(null);\n        return;\n      }\n\n      var childData = _this8.getChildData(childKey);\n\n      // If the child element returns null, we need to avoid trying to\n      // account for it\n      if (!childData.domNode || !child) {\n        childrenBoundingBoxes.push(null);\n        return;\n      }\n\n      childrenBoundingBoxes.push(getRelativeBoundingBox({\n        childDomNode: childData.domNode,\n        parentDomNode: parentDomNode,\n        getPosition: _this8.props.getPosition\n      }));\n    });\n\n    this.state.children.forEach(function (child, index) {\n      var childKey = getKey(child);\n\n      var childBoundingBox = childrenBoundingBoxes[index];\n\n      if (!childKey) {\n        return;\n      }\n\n      _this8.setChildData(childKey, {\n        boundingBox: childBoundingBox\n      });\n    });\n  };\n\n  FlipMove.prototype.computeInitialStyles = function computeInitialStyles(child) {\n    if (child.appearing) {\n      return this.props.appearAnimation ? this.props.appearAnimation.from : {};\n    } else if (child.entering) {\n      if (!this.props.enterAnimation) {\n        return {};\n      }\n      // If this child was in the middle of leaving, it still has its\n      // absolute positioning styles applied. We need to undo those.\n      return _extends({\n        position: '',\n        top: '',\n        left: '',\n        right: '',\n        bottom: ''\n      }, this.props.enterAnimation.from);\n    } else if (child.leaving) {\n      return this.props.leaveAnimation ? this.props.leaveAnimation.from : {};\n    }\n\n    var childData = this.getChildData(getKey(child));\n    var childDomNode = childData.domNode;\n    var childBoundingBox = childData.boundingBox;\n    var parentBoundingBox = this.parentData.boundingBox;\n\n    if (!childDomNode) {\n      return {};\n    }\n\n    var _getPositionDelta2 = getPositionDelta({\n      childDomNode: childDomNode,\n      childBoundingBox: childBoundingBox,\n      parentBoundingBox: parentBoundingBox,\n      getPosition: this.props.getPosition\n    }),\n        dX = _getPositionDelta2[0],\n        dY = _getPositionDelta2[1];\n\n    return {\n      transform: 'translate(' + dX + 'px, ' + dY + 'px)'\n    };\n  };\n\n  // eslint-disable-next-line class-methods-use-this\n\n\n  FlipMove.prototype.isAnimationDisabled = function isAnimationDisabled(props) {\n    // If the component is explicitly passed a `disableAllAnimations` flag,\n    // we can skip this whole process. Similarly, if all of the numbers have\n    // been set to 0, there is no point in trying to animate; doing so would\n    // only cause a flicker (and the intent is probably to disable animations)\n    // We can also skip this rigamarole if there's no browser support for it.\n    return noBrowserSupport || props.disableAllAnimations || props.duration === 0 && props.delay === 0 && props.staggerDurationBy === 0 && props.staggerDelayBy === 0;\n  };\n\n  FlipMove.prototype.findChildByKey = function findChildByKey(key) {\n    return find(function (child) {\n      return getKey(child) === key;\n    }, this.state.children);\n  };\n\n  FlipMove.prototype.hasChildData = function hasChildData(key) {\n    // Object has some built-in properties on its prototype, such as toString.  hasOwnProperty makes\n    // sure that key is present on childrenData itself, not on its prototype.\n    return Object.prototype.hasOwnProperty.call(this.childrenData, key);\n  };\n\n  FlipMove.prototype.getChildData = function getChildData(key) {\n    return this.hasChildData(key) ? this.childrenData[key] : {};\n  };\n\n  FlipMove.prototype.setChildData = function setChildData(key, data) {\n    this.childrenData[key] = _extends({}, this.getChildData(key), data);\n  };\n\n  FlipMove.prototype.removeChildData = function removeChildData(key) {\n    delete this.childrenData[key];\n    this.setState(function (prevState) {\n      return _extends({}, prevState, {\n        children: prevState.children.filter(function (child) {\n          return child.element.key !== key;\n        })\n      });\n    });\n  };\n\n  FlipMove.prototype.createHeightPlaceholder = function createHeightPlaceholder() {\n    var _this9 = this;\n\n    var typeName = this.props.typeName;\n\n    // If requested, create an invisible element at the end of the list.\n    // Its height will be modified to prevent the container from collapsing\n    // prematurely.\n\n    var isContainerAList = typeName === 'ul' || typeName === 'ol';\n    var placeholderType = isContainerAList ? 'li' : 'div';\n\n    return createElement(placeholderType, {\n      key: 'height-placeholder',\n      ref: function ref(domNode) {\n        _this9.heightPlaceholderData.domNode = domNode;\n      },\n      style: { visibility: 'hidden', height: 0 }\n    });\n  };\n\n  FlipMove.prototype.childrenWithRefs = function childrenWithRefs() {\n    var _this10 = this;\n\n    // We need to clone the provided children, capturing a reference to the\n    // underlying DOM node. Flip Move needs to use the React escape hatches to\n    // be able to do its calculations.\n    return this.state.children.map(function (child) {\n      return cloneElement(child.element, {\n        ref: function ref(element) {\n          // Functional Components without a forwarded ref are not supported by FlipMove,\n          // because they don't have instances.\n          if (!element) {\n            return;\n          }\n\n          var domNode = getNativeNode(element);\n          _this10.setChildData(getKey(child), { domNode: domNode });\n        }\n      });\n    });\n  };\n\n  FlipMove.prototype.render = function render() {\n    var _this11 = this;\n\n    var _props2 = this.props,\n        typeName = _props2.typeName,\n        delegated = _props2.delegated,\n        leaveAnimation = _props2.leaveAnimation,\n        maintainContainerHeight = _props2.maintainContainerHeight;\n\n\n    var children = this.childrenWithRefs();\n    if (leaveAnimation && maintainContainerHeight) {\n      children.push(this.createHeightPlaceholder());\n    }\n\n    if (!typeName) return children;\n\n    var props = _extends({}, delegated, {\n      children: children,\n      ref: function ref(node) {\n        _this11.parentData.domNode = node;\n      }\n    });\n\n    return createElement(typeName, props);\n  };\n\n  return FlipMove;\n}(Component);\n\nvar enhancedFlipMove = /* #__PURE__ */propConverter(FlipMove$1);\n\n/**\n * React Flip Move\n * (c) 2016-present Joshua Comeau\n */\n\nexport default enhancedFlipMove;\n"],"sourceRoot":""}