{"version":3,"sources":["webpack:///./node_modules/react-motion/lib/spring.js","webpack:///./node_modules/react-motion/lib/TransitionMotion.js","webpack:///./node_modules/react-motion/lib/mapToZero.js","webpack:///./node_modules/react-motion/lib/stripStyle.js","webpack:///./node_modules/react-motion/lib/stepper.js","webpack:///./node_modules/react-motion/lib/mergeDiff.js","webpack:///./node_modules/react-motion/node_modules/performance-now/lib/performance-now.js","webpack:///./node_modules/react-motion/lib/shouldStopAnimation.js","webpack:///./node_modules/react-motion/lib/presets.js"],"names":["exports","__esModule","_extends","Object","assign","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","val","config","defaultConfig","obj","_presets","_presets2","noWobble","precision","module","_createClass","defineProperties","props","descriptor","enumerable","configurable","writable","defineProperty","Constructor","protoProps","staticProps","_interopRequireDefault","_mapToZero2","_stripStyle2","_stepper4","_mergeDiff2","_performanceNow2","_raf2","_shouldStopAnimation2","_react2","_propTypes2","rehydrateStyles","mergedPropsStyles","unreadPropStyles","plainStyles","cUnreadPropStyles","map","mergedPropsStyle","data","style","j","mergeAndSync","willEnter","willLeave","didLeave","oldMergedPropsStyles","destStyles","oldCurrentStyles","oldCurrentVelocities","oldLastIdealStyles","oldLastIdealVelocities","newMergedPropsStyles","oldIndex","oldMergedPropsStyle","leavingStyle","newCurrentStyles","newCurrentVelocities","newLastIdealStyles","newLastIdealVelocities","newMergedPropsStyleCell","foundOldIndex","plainStyle","velocity","TransitionMotion","_React$Component","_this","this","instance","TypeError","_classCallCheck","unmounting","animationID","prevTime","accumulatedTime","clearUnreadPropStyle","_mergeAndSync","state","currentStyles","currentVelocities","lastIdealStyles","lastIdealVelocities","unreadPropStyle","dirty","styleValue","setState","startAnimationIfNecessary","timestamp","propStyles","styles","shouldStopAnimationAll","currentTime","timeDelta","currentFrameCompletion","Math","floor","framesToCatchUp","_mergeAndSync2","newMergedPropsStyle","newCurrentStyle","newCurrentVelocity","newLastIdealStyle","newLastIdealVelocity","newLastIdealStyleValue","newLastIdealVelocityValue","_stepper","stiffness","damping","_stepper2","nextIdealX","nextIdealV","defaultState","subClass","superClass","create","constructor","value","setPrototypeOf","__proto__","_inherits","defaultStyles","arrayOf","shape","string","isRequired","any","objectOf","number","oneOfType","func","object","children","styleThatEntered","_props","undefined","defaultStyleCell","s","_mergeAndSync3","componentDidMount","componentWillReceiveProps","componentWillUnmount","cancel","render","hydratedStyles","renderedChildren","Children","only","Component","ret","secondPerFrame","x","v","destX","k","b","newV","newX","abs","reusedTuple","prev","next","onRemove","prevKeyIndex","nextKeyIndex","fill","push","sort","a","nextOrderA","nextOrderB","prevOrderA","prevOrderB","pivot","getNanoSeconds","hrtime","loadTime","performance","now","process","hr","Date","getTime","currentStyle","currentVelocity","gentle","wobbly","stiff"],"mappings":"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","file":"npm.react-motion.c920b4ddeb9b68365139.js","sourcesContent":["'use strict';\n\nexports.__esModule = true;\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\nexports['default'] = spring;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _presets = require('./presets');\n\nvar _presets2 = _interopRequireDefault(_presets);\n\nvar defaultConfig = _extends({}, _presets2['default'].noWobble, {\n  precision: 0.01\n});\n\nfunction spring(val, config) {\n  return _extends({}, defaultConfig, config, { val: val });\n}\n\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\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\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\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 _mapToZero = require('./mapToZero');\n\nvar _mapToZero2 = _interopRequireDefault(_mapToZero);\n\nvar _stripStyle = require('./stripStyle');\n\nvar _stripStyle2 = _interopRequireDefault(_stripStyle);\n\nvar _stepper3 = require('./stepper');\n\nvar _stepper4 = _interopRequireDefault(_stepper3);\n\nvar _mergeDiff = require('./mergeDiff');\n\nvar _mergeDiff2 = _interopRequireDefault(_mergeDiff);\n\nvar _performanceNow = require('performance-now');\n\nvar _performanceNow2 = _interopRequireDefault(_performanceNow);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _shouldStopAnimation = require('./shouldStopAnimation');\n\nvar _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar msPerFrame = 1000 / 60;\n\n// the children function & (potential) styles function asks as param an\n// Array<TransitionPlainStyle>, where each TransitionPlainStyle is of the format\n// {key: string, data?: any, style: PlainStyle}. However, the way we keep\n// internal states doesn't contain such a data structure (check the state and\n// TransitionMotionState). So when children function and others ask for such\n// data we need to generate them on the fly by combining mergedPropsStyles and\n// currentStyles/lastIdealStyles\nfunction rehydrateStyles(mergedPropsStyles, unreadPropStyles, plainStyles) {\n  // Copy the value to a `const` so that Flow understands that the const won't\n  // change and will be non-nullable in the callback below.\n  var cUnreadPropStyles = unreadPropStyles;\n  if (cUnreadPropStyles == null) {\n    return mergedPropsStyles.map(function (mergedPropsStyle, i) {\n      return {\n        key: mergedPropsStyle.key,\n        data: mergedPropsStyle.data,\n        style: plainStyles[i]\n      };\n    });\n  }\n  return mergedPropsStyles.map(function (mergedPropsStyle, i) {\n    for (var j = 0; j < cUnreadPropStyles.length; j++) {\n      if (cUnreadPropStyles[j].key === mergedPropsStyle.key) {\n        return {\n          key: cUnreadPropStyles[j].key,\n          data: cUnreadPropStyles[j].data,\n          style: plainStyles[i]\n        };\n      }\n    }\n    return { key: mergedPropsStyle.key, data: mergedPropsStyle.data, style: plainStyles[i] };\n  });\n}\n\nfunction shouldStopAnimationAll(currentStyles, destStyles, currentVelocities, mergedPropsStyles) {\n  if (mergedPropsStyles.length !== destStyles.length) {\n    return false;\n  }\n\n  for (var i = 0; i < mergedPropsStyles.length; i++) {\n    if (mergedPropsStyles[i].key !== destStyles[i].key) {\n      return false;\n    }\n  }\n\n  // we have the invariant that mergedPropsStyles and\n  // currentStyles/currentVelocities/last* are synced in terms of cells, see\n  // mergeAndSync comment for more info\n  for (var i = 0; i < mergedPropsStyles.length; i++) {\n    if (!_shouldStopAnimation2['default'](currentStyles[i], destStyles[i].style, currentVelocities[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n// core key merging logic\n\n// things to do: say previously merged style is {a, b}, dest style (prop) is {b,\n// c}, previous current (interpolating) style is {a, b}\n// **invariant**: current[i] corresponds to merged[i] in terms of key\n\n// steps:\n// turn merged style into {a?, b, c}\n//    add c, value of c is destStyles.c\n//    maybe remove a, aka call willLeave(a), then merged is either {b, c} or {a, b, c}\n// turn current (interpolating) style from {a, b} into {a?, b, c}\n//    maybe remove a\n//    certainly add c, value of c is willEnter(c)\n// loop over merged and construct new current\n// dest doesn't change, that's owner's\nfunction mergeAndSync(willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldLastIdealStyles, oldLastIdealVelocities) {\n  var newMergedPropsStyles = _mergeDiff2['default'](oldMergedPropsStyles, destStyles, function (oldIndex, oldMergedPropsStyle) {\n    var leavingStyle = willLeave(oldMergedPropsStyle);\n    if (leavingStyle == null) {\n      didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n      return null;\n    }\n    if (_shouldStopAnimation2['default'](oldCurrentStyles[oldIndex], leavingStyle, oldCurrentVelocities[oldIndex])) {\n      didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n      return null;\n    }\n    return { key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data, style: leavingStyle };\n  });\n\n  var newCurrentStyles = [];\n  var newCurrentVelocities = [];\n  var newLastIdealStyles = [];\n  var newLastIdealVelocities = [];\n  for (var i = 0; i < newMergedPropsStyles.length; i++) {\n    var newMergedPropsStyleCell = newMergedPropsStyles[i];\n    var foundOldIndex = null;\n    for (var j = 0; j < oldMergedPropsStyles.length; j++) {\n      if (oldMergedPropsStyles[j].key === newMergedPropsStyleCell.key) {\n        foundOldIndex = j;\n        break;\n      }\n    }\n    // TODO: key search code\n    if (foundOldIndex == null) {\n      var plainStyle = willEnter(newMergedPropsStyleCell);\n      newCurrentStyles[i] = plainStyle;\n      newLastIdealStyles[i] = plainStyle;\n\n      var velocity = _mapToZero2['default'](newMergedPropsStyleCell.style);\n      newCurrentVelocities[i] = velocity;\n      newLastIdealVelocities[i] = velocity;\n    } else {\n      newCurrentStyles[i] = oldCurrentStyles[foundOldIndex];\n      newLastIdealStyles[i] = oldLastIdealStyles[foundOldIndex];\n      newCurrentVelocities[i] = oldCurrentVelocities[foundOldIndex];\n      newLastIdealVelocities[i] = oldLastIdealVelocities[foundOldIndex];\n    }\n  }\n\n  return [newMergedPropsStyles, newCurrentStyles, newCurrentVelocities, newLastIdealStyles, newLastIdealVelocities];\n}\n\nvar TransitionMotion = (function (_React$Component) {\n  _inherits(TransitionMotion, _React$Component);\n\n  _createClass(TransitionMotion, null, [{\n    key: 'propTypes',\n    value: {\n      defaultStyles: _propTypes2['default'].arrayOf(_propTypes2['default'].shape({\n        key: _propTypes2['default'].string.isRequired,\n        data: _propTypes2['default'].any,\n        style: _propTypes2['default'].objectOf(_propTypes2['default'].number).isRequired\n      })),\n      styles: _propTypes2['default'].oneOfType([_propTypes2['default'].func, _propTypes2['default'].arrayOf(_propTypes2['default'].shape({\n        key: _propTypes2['default'].string.isRequired,\n        data: _propTypes2['default'].any,\n        style: _propTypes2['default'].objectOf(_propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].object])).isRequired\n      }))]).isRequired,\n      children: _propTypes2['default'].func.isRequired,\n      willEnter: _propTypes2['default'].func,\n      willLeave: _propTypes2['default'].func,\n      didLeave: _propTypes2['default'].func\n    },\n    enumerable: true\n  }, {\n    key: 'defaultProps',\n    value: {\n      willEnter: function willEnter(styleThatEntered) {\n        return _stripStyle2['default'](styleThatEntered.style);\n      },\n      // recall: returning null makes the current unmounting TransitionStyle\n      // disappear immediately\n      willLeave: function willLeave() {\n        return null;\n      },\n      didLeave: function didLeave() {}\n    },\n    enumerable: true\n  }]);\n\n  function TransitionMotion(props) {\n    var _this = this;\n\n    _classCallCheck(this, TransitionMotion);\n\n    _React$Component.call(this, props);\n    this.unmounting = false;\n    this.animationID = null;\n    this.prevTime = 0;\n    this.accumulatedTime = 0;\n    this.unreadPropStyles = null;\n\n    this.clearUnreadPropStyle = function (unreadPropStyles) {\n      var _mergeAndSync = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, unreadPropStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities);\n\n      var mergedPropsStyles = _mergeAndSync[0];\n      var currentStyles = _mergeAndSync[1];\n      var currentVelocities = _mergeAndSync[2];\n      var lastIdealStyles = _mergeAndSync[3];\n      var lastIdealVelocities = _mergeAndSync[4];\n\n      for (var i = 0; i < unreadPropStyles.length; i++) {\n        var unreadPropStyle = unreadPropStyles[i].style;\n        var dirty = false;\n\n        for (var key in unreadPropStyle) {\n          if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) {\n            continue;\n          }\n\n          var styleValue = unreadPropStyle[key];\n          if (typeof styleValue === 'number') {\n            if (!dirty) {\n              dirty = true;\n              currentStyles[i] = _extends({}, currentStyles[i]);\n              currentVelocities[i] = _extends({}, currentVelocities[i]);\n              lastIdealStyles[i] = _extends({}, lastIdealStyles[i]);\n              lastIdealVelocities[i] = _extends({}, lastIdealVelocities[i]);\n              mergedPropsStyles[i] = {\n                key: mergedPropsStyles[i].key,\n                data: mergedPropsStyles[i].data,\n                style: _extends({}, mergedPropsStyles[i].style)\n              };\n            }\n            currentStyles[i][key] = styleValue;\n            currentVelocities[i][key] = 0;\n            lastIdealStyles[i][key] = styleValue;\n            lastIdealVelocities[i][key] = 0;\n            mergedPropsStyles[i].style[key] = styleValue;\n          }\n        }\n      }\n\n      // unlike the other 2 components, we can't detect staleness and optionally\n      // opt out of setState here. each style object's data might contain new\n      // stuff we're not/cannot compare\n      _this.setState({\n        currentStyles: currentStyles,\n        currentVelocities: currentVelocities,\n        mergedPropsStyles: mergedPropsStyles,\n        lastIdealStyles: lastIdealStyles,\n        lastIdealVelocities: lastIdealVelocities\n      });\n    };\n\n    this.startAnimationIfNecessary = function () {\n      if (_this.unmounting) {\n        return;\n      }\n\n      // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and\n      // call cb? No, otherwise accidental parent rerender causes cb trigger\n      _this.animationID = _raf2['default'](function (timestamp) {\n        // https://github.com/chenglou/react-motion/pull/420\n        // > if execution passes the conditional if (this.unmounting), then\n        // executes async defaultRaf and after that component unmounts and after\n        // that the callback of defaultRaf is called, then setState will be called\n        // on unmounted component.\n        if (_this.unmounting) {\n          return;\n        }\n\n        var propStyles = _this.props.styles;\n        var destStyles = typeof propStyles === 'function' ? propStyles(rehydrateStyles(_this.state.mergedPropsStyles, _this.unreadPropStyles, _this.state.lastIdealStyles)) : propStyles;\n\n        // check if we need to animate in the first place\n        if (shouldStopAnimationAll(_this.state.currentStyles, destStyles, _this.state.currentVelocities, _this.state.mergedPropsStyles)) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.accumulatedTime = 0;\n          return;\n        }\n\n        var currentTime = timestamp || _performanceNow2['default']();\n        var timeDelta = currentTime - _this.prevTime;\n        _this.prevTime = currentTime;\n        _this.accumulatedTime = _this.accumulatedTime + timeDelta;\n        // more than 10 frames? prolly switched browser tab. Restart\n        if (_this.accumulatedTime > msPerFrame * 10) {\n          _this.accumulatedTime = 0;\n        }\n\n        if (_this.accumulatedTime === 0) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.startAnimationIfNecessary();\n          return;\n        }\n\n        var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n        var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame);\n\n        var _mergeAndSync2 = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, destStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities);\n\n        var newMergedPropsStyles = _mergeAndSync2[0];\n        var newCurrentStyles = _mergeAndSync2[1];\n        var newCurrentVelocities = _mergeAndSync2[2];\n        var newLastIdealStyles = _mergeAndSync2[3];\n        var newLastIdealVelocities = _mergeAndSync2[4];\n\n        for (var i = 0; i < newMergedPropsStyles.length; i++) {\n          var newMergedPropsStyle = newMergedPropsStyles[i].style;\n          var newCurrentStyle = {};\n          var newCurrentVelocity = {};\n          var newLastIdealStyle = {};\n          var newLastIdealVelocity = {};\n\n          for (var key in newMergedPropsStyle) {\n            if (!Object.prototype.hasOwnProperty.call(newMergedPropsStyle, key)) {\n              continue;\n            }\n\n            var styleValue = newMergedPropsStyle[key];\n            if (typeof styleValue === 'number') {\n              newCurrentStyle[key] = styleValue;\n              newCurrentVelocity[key] = 0;\n              newLastIdealStyle[key] = styleValue;\n              newLastIdealVelocity[key] = 0;\n            } else {\n              var newLastIdealStyleValue = newLastIdealStyles[i][key];\n              var newLastIdealVelocityValue = newLastIdealVelocities[i][key];\n              for (var j = 0; j < framesToCatchUp; j++) {\n                var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n                newLastIdealStyleValue = _stepper[0];\n                newLastIdealVelocityValue = _stepper[1];\n              }\n\n              var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n              var nextIdealX = _stepper2[0];\n              var nextIdealV = _stepper2[1];\n\n              newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n              newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n              newLastIdealStyle[key] = newLastIdealStyleValue;\n              newLastIdealVelocity[key] = newLastIdealVelocityValue;\n            }\n          }\n\n          newLastIdealStyles[i] = newLastIdealStyle;\n          newLastIdealVelocities[i] = newLastIdealVelocity;\n          newCurrentStyles[i] = newCurrentStyle;\n          newCurrentVelocities[i] = newCurrentVelocity;\n        }\n\n        _this.animationID = null;\n        // the amount we're looped over above\n        _this.accumulatedTime -= framesToCatchUp * msPerFrame;\n\n        _this.setState({\n          currentStyles: newCurrentStyles,\n          currentVelocities: newCurrentVelocities,\n          lastIdealStyles: newLastIdealStyles,\n          lastIdealVelocities: newLastIdealVelocities,\n          mergedPropsStyles: newMergedPropsStyles\n        });\n\n        _this.unreadPropStyles = null;\n\n        _this.startAnimationIfNecessary();\n      });\n    };\n\n    this.state = this.defaultState();\n  }\n\n  TransitionMotion.prototype.defaultState = function defaultState() {\n    var _props = this.props;\n    var defaultStyles = _props.defaultStyles;\n    var styles = _props.styles;\n    var willEnter = _props.willEnter;\n    var willLeave = _props.willLeave;\n    var didLeave = _props.didLeave;\n\n    var destStyles = typeof styles === 'function' ? styles(defaultStyles) : styles;\n\n    // this is special. for the first time around, we don't have a comparison\n    // between last (no last) and current merged props. we'll compute last so:\n    // say default is {a, b} and styles (dest style) is {b, c}, we'll\n    // fabricate last as {a, b}\n    var oldMergedPropsStyles = undefined;\n    if (defaultStyles == null) {\n      oldMergedPropsStyles = destStyles;\n    } else {\n      oldMergedPropsStyles = defaultStyles.map(function (defaultStyleCell) {\n        // TODO: key search code\n        for (var i = 0; i < destStyles.length; i++) {\n          if (destStyles[i].key === defaultStyleCell.key) {\n            return destStyles[i];\n          }\n        }\n        return defaultStyleCell;\n      });\n    }\n    var oldCurrentStyles = defaultStyles == null ? destStyles.map(function (s) {\n      return _stripStyle2['default'](s.style);\n    }) : defaultStyles.map(function (s) {\n      return _stripStyle2['default'](s.style);\n    });\n    var oldCurrentVelocities = defaultStyles == null ? destStyles.map(function (s) {\n      return _mapToZero2['default'](s.style);\n    }) : defaultStyles.map(function (s) {\n      return _mapToZero2['default'](s.style);\n    });\n\n    var _mergeAndSync3 = mergeAndSync(\n    // Because this is an old-style createReactClass component, Flow doesn't\n    // understand that the willEnter and willLeave props have default values\n    // and will always be present.\n    willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldCurrentStyles, // oldLastIdealStyles really\n    oldCurrentVelocities);\n\n    var mergedPropsStyles = _mergeAndSync3[0];\n    var currentStyles = _mergeAndSync3[1];\n    var currentVelocities = _mergeAndSync3[2];\n    var lastIdealStyles = _mergeAndSync3[3];\n    var lastIdealVelocities = _mergeAndSync3[4];\n    // oldLastIdealVelocities really\n\n    return {\n      currentStyles: currentStyles,\n      currentVelocities: currentVelocities,\n      lastIdealStyles: lastIdealStyles,\n      lastIdealVelocities: lastIdealVelocities,\n      mergedPropsStyles: mergedPropsStyles\n    };\n  };\n\n  // after checking for unreadPropStyles != null, we manually go set the\n  // non-interpolating values (those that are a number, without a spring\n  // config)\n\n  TransitionMotion.prototype.componentDidMount = function componentDidMount() {\n    this.prevTime = _performanceNow2['default']();\n    this.startAnimationIfNecessary();\n  };\n\n  TransitionMotion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) {\n    if (this.unreadPropStyles) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyles);\n    }\n\n    var styles = props.styles;\n    if (typeof styles === 'function') {\n      this.unreadPropStyles = styles(rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.lastIdealStyles));\n    } else {\n      this.unreadPropStyles = styles;\n    }\n\n    if (this.animationID == null) {\n      this.prevTime = _performanceNow2['default']();\n      this.startAnimationIfNecessary();\n    }\n  };\n\n  TransitionMotion.prototype.componentWillUnmount = function componentWillUnmount() {\n    this.unmounting = true;\n    if (this.animationID != null) {\n      _raf2['default'].cancel(this.animationID);\n      this.animationID = null;\n    }\n  };\n\n  TransitionMotion.prototype.render = function render() {\n    var hydratedStyles = rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.currentStyles);\n    var renderedChildren = this.props.children(hydratedStyles);\n    return renderedChildren && _react2['default'].Children.only(renderedChildren);\n  };\n\n  return TransitionMotion;\n})(_react2['default'].Component);\n\nexports['default'] = TransitionMotion;\nmodule.exports = exports['default'];\n\n// list of styles, each containing interpolating values. Part of what's passed\n// to children function. Notice that this is\n// Array<ActualInterpolatingStyleObject>, without the wrapper that is {key: ...,\n// data: ... style: ActualInterpolatingStyleObject}. Only mergedPropsStyles\n// contains the key & data info (so that we only have a single source of truth\n// for these, and to save space). Check the comment for `rehydrateStyles` to\n// see how we regenerate the entirety of what's passed to children function\n\n// the array that keeps track of currently rendered stuff! Including stuff\n// that you've unmounted but that's still animating. This is where it lives\n\n// it's possible that currentStyle's value is stale: if props is immediately\n// changed from 0 to 400 to spring(0) again, the async currentStyle is still\n// at 0 (didn't have time to tick and interpolate even once). If we naively\n// compare currentStyle with destVal it'll be 0 === 0 (no animation, stop).\n// In reality currentStyle should be 400","\n\n// currently used to initiate the velocity style object to 0\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = mapToZero;\n\nfunction mapToZero(obj) {\n  var ret = {};\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      ret[key] = 0;\n    }\n  }\n  return ret;\n}\n\nmodule.exports = exports['default'];","\n// turn {x: {val: 1, stiffness: 1, damping: 2}, y: 2} generated by\n// `{x: spring(1, {stiffness: 1, damping: 2}), y: 2}` into {x: 1, y: 2}\n\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = stripStyle;\n\nfunction stripStyle(style) {\n  var ret = {};\n  for (var key in style) {\n    if (!Object.prototype.hasOwnProperty.call(style, key)) {\n      continue;\n    }\n    ret[key] = typeof style[key] === 'number' ? style[key] : style[key].val;\n  }\n  return ret;\n}\n\nmodule.exports = exports['default'];","\n\n// stepper is used a lot. Saves allocation to return the same array wrapper.\n// This is fine and danger-free against mutations because the callsite\n// immediately destructures it and gets the numbers inside without passing the\n\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = stepper;\n\nvar reusedTuple = [0, 0];\n\nfunction stepper(secondPerFrame, x, v, destX, k, b, precision) {\n  // Spring stiffness, in kg / s^2\n\n  // for animations, destX is really spring length (spring at rest). initial\n  // position is considered as the stretched/compressed position of a spring\n  var Fspring = -k * (x - destX);\n\n  // Damping, in kg / s\n  var Fdamper = -b * v;\n\n  // usually we put mass here, but for animation purposes, specifying mass is a\n  // bit redundant. you could simply adjust k and b accordingly\n  // let a = (Fspring + Fdamper) / mass;\n  var a = Fspring + Fdamper;\n\n  var newV = v + a * secondPerFrame;\n  var newX = x + newV * secondPerFrame;\n\n  if (Math.abs(newV) < precision && Math.abs(newX - destX) < precision) {\n    reusedTuple[0] = destX;\n    reusedTuple[1] = 0;\n    return reusedTuple;\n  }\n\n  reusedTuple[0] = newX;\n  reusedTuple[1] = newV;\n  return reusedTuple;\n}\n\nmodule.exports = exports[\"default\"];\n// array reference around.","\n\n// core keys merging algorithm. If previous render's keys are [a, b], and the\n// next render's [c, b, d], what's the final merged keys and ordering?\n\n// - c and a must both be before b\n// - b before d\n// - ordering between a and c ambiguous\n\n// this reduces to merging two partially ordered lists (e.g. lists where not\n// every item has a definite ordering, like comparing a and c above). For the\n// ambiguous ordering we deterministically choose to place the next render's\n// item after the previous'; so c after a\n\n// this is called a topological sorting. Except the existing algorithms don't\n// work well with js bc of the amount of allocation, and isn't optimized for our\n// current use-case bc the runtime is linear in terms of edges (see wiki for\n// meaning), which is huge when two lists have many common elements\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = mergeDiff;\n\nfunction mergeDiff(prev, next, onRemove) {\n  // bookkeeping for easier access of a key's index below. This is 2 allocations +\n  // potentially triggering chrome hash map mode for objs (so it might be faster\n\n  var prevKeyIndex = {};\n  for (var i = 0; i < prev.length; i++) {\n    prevKeyIndex[prev[i].key] = i;\n  }\n  var nextKeyIndex = {};\n  for (var i = 0; i < next.length; i++) {\n    nextKeyIndex[next[i].key] = i;\n  }\n\n  // first, an overly elaborate way of merging prev and next, eliminating\n  // duplicates (in terms of keys). If there's dupe, keep the item in next).\n  // This way of writing it saves allocations\n  var ret = [];\n  for (var i = 0; i < next.length; i++) {\n    ret[i] = next[i];\n  }\n  for (var i = 0; i < prev.length; i++) {\n    if (!Object.prototype.hasOwnProperty.call(nextKeyIndex, prev[i].key)) {\n      // this is called my TM's `mergeAndSync`, which calls willLeave. We don't\n      // merge in keys that the user desires to kill\n      var fill = onRemove(i, prev[i]);\n      if (fill != null) {\n        ret.push(fill);\n      }\n    }\n  }\n\n  // now all the items all present. Core sorting logic to have the right order\n  return ret.sort(function (a, b) {\n    var nextOrderA = nextKeyIndex[a.key];\n    var nextOrderB = nextKeyIndex[b.key];\n    var prevOrderA = prevKeyIndex[a.key];\n    var prevOrderB = prevKeyIndex[b.key];\n\n    if (nextOrderA != null && nextOrderB != null) {\n      // both keys in next\n      return nextKeyIndex[a.key] - nextKeyIndex[b.key];\n    } else if (prevOrderA != null && prevOrderB != null) {\n      // both keys in prev\n      return prevKeyIndex[a.key] - prevKeyIndex[b.key];\n    } else if (nextOrderA != null) {\n      // key a in next, key b in prev\n\n      // how to determine the order between a and b? We find a \"pivot\" (term\n      // abuse), a key present in both prev and next, that is sandwiched between\n      // a and b. In the context of our above example, if we're comparing a and\n      // d, b's (the only) pivot\n      for (var i = 0; i < next.length; i++) {\n        var pivot = next[i].key;\n        if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) {\n          continue;\n        }\n\n        if (nextOrderA < nextKeyIndex[pivot] && prevOrderB > prevKeyIndex[pivot]) {\n          return -1;\n        } else if (nextOrderA > nextKeyIndex[pivot] && prevOrderB < prevKeyIndex[pivot]) {\n          return 1;\n        }\n      }\n      // pluggable. default to: next bigger than prev\n      return 1;\n    }\n    // prevOrderA, nextOrderB\n    for (var i = 0; i < next.length; i++) {\n      var pivot = next[i].key;\n      if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) {\n        continue;\n      }\n      if (nextOrderB < nextKeyIndex[pivot] && prevOrderA > prevKeyIndex[pivot]) {\n        return 1;\n      } else if (nextOrderB > nextKeyIndex[pivot] && prevOrderA < prevKeyIndex[pivot]) {\n        return -1;\n      }\n    }\n    // pluggable. default to: next bigger than prev\n    return -1;\n  });\n}\n\nmodule.exports = exports['default'];\n// to loop through and find a key's index each time), but I no longer care","// Generated by CoffeeScript 1.7.1\n(function() {\n  var getNanoSeconds, hrtime, loadTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - loadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    loadTime = getNanoSeconds();\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n","\n\n// usage assumption: currentStyle values have already been rendered but it says\n// nothing of whether currentStyle is stale (see unreadPropStyle)\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = shouldStopAnimation;\n\nfunction shouldStopAnimation(currentStyle, style, currentVelocity) {\n  for (var key in style) {\n    if (!Object.prototype.hasOwnProperty.call(style, key)) {\n      continue;\n    }\n\n    if (currentVelocity[key] !== 0) {\n      return false;\n    }\n\n    var styleValue = typeof style[key] === 'number' ? style[key] : style[key].val;\n    // stepper will have already taken care of rounding precision errors, so\n    // won't have such thing as 0.9999 !=== 1\n    if (currentStyle[key] !== styleValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = exports['default'];","\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = {\n  noWobble: { stiffness: 170, damping: 26 }, // the default, if nothing provided\n  gentle: { stiffness: 120, damping: 14 },\n  wobbly: { stiffness: 180, damping: 12 },\n  stiff: { stiffness: 210, damping: 20 }\n};\nmodule.exports = exports[\"default\"];"],"sourceRoot":""}