{"version":3,"sources":["jsdelivr-header.js","webpack:///webpack/universalModuleDefinition","/npm/react-motion@0.5.2/build/webpack:/webpack/bootstrap f6a4e026674f2438019d","webpack:///src/react-motion.js","webpack:///src/Motion.js","webpack:///src/mapToZero.js","webpack:///src/stripStyle.js","webpack:///src/stepper.js","webpack:///~/performance-now/lib/performance-now.js","webpack:///~/process/browser.js","webpack:///~/raf/index.js","webpack:///~/raf/~/performance-now/lib/performance-now.js","webpack:///src/shouldStopAnimation.js","/npm/react-motion@0.5.2/build/webpack:/external {\"root\":\"React\",\"commonjs2\":\"react\",\"commonjs\":\"react\",\"amd\":\"react\"}","webpack:///~/prop-types/index.js","webpack:///~/prop-types/factoryWithTypeCheckers.js","webpack:///~/fbjs/lib/emptyFunction.js","webpack:///~/fbjs/lib/invariant.js","webpack:///~/fbjs/lib/warning.js","webpack:///~/object-assign/index.js","webpack:///~/prop-types/lib/ReactPropTypesSecret.js","webpack:///~/prop-types/checkPropTypes.js","webpack:///~/prop-types/factoryWithThrowingShims.js","webpack:///src/StaggeredMotion.js","webpack:///src/TransitionMotion.js","webpack:///src/mergeDiff.js","webpack:///src/spring.js","webpack:///src/presets.js","webpack:///src/reorderKeys.js"],"names":[],"mappings":"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","file":"/npm/react-motion@0.5.2/build/react-motion.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/react-motion@0.5.2/build/react-motion.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactMotion\"] = factory(require(\"react\"));\n\telse\n\t\troot[\"ReactMotion\"] = factory(root[\"React\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_10__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition",null,"/* @flow */\nexport {default as Motion} from './Motion';\nexport {default as StaggeredMotion} from './StaggeredMotion';\nexport {default as TransitionMotion} from './TransitionMotion';\nexport {default as spring} from './spring';\nexport {default as presets} from './presets';\nexport {default as stripStyle} from './stripStyle';\n\n// deprecated, dummy warning function\nexport {default as reorderKeys} from './reorderKeys';\n\n\n\n// WEBPACK FOOTER //\n// ./src/react-motion.js","/* @flow */\nimport mapToZero from './mapToZero';\nimport stripStyle from './stripStyle';\nimport stepper from './stepper';\nimport defaultNow from 'performance-now';\nimport defaultRaf from 'raf';\nimport shouldStopAnimation from './shouldStopAnimation';\nimport React from 'react';\nimport PropTypes from 'prop-types';\n\nimport type {ReactElement, PlainStyle, Style, Velocity, MotionProps} from './Types';\n\nconst msPerFrame = 1000 / 60;\n\ntype MotionState = {\n  currentStyle: PlainStyle,\n  currentVelocity: Velocity,\n  lastIdealStyle: PlainStyle,\n  lastIdealVelocity: Velocity,\n};\n\nexport default class Motion extends React.Component<MotionProps, MotionState> {\n  static propTypes = {\n    // TOOD: warn against putting a config in here\n    defaultStyle: PropTypes.objectOf(PropTypes.number),\n    style: PropTypes.objectOf(PropTypes.oneOfType([\n      PropTypes.number,\n      PropTypes.object,\n    ])).isRequired,\n    children: PropTypes.func.isRequired,\n    onRest: PropTypes.func,\n  };\n\n  constructor(props: MotionProps) {\n    super(props);\n    this.state = this.defaultState();\n  }\n\n  wasAnimating: boolean = false;\n  animationID: ?number = null;\n  prevTime: number = 0;\n  accumulatedTime: number = 0;\n\n  defaultState(): MotionState {\n    const {defaultStyle, style} = this.props;\n    const currentStyle = defaultStyle || stripStyle(style);\n    const currentVelocity = mapToZero(currentStyle);\n    return {\n      currentStyle,\n      currentVelocity,\n      lastIdealStyle: currentStyle,\n      lastIdealVelocity: currentVelocity,\n    };\n  }\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  unreadPropStyle: ?Style = null;\n  // after checking for unreadPropStyle != null, we manually go set the\n  // non-interpolating values (those that are a number, without a spring\n  // config)\n  clearUnreadPropStyle = (destStyle: Style): void => {\n    let dirty = false;\n    let {currentStyle, currentVelocity, lastIdealStyle, lastIdealVelocity} = this.state;\n\n    for (let key in destStyle) {\n      if (!Object.prototype.hasOwnProperty.call(destStyle, key)) {\n        continue;\n      }\n\n      const styleValue = destStyle[key];\n      if (typeof styleValue === 'number') {\n        if (!dirty) {\n          dirty = true;\n          currentStyle = {...currentStyle};\n          currentVelocity = {...currentVelocity};\n          lastIdealStyle = {...lastIdealStyle};\n          lastIdealVelocity = {...lastIdealVelocity};\n        }\n\n        currentStyle[key] = styleValue;\n        currentVelocity[key] = 0;\n        lastIdealStyle[key] = styleValue;\n        lastIdealVelocity[key] = 0;\n      }\n    }\n\n    if (dirty) {\n      this.setState({currentStyle, currentVelocity, lastIdealStyle, lastIdealVelocity});\n    }\n  };\n\n  startAnimationIfNecessary = (): void => {\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 = defaultRaf((timestamp) => {\n      // check if we need to animate in the first place\n      const propsStyle: Style = this.props.style;\n      if (shouldStopAnimation(\n        this.state.currentStyle,\n        propsStyle,\n        this.state.currentVelocity,\n      )) {\n        if (this.wasAnimating && this.props.onRest) {\n          this.props.onRest();\n        }\n\n        // no need to cancel animationID here; shouldn't have any in flight\n        this.animationID = null;\n        this.wasAnimating = false;\n        this.accumulatedTime = 0;\n        return;\n      }\n\n      this.wasAnimating = true;\n\n      const currentTime = timestamp || defaultNow();\n      const 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      let currentFrameCompletion =\n        (this.accumulatedTime - Math.floor(this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n      const framesToCatchUp = Math.floor(this.accumulatedTime / msPerFrame);\n\n      let newLastIdealStyle: PlainStyle = {};\n      let newLastIdealVelocity: Velocity = {};\n      let newCurrentStyle: PlainStyle = {};\n      let newCurrentVelocity: Velocity = {};\n\n      for (let key in propsStyle) {\n        if (!Object.prototype.hasOwnProperty.call(propsStyle, key)) {\n          continue;\n        }\n\n        const styleValue = propsStyle[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          let newLastIdealStyleValue = this.state.lastIdealStyle[key];\n          let newLastIdealVelocityValue = this.state.lastIdealVelocity[key];\n          for (let i = 0; i < framesToCatchUp; i++) {\n            [newLastIdealStyleValue, newLastIdealVelocityValue] = stepper(\n              msPerFrame / 1000,\n              newLastIdealStyleValue,\n              newLastIdealVelocityValue,\n              styleValue.val,\n              styleValue.stiffness,\n              styleValue.damping,\n              styleValue.precision,\n            );\n          }\n          const [nextIdealX, nextIdealV] = stepper(\n            msPerFrame / 1000,\n            newLastIdealStyleValue,\n            newLastIdealVelocityValue,\n            styleValue.val,\n            styleValue.stiffness,\n            styleValue.damping,\n            styleValue.precision,\n          );\n\n          newCurrentStyle[key] =\n            newLastIdealStyleValue +\n            (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n          newCurrentVelocity[key] =\n            newLastIdealVelocityValue +\n            (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n          newLastIdealStyle[key] = newLastIdealStyleValue;\n          newLastIdealVelocity[key] = newLastIdealVelocityValue;\n        }\n      }\n\n      this.animationID = null;\n      // the amount we're looped over above\n      this.accumulatedTime -= framesToCatchUp * msPerFrame;\n\n      this.setState({\n        currentStyle: newCurrentStyle,\n        currentVelocity: newCurrentVelocity,\n        lastIdealStyle: newLastIdealStyle,\n        lastIdealVelocity: newLastIdealVelocity,\n      });\n\n      this.unreadPropStyle = null;\n\n      this.startAnimationIfNecessary();\n    });\n  };\n\n  componentDidMount() {\n    this.prevTime = defaultNow();\n    this.startAnimationIfNecessary();\n  }\n\n  componentWillReceiveProps(props: MotionProps) {\n    if (this.unreadPropStyle != null) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyle);\n    }\n\n    this.unreadPropStyle = props.style;\n    if (this.animationID == null) {\n      this.prevTime = defaultNow();\n      this.startAnimationIfNecessary();\n    }\n  }\n\n  componentWillUnmount() {\n    if (this.animationID != null) {\n      defaultRaf.cancel(this.animationID);\n      this.animationID = null;\n    }\n  }\n\n  render(): ReactElement {\n    const renderedChildren = this.props.children(this.state.currentStyle);\n    return renderedChildren && React.Children.only(renderedChildren);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/Motion.js","/* @flow */\nimport type {PlainStyle, Style} from './Types';\n\n// currently used to initiate the velocity style object to 0\nexport default function mapToZero(obj: Style | PlainStyle): PlainStyle {\n  let ret = {};\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      ret[key] = 0;\n    }\n  }\n  return ret;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/mapToZero.js","/* @flow */\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\nimport type {Style, PlainStyle} from './Types';\n\nexport default function stripStyle(style: Style): PlainStyle {\n  let ret = {};\n  for (const 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\n\n\n// WEBPACK FOOTER //\n// ./src/stripStyle.js","/* @flow */\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// array reference around.\nlet reusedTuple: [number, number] = [0, 0];\nexport default function stepper(\n  secondPerFrame: number,\n  x: number,\n  v: number,\n  destX: number,\n  k: number,\n  b: number,\n  precision: number): [number, number] {\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  const Fspring = -k * (x - destX);\n\n  // Damping, in kg / s\n  const 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  const a = Fspring + Fdamper;\n\n  const newV = v + a * secondPerFrame;\n  const 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\n\n\n// WEBPACK FOOTER //\n// ./src/stepper.js","// 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\n// WEBPACK FOOTER //\n// ./~/performance-now/lib/performance-now.js","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n// WEBPACK FOOTER //\n// ./~/process/browser.js","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n\n\n\n// WEBPACK FOOTER //\n// ./~/raf/index.js","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\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() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\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//# sourceMappingURL=performance-now.js.map\n\n\n\n// WEBPACK FOOTER //\n// ./~/raf/~/performance-now/lib/performance-now.js","/* @flow */\nimport type {PlainStyle, Style, Velocity} from './Types';\n\n// usage assumption: currentStyle values have already been rendered but it says\n// nothing of whether currentStyle is stale (see unreadPropStyle)\nexport default function shouldStopAnimation(\n  currentStyle: PlainStyle,\n  style: Style,\n  currentVelocity: Velocity,\n): boolean {\n  for (let 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    const styleValue = typeof style[key] === 'number'\n      ? style[key]\n      : 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\n\n\n// WEBPACK FOOTER //\n// ./src/shouldStopAnimation.js",null,"/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\n    Symbol.for &&\n    Symbol.for('react.element')) ||\n    0xeac7;\n\n  var isValidElement = function(object) {\n    return typeof object === 'object' &&\n      object !== null &&\n      object.$$typeof === REACT_ELEMENT_TYPE;\n  };\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n\n\n\n// WEBPACK FOOTER //\n// ./~/prop-types/index.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\nvar assign = require('object-assign');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar checkPropTypes = require('./checkPropTypes');\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n  /* global Symbol */\n  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n  /**\n   * Returns the iterator method function contained on the iterable object.\n   *\n   * Be sure to invoke the function with the iterable as context:\n   *\n   *     var iteratorFn = getIteratorFn(myIterable);\n   *     if (iteratorFn) {\n   *       var iterator = iteratorFn.call(myIterable);\n   *       ...\n   *     }\n   *\n   * @param {?object} maybeIterable\n   * @return {?function}\n   */\n  function getIteratorFn(maybeIterable) {\n    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  /**\n   * Collection of methods that allow declaration and validation of props that are\n   * supplied to React components. Example usage:\n   *\n   *   var Props = require('ReactPropTypes');\n   *   var MyArticle = React.createClass({\n   *     propTypes: {\n   *       // An optional string prop named \"description\".\n   *       description: Props.string,\n   *\n   *       // A required enum prop named \"category\".\n   *       category: Props.oneOf(['News','Photos']).isRequired,\n   *\n   *       // A prop named \"dialog\" that requires an instance of Dialog.\n   *       dialog: Props.instanceOf(Dialog).isRequired\n   *     },\n   *     render: function() { ... }\n   *   });\n   *\n   * A more formal specification of how these methods are used:\n   *\n   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n   *   decl := ReactPropTypes.{type}(.isRequired)?\n   *\n   * Each and every declaration produces a function with the same signature. This\n   * allows the creation of custom validation functions. For example:\n   *\n   *  var MyLink = React.createClass({\n   *    propTypes: {\n   *      // An optional string or URI prop named \"href\".\n   *      href: function(props, propName, componentName) {\n   *        var propValue = props[propName];\n   *        if (propValue != null && typeof propValue !== 'string' &&\n   *            !(propValue instanceof URI)) {\n   *          return new Error(\n   *            'Expected a string or an URI for ' + propName + ' in ' +\n   *            componentName\n   *          );\n   *        }\n   *      }\n   *    },\n   *    render: function() {...}\n   *  });\n   *\n   * @internal\n   */\n\n  var ANONYMOUS = '<<anonymous>>';\n\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n  var ReactPropTypes = {\n    array: createPrimitiveTypeChecker('array'),\n    bool: createPrimitiveTypeChecker('boolean'),\n    func: createPrimitiveTypeChecker('function'),\n    number: createPrimitiveTypeChecker('number'),\n    object: createPrimitiveTypeChecker('object'),\n    string: createPrimitiveTypeChecker('string'),\n    symbol: createPrimitiveTypeChecker('symbol'),\n\n    any: createAnyTypeChecker(),\n    arrayOf: createArrayOfTypeChecker,\n    element: createElementTypeChecker(),\n    instanceOf: createInstanceTypeChecker,\n    node: createNodeChecker(),\n    objectOf: createObjectOfTypeChecker,\n    oneOf: createEnumTypeChecker,\n    oneOfType: createUnionTypeChecker,\n    shape: createShapeTypeChecker,\n    exact: createStrictShapeTypeChecker,\n  };\n\n  /**\n   * inlined Object.is polyfill to avoid requiring consumers ship their own\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n   */\n  /*eslint-disable no-self-compare*/\n  function is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n      // Steps 1-5, 7-10\n      // Steps 6.b-6.e: +0 != -0\n      return x !== 0 || 1 / x === 1 / y;\n    } else {\n      // Step 6.a: NaN == NaN\n      return x !== x && y !== y;\n    }\n  }\n  /*eslint-enable no-self-compare*/\n\n  /**\n   * We use an Error-like object for backward compatibility as people may call\n   * PropTypes directly and inspect their output. However, we don't use real\n   * Errors anymore. We don't inspect their stack anyway, and creating them\n   * is prohibitively expensive if they are created too often, such as what\n   * happens in oneOfType() for any type before the one that matched.\n   */\n  function PropTypeError(message) {\n    this.message = message;\n    this.stack = '';\n  }\n  // Make `instanceof Error` still work for returned errors.\n  PropTypeError.prototype = Error.prototype;\n\n  function createChainableTypeChecker(validate) {\n    if (process.env.NODE_ENV !== 'production') {\n      var manualPropTypeCallCache = {};\n      var manualPropTypeWarningCount = 0;\n    }\n    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n      componentName = componentName || ANONYMOUS;\n      propFullName = propFullName || propName;\n\n      if (secret !== ReactPropTypesSecret) {\n        if (throwOnDirectAccess) {\n          // New behavior only for users of `prop-types` package\n          invariant(\n            false,\n            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n            'Use `PropTypes.checkPropTypes()` to call them. ' +\n            'Read more at http://fb.me/use-check-prop-types'\n          );\n        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n          // Old behavior for people using React.PropTypes\n          var cacheKey = componentName + ':' + propName;\n          if (\n            !manualPropTypeCallCache[cacheKey] &&\n            // Avoid spamming the console because they are often not actionable except for lib authors\n            manualPropTypeWarningCount < 3\n          ) {\n            warning(\n              false,\n              'You are manually calling a React.PropTypes validation ' +\n              'function for the `%s` prop on `%s`. This is deprecated ' +\n              'and will throw in the standalone `prop-types` package. ' +\n              'You may be seeing this warning due to a third-party PropTypes ' +\n              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',\n              propFullName,\n              componentName\n            );\n            manualPropTypeCallCache[cacheKey] = true;\n            manualPropTypeWarningCount++;\n          }\n        }\n      }\n      if (props[propName] == null) {\n        if (isRequired) {\n          if (props[propName] === null) {\n            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n          }\n          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n        }\n        return null;\n      } else {\n        return validate(props, propName, componentName, location, propFullName);\n      }\n    }\n\n    var chainedCheckType = checkType.bind(null, false);\n    chainedCheckType.isRequired = checkType.bind(null, true);\n\n    return chainedCheckType;\n  }\n\n  function createPrimitiveTypeChecker(expectedType) {\n    function validate(props, propName, componentName, location, propFullName, secret) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== expectedType) {\n        // `propValue` being instance of, say, date/regexp, pass the 'object'\n        // check, but we can offer a more precise error message here rather than\n        // 'of type `object`'.\n        var preciseType = getPreciseType(propValue);\n\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createAnyTypeChecker() {\n    return createChainableTypeChecker(emptyFunction.thatReturnsNull);\n  }\n\n  function createArrayOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n      }\n      var propValue = props[propName];\n      if (!Array.isArray(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n      }\n      for (var i = 0; i < propValue.length; i++) {\n        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n        if (error instanceof Error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!isValidElement(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createInstanceTypeChecker(expectedClass) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!(props[propName] instanceof expectedClass)) {\n        var expectedClassName = expectedClass.name || ANONYMOUS;\n        var actualClassName = getClassName(props[propName]);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createEnumTypeChecker(expectedValues) {\n    if (!Array.isArray(expectedValues)) {\n      process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;\n      return emptyFunction.thatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      for (var i = 0; i < expectedValues.length; i++) {\n        if (is(propValue, expectedValues[i])) {\n          return null;\n        }\n      }\n\n      var valuesString = JSON.stringify(expectedValues);\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createObjectOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n      }\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n      }\n      for (var key in propValue) {\n        if (propValue.hasOwnProperty(key)) {\n          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n          if (error instanceof Error) {\n            return error;\n          }\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createUnionTypeChecker(arrayOfTypeCheckers) {\n    if (!Array.isArray(arrayOfTypeCheckers)) {\n      process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n      return emptyFunction.thatReturnsNull;\n    }\n\n    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n      var checker = arrayOfTypeCheckers[i];\n      if (typeof checker !== 'function') {\n        warning(\n          false,\n          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\n          'received %s at index %s.',\n          getPostfixForTypeWarning(checker),\n          i\n        );\n        return emptyFunction.thatReturnsNull;\n      }\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n        var checker = arrayOfTypeCheckers[i];\n        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\n          return null;\n        }\n      }\n\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createNodeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!isNode(props[propName])) {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      for (var key in shapeTypes) {\n        var checker = shapeTypes[key];\n        if (!checker) {\n          continue;\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createStrictShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      // We need to check all keys in case some are required but missing from\n      // props.\n      var allKeys = assign({}, props[propName], shapeTypes);\n      for (var key in allKeys) {\n        var checker = shapeTypes[key];\n        if (!checker) {\n          return new PropTypeError(\n            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\n            '\\nBad object: ' + JSON.stringify(props[propName], null, '  ') +\n            '\\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')\n          );\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n\n    return createChainableTypeChecker(validate);\n  }\n\n  function isNode(propValue) {\n    switch (typeof propValue) {\n      case 'number':\n      case 'string':\n      case 'undefined':\n        return true;\n      case 'boolean':\n        return !propValue;\n      case 'object':\n        if (Array.isArray(propValue)) {\n          return propValue.every(isNode);\n        }\n        if (propValue === null || isValidElement(propValue)) {\n          return true;\n        }\n\n        var iteratorFn = getIteratorFn(propValue);\n        if (iteratorFn) {\n          var iterator = iteratorFn.call(propValue);\n          var step;\n          if (iteratorFn !== propValue.entries) {\n            while (!(step = iterator.next()).done) {\n              if (!isNode(step.value)) {\n                return false;\n              }\n            }\n          } else {\n            // Iterator will provide entry [k,v] tuples rather than values.\n            while (!(step = iterator.next()).done) {\n              var entry = step.value;\n              if (entry) {\n                if (!isNode(entry[1])) {\n                  return false;\n                }\n              }\n            }\n          }\n        } else {\n          return false;\n        }\n\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  function isSymbol(propType, propValue) {\n    // Native Symbol.\n    if (propType === 'symbol') {\n      return true;\n    }\n\n    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n    if (propValue['@@toStringTag'] === 'Symbol') {\n      return true;\n    }\n\n    // Fallback for non-spec compliant Symbols which are polyfilled.\n    if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Equivalent of `typeof` but with special handling for array and regexp.\n  function getPropType(propValue) {\n    var propType = typeof propValue;\n    if (Array.isArray(propValue)) {\n      return 'array';\n    }\n    if (propValue instanceof RegExp) {\n      // Old webkits (at least until Android 4.0) return 'function' rather than\n      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n      // passes PropTypes.object.\n      return 'object';\n    }\n    if (isSymbol(propType, propValue)) {\n      return 'symbol';\n    }\n    return propType;\n  }\n\n  // This handles more types than `getPropType`. Only used for error messages.\n  // See `createPrimitiveTypeChecker`.\n  function getPreciseType(propValue) {\n    if (typeof propValue === 'undefined' || propValue === null) {\n      return '' + propValue;\n    }\n    var propType = getPropType(propValue);\n    if (propType === 'object') {\n      if (propValue instanceof Date) {\n        return 'date';\n      } else if (propValue instanceof RegExp) {\n        return 'regexp';\n      }\n    }\n    return propType;\n  }\n\n  // Returns a string that is postfixed to a warning about an invalid type.\n  // For example, \"undefined\" or \"of type array\"\n  function getPostfixForTypeWarning(value) {\n    var type = getPreciseType(value);\n    switch (type) {\n      case 'array':\n      case 'object':\n        return 'an ' + type;\n      case 'boolean':\n      case 'date':\n      case 'regexp':\n        return 'a ' + type;\n      default:\n        return type;\n    }\n  }\n\n  // Returns class name of the object, if any.\n  function getClassName(propValue) {\n    if (!propValue.constructor || !propValue.constructor.name) {\n      return ANONYMOUS;\n    }\n    return propValue.constructor.name;\n  }\n\n  ReactPropTypes.checkPropTypes = checkPropTypes;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./~/prop-types/factoryWithTypeCheckers.js","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;\n\n\n// WEBPACK FOOTER //\n// ./~/fbjs/lib/emptyFunction.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n\nmodule.exports = invariant;\n\n\n// WEBPACK FOOTER //\n// ./~/fbjs/lib/invariant.js","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar emptyFunction = require('./emptyFunction');\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (process.env.NODE_ENV !== 'production') {\n  var printWarning = function printWarning(format) {\n    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    var argIndex = 0;\n    var message = 'Warning: ' + format.replace(/%s/g, function () {\n      return args[argIndex++];\n    });\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n\n  warning = function warning(condition, format) {\n    if (format === undefined) {\n      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n    }\n\n    if (format.indexOf('Failed Composite propType: ') === 0) {\n      return; // Ignore CompositeComponent proptype check.\n    }\n\n    if (!condition) {\n      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n        args[_key2 - 2] = arguments[_key2];\n      }\n\n      printWarning.apply(undefined, [format].concat(args));\n    }\n  };\n}\n\nmodule.exports = warning;\n\n\n// WEBPACK FOOTER //\n// ./~/fbjs/lib/warning.js","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./~/object-assign/index.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n\n// WEBPACK FOOTER //\n// ./~/prop-types/lib/ReactPropTypesSecret.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== 'production') {\n  var invariant = require('fbjs/lib/invariant');\n  var warning = require('fbjs/lib/warning');\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (typeSpecs.hasOwnProperty(typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');\n        }\n      }\n    }\n  }\n}\n\nmodule.exports = checkPropTypes;\n\n\n\n// WEBPACK FOOTER //\n// ./~/prop-types/checkPropTypes.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    invariant(\n      false,\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim\n  };\n\n  ReactPropTypes.checkPropTypes = emptyFunction;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./~/prop-types/factoryWithThrowingShims.js","/* @flow */\nimport mapToZero from './mapToZero';\nimport stripStyle from './stripStyle';\nimport stepper from './stepper';\nimport defaultNow from 'performance-now';\nimport defaultRaf from 'raf';\nimport shouldStopAnimation from './shouldStopAnimation';\nimport React from 'react';\nimport PropTypes from 'prop-types';\n\nimport type {ReactElement, PlainStyle, Style, Velocity, StaggeredProps} from './Types';\n\nconst msPerFrame = 1000 / 60;\n\ntype StaggeredMotionState = {\n  currentStyles: Array<PlainStyle>,\n  currentVelocities: Array<Velocity>,\n  lastIdealStyles: Array<PlainStyle>,\n  lastIdealVelocities: Array<Velocity>,\n};\n\nfunction shouldStopAnimationAll(\n  currentStyles: Array<PlainStyle>,\n  styles: Array<Style>,\n  currentVelocities: Array<Velocity>,\n): boolean {\n  for (let i = 0; i < currentStyles.length; i++) {\n    if (!shouldStopAnimation(currentStyles[i], styles[i], currentVelocities[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport default class StaggeredMotion extends React.Component<StaggeredProps, StaggeredMotionState> {\n  static propTypes = {\n    // TOOD: warn against putting a config in here\n    defaultStyles: PropTypes.arrayOf(PropTypes.objectOf(PropTypes.number)),\n    styles: PropTypes.func.isRequired,\n    children: PropTypes.func.isRequired,\n  };\n\n  constructor(props: StaggeredProps) {\n    super(props);\n    this.state = this.defaultState();\n  }\n\n  defaultState(): StaggeredMotionState {\n    const {defaultStyles, styles} = this.props;\n    const currentStyles: Array<PlainStyle> = defaultStyles || styles().map(stripStyle);\n    const currentVelocities = currentStyles.map(currentStyle => mapToZero(currentStyle));\n    return {\n      currentStyles,\n      currentVelocities,\n      lastIdealStyles: currentStyles,\n      lastIdealVelocities: currentVelocities,\n    };\n  }\n\n  animationID: ?number = null;\n  prevTime = 0;\n  accumulatedTime = 0;\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  unreadPropStyles: ?Array<Style> = null;\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  clearUnreadPropStyle = (unreadPropStyles: Array<Style>): void => {\n    let {currentStyles, currentVelocities, lastIdealStyles, lastIdealVelocities} = this.state;\n\n    let someDirty = false;\n    for (let i = 0; i < unreadPropStyles.length; i++) {\n      const unreadPropStyle = unreadPropStyles[i];\n      let dirty = false;\n\n      for (let key in unreadPropStyle) {\n        if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) {\n          continue;\n        }\n\n        const styleValue = unreadPropStyle[key];\n        if (typeof styleValue === 'number') {\n          if (!dirty) {\n            dirty = true;\n            someDirty = true;\n            currentStyles[i] = {...currentStyles[i]};\n            currentVelocities[i] = {...currentVelocities[i]};\n            lastIdealStyles[i] = {...lastIdealStyles[i]};\n            lastIdealVelocities[i] = {...lastIdealVelocities[i]};\n          }\n          currentStyles[i][key] = styleValue;\n          currentVelocities[i][key] = 0;\n          lastIdealStyles[i][key] = styleValue;\n          lastIdealVelocities[i][key] = 0;\n        }\n      }\n    }\n\n    if (someDirty) {\n      this.setState({currentStyles, currentVelocities, lastIdealStyles, lastIdealVelocities});\n    }\n  }\n\n  startAnimationIfNecessary = (): void => {\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 = defaultRaf((timestamp) => {\n      const destStyles: Array<Style> = this.props.styles(this.state.lastIdealStyles);\n\n      // check if we need to animate in the first place\n      if (shouldStopAnimationAll(\n          this.state.currentStyles,\n          destStyles,\n          this.state.currentVelocities,\n        )) {\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      const currentTime = timestamp || defaultNow();\n      const 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      let currentFrameCompletion =\n        (this.accumulatedTime - Math.floor(this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n      const framesToCatchUp = Math.floor(this.accumulatedTime / msPerFrame);\n\n      let newLastIdealStyles = [];\n      let newLastIdealVelocities = [];\n      let newCurrentStyles = [];\n      let newCurrentVelocities = [];\n\n      for (let i = 0; i < destStyles.length; i++) {\n        const destStyle = destStyles[i];\n        let newCurrentStyle: PlainStyle = {};\n        let newCurrentVelocity: Velocity = {};\n        let newLastIdealStyle: PlainStyle = {};\n        let newLastIdealVelocity: Velocity = {};\n\n        for (let key in destStyle) {\n          if (!Object.prototype.hasOwnProperty.call(destStyle, key)) {\n            continue;\n          }\n\n          const styleValue = destStyle[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            let newLastIdealStyleValue = this.state.lastIdealStyles[i][key];\n            let newLastIdealVelocityValue = this.state.lastIdealVelocities[i][key];\n            for (let j = 0; j < framesToCatchUp; j++) {\n              [newLastIdealStyleValue, newLastIdealVelocityValue] = stepper(\n                msPerFrame / 1000,\n                newLastIdealStyleValue,\n                newLastIdealVelocityValue,\n                styleValue.val,\n                styleValue.stiffness,\n                styleValue.damping,\n                styleValue.precision,\n              );\n            }\n            const [nextIdealX, nextIdealV] = stepper(\n              msPerFrame / 1000,\n              newLastIdealStyleValue,\n              newLastIdealVelocityValue,\n              styleValue.val,\n              styleValue.stiffness,\n              styleValue.damping,\n              styleValue.precision,\n            );\n\n            newCurrentStyle[key] =\n              newLastIdealStyleValue +\n              (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n            newCurrentVelocity[key] =\n              newLastIdealVelocityValue +\n              (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n            newLastIdealStyle[key] = newLastIdealStyleValue;\n            newLastIdealVelocity[key] = newLastIdealVelocityValue;\n          }\n        }\n\n        newCurrentStyles[i] = newCurrentStyle;\n        newCurrentVelocities[i] = newCurrentVelocity;\n        newLastIdealStyles[i] = newLastIdealStyle;\n        newLastIdealVelocities[i] = newLastIdealVelocity;\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      });\n\n      this.unreadPropStyles = null;\n\n      this.startAnimationIfNecessary();\n    });\n  }\n\n  componentDidMount() {\n    this.prevTime = defaultNow();\n    this.startAnimationIfNecessary();\n  }\n\n  componentWillReceiveProps(props: StaggeredProps) {\n    if (this.unreadPropStyles != null) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyles);\n    }\n\n    this.unreadPropStyles = props.styles(this.state.lastIdealStyles);\n    if (this.animationID == null) {\n      this.prevTime = defaultNow();\n      this.startAnimationIfNecessary();\n    }\n  }\n\n  componentWillUnmount() {\n    if (this.animationID != null) {\n      defaultRaf.cancel(this.animationID);\n      this.animationID = null;\n    }\n  }\n\n  render(): ReactElement {\n    const renderedChildren = this.props.children(this.state.currentStyles);\n    return renderedChildren && React.Children.only(renderedChildren);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/StaggeredMotion.js","/* @flow */\nimport mapToZero from './mapToZero';\nimport stripStyle from './stripStyle';\nimport stepper from './stepper';\nimport mergeDiff from './mergeDiff';\nimport defaultNow from 'performance-now';\nimport defaultRaf from 'raf';\nimport shouldStopAnimation from './shouldStopAnimation';\nimport React from 'react';\nimport PropTypes from 'prop-types';\n\nimport type {\n  ReactElement,\n  PlainStyle,\n  Velocity,\n  TransitionStyle,\n  TransitionPlainStyle,\n  WillEnter,\n  WillLeave,\n  DidLeave,\n  TransitionProps,\n} from './Types';\n\nconst 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(\n  mergedPropsStyles: Array<TransitionStyle>,\n  unreadPropStyles: ?Array<TransitionStyle>,\n  plainStyles: Array<PlainStyle>,\n): Array<TransitionPlainStyle> {\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  const cUnreadPropStyles = unreadPropStyles;\n  if (cUnreadPropStyles == null) {\n    return mergedPropsStyles.map((mergedPropsStyle, i) => ({\n      key: mergedPropsStyle.key,\n      data: mergedPropsStyle.data,\n      style: plainStyles[i],\n    }));\n  }\n  return mergedPropsStyles.map((mergedPropsStyle, i) => {\n    for (let 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(\n  currentStyles: Array<PlainStyle>,\n  destStyles: Array<TransitionStyle>,\n  currentVelocities: Array<Velocity>,\n  mergedPropsStyles: Array<TransitionStyle>,\n): boolean {\n  if (mergedPropsStyles.length !== destStyles.length) {\n    return false;\n  }\n\n  for (let 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 (let i = 0; i < mergedPropsStyles.length; i++) {\n    if (!shouldStopAnimation(\n        currentStyles[i],\n        destStyles[i].style,\n        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(\n  willEnter: WillEnter,\n  willLeave: WillLeave,\n  didLeave: DidLeave,\n  oldMergedPropsStyles: Array<TransitionStyle>,\n  destStyles: Array<TransitionStyle>,\n  oldCurrentStyles: Array<PlainStyle>,\n  oldCurrentVelocities: Array<Velocity>,\n  oldLastIdealStyles: Array<PlainStyle>,\n  oldLastIdealVelocities: Array<Velocity>,\n): [Array<TransitionStyle>, Array<PlainStyle>, Array<Velocity>, Array<PlainStyle>, Array<Velocity>] {\n  const newMergedPropsStyles = mergeDiff(\n    oldMergedPropsStyles,\n    destStyles,\n    (oldIndex, oldMergedPropsStyle) => {\n      const leavingStyle = willLeave(oldMergedPropsStyle);\n      if (leavingStyle == null) {\n        didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n        return null;\n      }\n      if (shouldStopAnimation(\n          oldCurrentStyles[oldIndex],\n          leavingStyle,\n          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\n  let newCurrentStyles = [];\n  let newCurrentVelocities = [];\n  let newLastIdealStyles = [];\n  let newLastIdealVelocities = [];\n  for (let i = 0; i < newMergedPropsStyles.length; i++) {\n    const newMergedPropsStyleCell = newMergedPropsStyles[i];\n    let foundOldIndex = null;\n    for (let 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      const plainStyle = willEnter(newMergedPropsStyleCell);\n      newCurrentStyles[i] = plainStyle;\n      newLastIdealStyles[i] = plainStyle;\n\n      const velocity = mapToZero(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\ntype TransitionMotionDefaultProps = {\n  willEnter: WillEnter,\n  willLeave: WillLeave,\n  didLeave: DidLeave\n}\n\ntype TransitionMotionState = {\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  currentStyles: Array<PlainStyle>,\n  currentVelocities: Array<Velocity>,\n  lastIdealStyles: Array<PlainStyle>,\n  lastIdealVelocities: Array<Velocity>,\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  mergedPropsStyles: Array<TransitionStyle>,\n};\n\nexport default class TransitionMotion extends React.Component<TransitionProps, TransitionMotionState> {\n  static propTypes = {\n    defaultStyles: PropTypes.arrayOf(PropTypes.shape({\n      key: PropTypes.string.isRequired,\n      data: PropTypes.any,\n      style: PropTypes.objectOf(PropTypes.number).isRequired,\n    })),\n    styles: PropTypes.oneOfType([\n      PropTypes.func,\n      PropTypes.arrayOf(PropTypes.shape({\n        key: PropTypes.string.isRequired,\n        data: PropTypes.any,\n        style: PropTypes.objectOf(PropTypes.oneOfType([\n          PropTypes.number,\n          PropTypes.object,\n        ])).isRequired,\n      }),\n      )]).isRequired,\n    children: PropTypes.func.isRequired,\n    willEnter: PropTypes.func,\n    willLeave: PropTypes.func,\n    didLeave: PropTypes.func,\n  };\n\n  static defaultProps: TransitionMotionDefaultProps = {\n    willEnter: styleThatEntered => stripStyle(styleThatEntered.style),\n    // recall: returning null makes the current unmounting TransitionStyle\n    // disappear immediately\n    willLeave: () => null,\n    didLeave: () => {},\n  };\n\n  unmounting: boolean = false;\n  animationID: ?number = null;\n  prevTime = 0;\n  accumulatedTime = 0;\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  unreadPropStyles: ?Array<TransitionStyle> = null;\n\n  constructor(props: TransitionProps) {\n    super(props);\n    this.state = this.defaultState();\n  }\n\n  defaultState(): TransitionMotionState {\n    const {defaultStyles, styles, willEnter, willLeave, didLeave} = this.props;\n    const destStyles: Array<TransitionStyle> = 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    let oldMergedPropsStyles: Array<TransitionStyle>;\n    if (defaultStyles == null) {\n      oldMergedPropsStyles = destStyles;\n    } else {\n      oldMergedPropsStyles = (defaultStyles: any).map(defaultStyleCell => {\n        // TODO: key search code\n        for (let 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    const oldCurrentStyles = defaultStyles == null\n      ? destStyles.map(s => stripStyle(s.style))\n      : (defaultStyles: any).map(s => stripStyle(s.style));\n    const oldCurrentVelocities = defaultStyles == null\n      ? destStyles.map(s => mapToZero(s.style))\n      : defaultStyles.map(s => mapToZero(s.style));\n    const [mergedPropsStyles, currentStyles, currentVelocities, lastIdealStyles, lastIdealVelocities] = 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: any),\n      (willLeave: any),\n      (didLeave: any),\n      oldMergedPropsStyles,\n      destStyles,\n      oldCurrentStyles,\n      oldCurrentVelocities,\n      oldCurrentStyles, // oldLastIdealStyles really\n      oldCurrentVelocities, // oldLastIdealVelocities really\n    );\n\n    return {\n      currentStyles,\n      currentVelocities,\n      lastIdealStyles,\n      lastIdealVelocities,\n      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  clearUnreadPropStyle = (unreadPropStyles: Array<TransitionStyle>): void => {\n    let [mergedPropsStyles, currentStyles, currentVelocities, lastIdealStyles, lastIdealVelocities] = mergeAndSync(\n      (this.props.willEnter: any),\n      (this.props.willLeave: any),\n      (this.props.didLeave: any),\n      this.state.mergedPropsStyles,\n      unreadPropStyles,\n      this.state.currentStyles,\n      this.state.currentVelocities,\n      this.state.lastIdealStyles,\n      this.state.lastIdealVelocities,\n    );\n\n    for (let i = 0; i < unreadPropStyles.length; i++) {\n      const unreadPropStyle = unreadPropStyles[i].style;\n      let dirty = false;\n\n      for (let key in unreadPropStyle) {\n        if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) {\n          continue;\n        }\n\n        const styleValue = unreadPropStyle[key];\n        if (typeof styleValue === 'number') {\n          if (!dirty) {\n            dirty = true;\n            currentStyles[i] = {...currentStyles[i]};\n            currentVelocities[i] = {...currentVelocities[i]};\n            lastIdealStyles[i] = {...lastIdealStyles[i]};\n            lastIdealVelocities[i] = {...lastIdealVelocities[i]};\n            mergedPropsStyles[i] = {\n              key: mergedPropsStyles[i].key,\n              data: mergedPropsStyles[i].data,\n              style: {...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,\n      currentVelocities,\n      mergedPropsStyles,\n      lastIdealStyles,\n      lastIdealVelocities,\n    });\n  }\n\n  startAnimationIfNecessary = (): void => {\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 = defaultRaf((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      const propStyles = this.props.styles;\n      let destStyles: Array<TransitionStyle> = typeof propStyles === 'function'\n        ? propStyles(rehydrateStyles(\n          this.state.mergedPropsStyles,\n          this.unreadPropStyles,\n          this.state.lastIdealStyles,\n        ))\n        : propStyles;\n\n      // check if we need to animate in the first place\n      if (shouldStopAnimationAll(\n          this.state.currentStyles,\n          destStyles,\n          this.state.currentVelocities,\n          this.state.mergedPropsStyles,\n        )) {\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      const currentTime = timestamp || defaultNow();\n      const 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      let currentFrameCompletion =\n        (this.accumulatedTime - Math.floor(this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n      const framesToCatchUp = Math.floor(this.accumulatedTime / msPerFrame);\n\n      let [newMergedPropsStyles, newCurrentStyles, newCurrentVelocities, newLastIdealStyles, newLastIdealVelocities] = mergeAndSync(\n        (this.props.willEnter: any),\n        (this.props.willLeave: any),\n        (this.props.didLeave: any),\n        this.state.mergedPropsStyles,\n        destStyles,\n        this.state.currentStyles,\n        this.state.currentVelocities,\n        this.state.lastIdealStyles,\n        this.state.lastIdealVelocities,\n      );\n      for (let i = 0; i < newMergedPropsStyles.length; i++) {\n        const newMergedPropsStyle = newMergedPropsStyles[i].style;\n        let newCurrentStyle: PlainStyle = {};\n        let newCurrentVelocity: Velocity = {};\n        let newLastIdealStyle: PlainStyle = {};\n        let newLastIdealVelocity: Velocity = {};\n\n        for (let key in newMergedPropsStyle) {\n          if (!Object.prototype.hasOwnProperty.call(newMergedPropsStyle, key)) {\n            continue;\n          }\n\n          const 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            let newLastIdealStyleValue = newLastIdealStyles[i][key];\n            let newLastIdealVelocityValue = newLastIdealVelocities[i][key];\n            for (let j = 0; j < framesToCatchUp; j++) {\n              [newLastIdealStyleValue, newLastIdealVelocityValue] = stepper(\n                msPerFrame / 1000,\n                newLastIdealStyleValue,\n                newLastIdealVelocityValue,\n                styleValue.val,\n                styleValue.stiffness,\n                styleValue.damping,\n                styleValue.precision,\n              );\n            }\n            const [nextIdealX, nextIdealV] = stepper(\n              msPerFrame / 1000,\n              newLastIdealStyleValue,\n              newLastIdealVelocityValue,\n              styleValue.val,\n              styleValue.stiffness,\n              styleValue.damping,\n              styleValue.precision,\n            );\n\n            newCurrentStyle[key] =\n              newLastIdealStyleValue +\n              (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n            newCurrentVelocity[key] =\n              newLastIdealVelocityValue +\n              (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  componentDidMount() {\n    this.prevTime = defaultNow();\n    this.startAnimationIfNecessary();\n  }\n\n  componentWillReceiveProps(props: TransitionProps) {\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    const styles = props.styles;\n    if (typeof styles === 'function') {\n      this.unreadPropStyles = styles(\n        rehydrateStyles(\n          this.state.mergedPropsStyles,\n          this.unreadPropStyles,\n          this.state.lastIdealStyles,\n        )\n      );\n    } else {\n      this.unreadPropStyles = styles;\n    }\n\n    if (this.animationID == null) {\n      this.prevTime = defaultNow();\n      this.startAnimationIfNecessary();\n    }\n  }\n\n  componentWillUnmount() {\n    this.unmounting = true;\n    if (this.animationID != null) {\n      defaultRaf.cancel(this.animationID);\n      this.animationID = null;\n    }\n  }\n\n  render(): ReactElement {\n    const hydratedStyles = rehydrateStyles(\n      this.state.mergedPropsStyles,\n      this.unreadPropStyles,\n      this.state.currentStyles,\n    );\n    const renderedChildren = this.props.children(hydratedStyles);\n    return renderedChildren && React.Children.only(renderedChildren);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/TransitionMotion.js","/* @flow */\nimport type {TransitionStyle} from './Types';\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\nexport default function mergeDiff(\n  prev: Array<TransitionStyle>,\n  next: Array<TransitionStyle>,\n  onRemove: (prevIndex: number, prevStyleCell: TransitionStyle) => ?TransitionStyle\n): Array<TransitionStyle> {\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  // to loop through and find a key's index each time), but I no longer care\n  let prevKeyIndex: {[key: string]: number} = {};\n  for (let i = 0; i < prev.length; i++) {\n    prevKeyIndex[prev[i].key] = i;\n  }\n  let nextKeyIndex: {[key: string]: number} = {};\n  for (let 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  let ret = [];\n  for (let i = 0; i < next.length; i++) {\n    ret[i] = next[i];\n  }\n  for (let 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      const 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((a, b) => {\n    const nextOrderA = nextKeyIndex[a.key];\n    const nextOrderB = nextKeyIndex[b.key];\n    const prevOrderA = prevKeyIndex[a.key];\n    const 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 (let i = 0; i < next.length; i++) {\n        const 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 (let i = 0; i < next.length; i++) {\n      const 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\n\n\n// WEBPACK FOOTER //\n// ./src/mergeDiff.js","/* @flow */\nimport presets from './presets';\nimport type {OpaqueConfig, SpringHelperConfig} from './Types';\n\nconst defaultConfig = {\n  ...presets.noWobble,\n  precision: 0.01,\n};\n\nexport default function spring(val: number, config?: SpringHelperConfig): OpaqueConfig {\n  return {...defaultConfig, ...config, val};\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/spring.js","/* @flow */\nexport 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};\n\n\n\n// WEBPACK FOOTER //\n// ./src/presets.js","/* @flow */\n\nlet hasWarned = false;\nexport default function reorderKeys() {\n  if (process.env.NODE_ENV === 'development') {\n    if (!hasWarned) {\n      hasWarned = true;\n      console.error(\n        '`reorderKeys` has been removed, since it is no longer needed for TransitionMotion\\'s new styles array API.'\n      );\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/reorderKeys.js"]}