{"version":3,"sources":["../node_modules/react-spring/web.js","../node_modules/timers-browserify/main.js","../node_modules/setimmediate/setImmediate.js","../node_modules/hammerjs/hammer.js"],"names":["is","arr","Array","isArray","obj","a","Object","prototype","toString","call","fun","str","num","und","nul","set","Set","map","Map","equ","b","keys","length","i","useForceUpdate","f","useState","useCallback","v","withDefault","value","defaultValue","toArray","callProp","_len","arguments","args","_key","interpolateTo","props","forward","to","from","config","onStart","onRest","onFrame","children","reset","reverse","force","immediate","delay","attach","destroyed","ref","lazy","_objectWithoutPropertiesLoose","getForwardProps","_extends","rest","reduce","k","applyAnimatedValues","colorNames","Animated","this","payload","getValue","child","push","index","indexOf","splice","detach","AnimatedArray","forEach","p","addChild","removeChild","AnimatedObject","values","s","animated","key","injectApplyAnimatedValues","fn","transform","injectColorNames","names","interpolation","requestFrame","cb","window","requestAnimationFrame","injectStringInterpolator","now","Date","injectDefaultElement","el","createAnimatedStyle","manualFrameloop","animatedApi","node","current","injectCreateAnimatedStyle","factory","AnimatedProps","callback","update","style","active","controllers","time","controller","isActive","configIdx","configs","endOfAnimation","lastTime","valIdx","animatedValues","animation","done","fromValues","toValues","position","lastPosition","isAnimated","velocity","initialVelocity","setValue","duration","easing","startTime","decay","Math","exp","abs","lastVelocity","numSteps","floor","tension","friction","mass","isOvershooting","clamp","isVelocity","precision","isDisplacement","name","delete","stop","size","createInterpolator","range","output","extrapolate","outputRange","inputRange","extrapolateLeft","extrapolateRight","t","input","findRange","inputMin","inputMax","outputMin","outputMax","result","Infinity","interpolate","AnimatedInterpolation","parents","calc","getPayload","AnimatedValue","_value","_this","animatedStyles","startPosition","flush","addAnimatedStyles","styles","add","getChildren","animatedStyle","clear","AnimatedValueArray","n","G","Controller","id","idle","hasChanged","guid","local","merged","animations","interpolations","listeners","queue","localQueue","getValues","_ref","_ref$delay","ops","entries","_ref2","entry","previous","sort","diff","onEnd","_ref3","_ref3$from","_ref3$to","_ref4","finished","async","setTimeout","runAsync","start","has","_ref5","Promise","resolve","undefined","fresh","then","r","last","_this$props","_this$props$from","_this$props$to","_this$props$config","_ref6","target","acc","_ref7","isNumber","isString","startsWith","test","isInterpolation","fromValue","toValue","toConfig","parent","interpolation$$1","newValue","currentValue","some","currentValueDiffersFromGoal","hasNewGoal","hasNewConfig","prev","updateConfig","useSprings","mounted","useRef","ctrl","isFn","_useMemo","useMemo","c","destroy","fill","_","newProps","useImperativeHandle","all","updateCtrl","updateProps","useEffect","propValues","pause","useSpring","_useSprings","AnimatedStyle","colors","transparent","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","NUMBER","PERCENTAGE","parts","join","rgb","RegExp","rgba","hsl","hsla","hex3","hex4","hex6","hex8","hue2rgb","q","hslToRgb","h","l","g","round","parse255","int","parseInt","parse360","parseFloat","parse1","parsePercentage","colorToRgba","int32Color","color","match","exec","hasOwnProperty","normalizeColor","stringShapeRegex","colorRegex","colorNamesRegex","isUnitlessNumber","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","fontWeight","lineClamp","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","prefixes","dangerousStyleValue","isCustomProperty","trim","prop","prefix","charAt","toUpperCase","substring","prefixKey","attributeCache","rangeValue","replace","outputRanges","number","p1","p2","p3","p4","instance","nodeType","setAttribute","scrollTop","scrollLeft","attributes","filter","nodeName","parentNode","styleName","textContent","styleValue","setProperty","dashCase","toLowerCase","getAttribute","lowercase","extendedAnimated","Component","forwardRef","forceUpdate","propsAnimated","attachProps","oldPropsAnimated","didUpdate","getAnimatedValue","val","_getValue","animatedProps","refFn","React","childRef","handleRef","createElement","object","element","scope","global","self","apply","Function","Timeout","clearFn","_id","_clearFn","exports","clearTimeout","setInterval","clearInterval","timeout","close","unref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","_onTimeout","require","setImmediate","clearImmediate","registerImmediate","nextHandle","tasksByHandle","currentlyRunningATask","doc","document","attachTo","getPrototypeOf","process","handle","nextTick","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","canUsePostMessage","messagePrefix","random","onGlobalMessage","event","source","data","slice","addEventListener","attachEvent","installPostMessageImplementation","MessageChannel","channel","port1","port2","installMessageChannelImplementation","html","documentElement","script","onreadystatechange","appendChild","installReadyStateChangeImplementation","task","run","exportName","assign","VENDOR_PREFIXES","TEST_ELEMENT","setTimeoutContext","context","bindFn","invokeArrayArg","arg","each","iterator","deprecate","method","message","deprecationMessage","e","Error","stack","log","console","warn","TypeError","nextKey","extend","dest","src","merge","inherit","base","properties","childP","baseP","create","constructor","_super","boolOrFn","ifUndefined","val1","val2","addEventListeners","types","handler","splitStr","type","removeEventListeners","removeEventListener","hasParent","inStr","find","split","inArray","findByKey","uniqueArray","results","prefixed","property","camelProp","_uniqueId","getWindowForElement","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","navigator","userAgent","PROPS_XY","PROPS_CLIENT_XY","Input","manager","options","inputTarget","domHandler","ev","enable","init","inputHandler","eventType","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offset","offsetDelta","prevDelta","prevInput","x","deltaX","y","deltaY","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","scale","end","rotation","getRotation","maxPointers","velocityX","velocityY","direction","lastInterval","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","clientY","sqrt","atan2","PI","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MouseInput","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","2","3","4","5","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SingleTouchInput","started","normalizeSingleTouches","touches","changed","changedTouches","concat","TOUCH_INPUT_MAP","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","touch","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","compute","actions","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","DIRECTION_LEFT","DIRECTION_UP","preventSrc","Recognizer","defaults","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","attrTest","optionPointers","isRecognized","isValid","threshold","DIRECTION_HORIZONTAL","directionTest","hasMoved","inOut","validPointers","validMovement","validTime","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","inputClass","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","handlers","oldCssProps","createInputInstance","toggleCssProps","stopped","curRecognizer","existing","remove","on","events","off","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","STATE_FAILED","DIRECTION_NONE","DIRECTION_RIGHT","DIRECTION_DOWN","DIRECTION_VERTICAL","DIRECTION_ALL","Tap","Pan","Swipe","Pinch","Rotate","Press","define"],"mappings":"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","file":"static/js/78.13725a45.chunk.js","sourcesContent":["import _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport React, { useState, useCallback, forwardRef, useRef, useEffect, useImperativeHandle, useMemo } from 'react';\n\nconst is = {\n  arr: Array.isArray,\n  obj: a => Object.prototype.toString.call(a) === '[object Object]',\n  fun: a => typeof a === 'function',\n  str: a => typeof a === 'string',\n  num: a => typeof a === 'number',\n  und: a => a === void 0,\n  nul: a => a === null,\n  set: a => a instanceof Set,\n  map: a => a instanceof Map,\n\n  equ(a, b) {\n    if (typeof a !== typeof b) return false;\n    if (is.str(a) || is.num(a)) return a === b;\n    if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true;\n    let i;\n\n    for (i in a) if (!(i in b)) return false;\n\n    for (i in b) if (a[i] !== b[i]) return false;\n\n    return is.und(i) ? a === b : true;\n  }\n\n};\nfunction merge(target, lowercase) {\n  if (lowercase === void 0) {\n    lowercase = true;\n  }\n\n  return object => (is.arr(object) ? object : Object.keys(object)).reduce((acc, element) => {\n    const key = lowercase ? element[0].toLowerCase() + element.substring(1) : element;\n    acc[key] = target(key);\n    return acc;\n  }, target);\n}\nfunction useForceUpdate() {\n  const _useState = useState(false),\n        f = _useState[1];\n\n  const forceUpdate = useCallback(() => f(v => !v), []);\n  return forceUpdate;\n}\nfunction withDefault(value, defaultValue) {\n  return is.und(value) || is.nul(value) ? defaultValue : value;\n}\nfunction toArray(a) {\n  return !is.und(a) ? is.arr(a) ? a : [a] : [];\n}\nfunction callProp(obj) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  return is.fun(obj) ? obj(...args) : obj;\n}\n\nfunction getForwardProps(props) {\n  const to = props.to,\n        from = props.from,\n        config = props.config,\n        onStart = props.onStart,\n        onRest = props.onRest,\n        onFrame = props.onFrame,\n        children = props.children,\n        reset = props.reset,\n        reverse = props.reverse,\n        force = props.force,\n        immediate = props.immediate,\n        delay = props.delay,\n        attach = props.attach,\n        destroyed = props.destroyed,\n        interpolateTo = props.interpolateTo,\n        ref = props.ref,\n        lazy = props.lazy,\n        forward = _objectWithoutPropertiesLoose(props, [\"to\", \"from\", \"config\", \"onStart\", \"onRest\", \"onFrame\", \"children\", \"reset\", \"reverse\", \"force\", \"immediate\", \"delay\", \"attach\", \"destroyed\", \"interpolateTo\", \"ref\", \"lazy\"]);\n\n  return forward;\n}\n\nfunction interpolateTo(props) {\n  const forward = getForwardProps(props);\n  if (is.und(forward)) return _extends({\n    to: forward\n  }, props);\n  const rest = Object.keys(props).reduce((a, k) => !is.und(forward[k]) ? a : _extends({}, a, {\n    [k]: props[k]\n  }), {});\n  return _extends({\n    to: forward\n  }, rest);\n}\nfunction handleRef(ref, forward) {\n  if (forward) {\n    // If it's a function, assume it's a ref callback\n    if (is.fun(forward)) forward(ref);else if (is.obj(forward)) {\n      forward.current = ref;\n    }\n  }\n\n  return ref;\n}\n\nclass Animated {\n  constructor() {\n    this.payload = void 0;\n    this.children = [];\n  }\n\n  getAnimatedValue() {\n    return this.getValue();\n  }\n\n  getPayload() {\n    return this.payload || this;\n  }\n\n  attach() {}\n\n  detach() {}\n\n  getChildren() {\n    return this.children;\n  }\n\n  addChild(child) {\n    if (this.children.length === 0) this.attach();\n    this.children.push(child);\n  }\n\n  removeChild(child) {\n    const index = this.children.indexOf(child);\n    this.children.splice(index, 1);\n    if (this.children.length === 0) this.detach();\n  }\n\n}\nclass AnimatedArray extends Animated {\n  constructor() {\n    super(...arguments);\n    this.payload = [];\n\n    this.attach = () => this.payload.forEach(p => p instanceof Animated && p.addChild(this));\n\n    this.detach = () => this.payload.forEach(p => p instanceof Animated && p.removeChild(this));\n  }\n\n}\nclass AnimatedObject extends Animated {\n  constructor() {\n    super(...arguments);\n    this.payload = {};\n\n    this.attach = () => Object.values(this.payload).forEach(s => s instanceof Animated && s.addChild(this));\n\n    this.detach = () => Object.values(this.payload).forEach(s => s instanceof Animated && s.removeChild(this));\n  }\n\n  getValue(animated) {\n    if (animated === void 0) {\n      animated = false;\n    }\n\n    const payload = {};\n\n    for (const key in this.payload) {\n      const value = this.payload[key];\n      if (animated && !(value instanceof Animated)) continue;\n      payload[key] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value;\n    }\n\n    return payload;\n  }\n\n  getAnimatedValue() {\n    return this.getValue(true);\n  }\n\n}\n\nlet applyAnimatedValues;\nfunction injectApplyAnimatedValues(fn, transform) {\n  applyAnimatedValues = {\n    fn,\n    transform\n  };\n}\nlet colorNames;\nfunction injectColorNames(names) {\n  colorNames = names;\n}\nlet requestFrame = cb => typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1;\nlet cancelFrame = id => {\n  typeof window !== 'undefined' && window.cancelAnimationFrame(id);\n};\nfunction injectFrame(raf, caf) {\n  requestFrame = raf;\n  cancelFrame = caf;\n}\nlet interpolation;\nfunction injectStringInterpolator(fn) {\n  interpolation = fn;\n}\nlet now = () => Date.now();\nfunction injectNow(nowFn) {\n  now = nowFn;\n}\nlet defaultElement;\nfunction injectDefaultElement(el) {\n  defaultElement = el;\n}\nlet animatedApi = node => node.current;\nfunction injectAnimatedApi(fn) {\n  animatedApi = fn;\n}\nlet createAnimatedStyle;\nfunction injectCreateAnimatedStyle(factory) {\n  createAnimatedStyle = factory;\n}\nlet manualFrameloop;\nfunction injectManualFrameloop(callback) {\n  manualFrameloop = callback;\n}\n\nvar Globals = /*#__PURE__*/Object.freeze({\n  get applyAnimatedValues () { return applyAnimatedValues; },\n  injectApplyAnimatedValues: injectApplyAnimatedValues,\n  get colorNames () { return colorNames; },\n  injectColorNames: injectColorNames,\n  get requestFrame () { return requestFrame; },\n  get cancelFrame () { return cancelFrame; },\n  injectFrame: injectFrame,\n  get interpolation () { return interpolation; },\n  injectStringInterpolator: injectStringInterpolator,\n  get now () { return now; },\n  injectNow: injectNow,\n  get defaultElement () { return defaultElement; },\n  injectDefaultElement: injectDefaultElement,\n  get animatedApi () { return animatedApi; },\n  injectAnimatedApi: injectAnimatedApi,\n  get createAnimatedStyle () { return createAnimatedStyle; },\n  injectCreateAnimatedStyle: injectCreateAnimatedStyle,\n  get manualFrameloop () { return manualFrameloop; },\n  injectManualFrameloop: injectManualFrameloop\n});\n\n/**\n * Wraps the `style` property with `AnimatedStyle`.\n */\n\nclass AnimatedProps extends AnimatedObject {\n  constructor(props, callback) {\n    super();\n    this.update = void 0;\n    this.payload = !props.style ? props : _extends({}, props, {\n      style: createAnimatedStyle(props.style)\n    });\n    this.update = callback;\n    this.attach();\n  }\n\n}\n\nconst isFunctionComponent = val => is.fun(val) && !(val.prototype instanceof React.Component);\n\nconst createAnimatedComponent = Component => {\n  const AnimatedComponent = forwardRef((props, ref) => {\n    const forceUpdate = useForceUpdate();\n    const mounted = useRef(true);\n    const propsAnimated = useRef(null);\n    const node = useRef(null);\n    const attachProps = useCallback(props => {\n      const oldPropsAnimated = propsAnimated.current;\n\n      const callback = () => {\n        let didUpdate = false;\n\n        if (node.current) {\n          didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue());\n        }\n\n        if (!node.current || didUpdate === false) {\n          // If no referenced node has been found, or the update target didn't have a\n          // native-responder, then forceUpdate the animation ...\n          forceUpdate();\n        }\n      };\n\n      propsAnimated.current = new AnimatedProps(props, callback);\n      oldPropsAnimated && oldPropsAnimated.detach();\n    }, []);\n    useEffect(() => () => {\n      mounted.current = false;\n      propsAnimated.current && propsAnimated.current.detach();\n    }, []);\n    useImperativeHandle(ref, () => animatedApi(node, mounted, forceUpdate));\n    attachProps(props);\n\n    const _getValue = propsAnimated.current.getValue(),\n          scrollTop = _getValue.scrollTop,\n          scrollLeft = _getValue.scrollLeft,\n          animatedProps = _objectWithoutPropertiesLoose(_getValue, [\"scrollTop\", \"scrollLeft\"]); // Functions cannot have refs, see:\n    // See: https://github.com/react-spring/react-spring/issues/569\n\n\n    const refFn = isFunctionComponent(Component) ? undefined : childRef => node.current = handleRef(childRef, ref);\n    return React.createElement(Component, _extends({}, animatedProps, {\n      ref: refFn\n    }));\n  });\n  return AnimatedComponent;\n};\n\nlet active = false;\nconst controllers = new Set();\n\nconst update = () => {\n  if (!active) return false;\n  let time = now();\n\n  for (let controller of controllers) {\n    let isActive = false;\n\n    for (let configIdx = 0; configIdx < controller.configs.length; configIdx++) {\n      let config = controller.configs[configIdx];\n      let endOfAnimation, lastTime;\n\n      for (let valIdx = 0; valIdx < config.animatedValues.length; valIdx++) {\n        let animation = config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude\n\n        if (animation.done) continue;\n        let from = config.fromValues[valIdx];\n        let to = config.toValues[valIdx];\n        let position = animation.lastPosition;\n        let isAnimated = to instanceof Animated;\n        let velocity = Array.isArray(config.initialVelocity) ? config.initialVelocity[valIdx] : config.initialVelocity;\n        if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state\n\n        if (config.immediate) {\n          animation.setValue(to);\n          animation.done = true;\n          continue;\n        } // Break animation when string values are involved\n\n\n        if (typeof from === 'string' || typeof to === 'string') {\n          animation.setValue(to);\n          animation.done = true;\n          continue;\n        }\n\n        if (config.duration !== void 0) {\n          /** Duration easing */\n          position = from + config.easing((time - animation.startTime) / config.duration) * (to - from);\n          endOfAnimation = time >= animation.startTime + config.duration;\n        } else if (config.decay) {\n          /** Decay easing */\n          position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime)));\n          endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1;\n          if (endOfAnimation) to = position;\n        } else {\n          /** Spring easing */\n          lastTime = animation.lastTime !== void 0 ? animation.lastTime : time;\n          velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : config.initialVelocity; // If we lost a lot of frames just jump to the end.\n\n          if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/\n\n          let numSteps = Math.floor(time - lastTime);\n\n          for (let i = 0; i < numSteps; ++i) {\n            let force = -config.tension * (position - to);\n            let damping = -config.friction * velocity;\n            let acceleration = (force + damping) / config.mass;\n            velocity = velocity + acceleration * 1 / 1000;\n            position = position + velocity * 1 / 1000;\n          } // Conditions for stopping the spring animation\n\n\n          let isOvershooting = config.clamp && config.tension !== 0 ? from < to ? position > to : position < to : false;\n          let isVelocity = Math.abs(velocity) <= config.precision;\n          let isDisplacement = config.tension !== 0 ? Math.abs(to - position) <= config.precision : true;\n          endOfAnimation = isOvershooting || isVelocity && isDisplacement;\n          animation.lastVelocity = velocity;\n          animation.lastTime = time;\n        } // Trails aren't done until their parents conclude\n\n\n        if (isAnimated && !config.toValues[valIdx].done) endOfAnimation = false;\n\n        if (endOfAnimation) {\n          // Ensure that we end up with a round value\n          if (animation.value !== to) position = to;\n          animation.done = true;\n        } else isActive = true;\n\n        animation.setValue(position);\n        animation.lastPosition = position;\n      } // Keep track of updated values only when necessary\n\n\n      if (controller.props.onFrame) controller.values[config.name] = config.interpolation.getValue();\n    } // Update callbacks in the end of the frame\n\n\n    if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame\n\n    if (!isActive) {\n      controllers.delete(controller);\n      controller.stop(true);\n    }\n  } // Loop over as long as there are controllers ...\n\n\n  if (controllers.size) {\n    if (manualFrameloop) manualFrameloop();else requestFrame(update);\n  } else {\n    active = false;\n  }\n\n  return active;\n};\n\nconst start = controller => {\n  if (!controllers.has(controller)) controllers.add(controller);\n\n  if (!active) {\n    active = true;\n    if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update);\n  }\n};\n\nconst stop = controller => {\n  if (controllers.has(controller)) controllers.delete(controller);\n};\n\nfunction createInterpolator(range, output, extrapolate) {\n  if (typeof range === 'function') {\n    return range;\n  }\n\n  if (Array.isArray(range)) {\n    return createInterpolator({\n      range,\n      output: output,\n      extrapolate\n    });\n  }\n\n  if (interpolation && typeof range.output[0] === 'string') {\n    return interpolation(range);\n  }\n\n  const config = range;\n  const outputRange = config.output;\n  const inputRange = config.range || [0, 1];\n  const extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend';\n  const extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend';\n\n  const easing = config.easing || (t => t);\n\n  return input => {\n    const range = findRange(input, inputRange);\n    return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map);\n  };\n}\n\nfunction interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {\n  let result = map ? map(input) : input; // Extrapolate\n\n  if (result < inputMin) {\n    if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin;\n  }\n\n  if (result > inputMax) {\n    if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax;\n  }\n\n  if (outputMin === outputMax) return outputMin;\n  if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range\n\n  if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing\n\n  result = easing(result); // Output Range\n\n  if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin;\n  return result;\n}\n\nfunction findRange(input, inputRange) {\n  for (var i = 1; i < inputRange.length - 1; ++i) if (inputRange[i] >= input) break;\n\n  return i - 1;\n}\n\nclass AnimatedInterpolation extends AnimatedArray {\n  constructor(parents, range, output, extrapolate) {\n    super();\n    this.calc = void 0;\n    this.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents];\n    this.calc = createInterpolator(range, output, extrapolate);\n  }\n\n  getValue() {\n    return this.calc(...this.payload.map(value => value.getValue()));\n  }\n\n  updateConfig(range, output, extrapolate) {\n    this.calc = createInterpolator(range, output, extrapolate);\n  }\n\n  interpolate(range, output, extrapolate) {\n    return new AnimatedInterpolation(this, range, output, extrapolate);\n  }\n\n}\n\nconst interpolate$1 = (parents, range, output) => parents && new AnimatedInterpolation(parents, range, output);\n\nconst config = {\n  default: {\n    tension: 170,\n    friction: 26\n  },\n  gentle: {\n    tension: 120,\n    friction: 14\n  },\n  wobbly: {\n    tension: 180,\n    friction: 12\n  },\n  stiff: {\n    tension: 210,\n    friction: 20\n  },\n  slow: {\n    tension: 280,\n    friction: 60\n  },\n  molasses: {\n    tension: 280,\n    friction: 120\n  }\n};\n\n/** API\n *  useChain(references, timeSteps, timeFrame)\n */\n\nfunction useChain(refs, timeSteps, timeFrame) {\n  if (timeFrame === void 0) {\n    timeFrame = 1000;\n  }\n\n  const previous = useRef();\n  useEffect(() => {\n    if (is.equ(refs, previous.current)) refs.forEach((_ref) => {\n      let current = _ref.current;\n      return current && current.start();\n    });else if (timeSteps) {\n      refs.forEach((_ref2, index) => {\n        let current = _ref2.current;\n\n        if (current) {\n          const ctrls = current.controllers;\n\n          if (ctrls.length) {\n            const t = timeFrame * timeSteps[index];\n            ctrls.forEach(ctrl => {\n              ctrl.queue = ctrl.queue.map(e => _extends({}, e, {\n                delay: e.delay + t\n              }));\n              ctrl.start();\n            });\n          }\n        }\n      });\n    } else refs.reduce((q, _ref3, rI) => {\n      let current = _ref3.current;\n      return q = q.then(() => current.start());\n    }, Promise.resolve());\n    previous.current = refs;\n  });\n}\n\n/**\n * Animated works by building a directed acyclic graph of dependencies\n * transparently when you render your Animated components.\n *\n *               new Animated.Value(0)\n *     .interpolate()        .interpolate()    new Animated.Value(1)\n *         opacity               translateY      scale\n *          style                         transform\n *         View#234                         style\n *                                         View#123\n *\n * A) Top Down phase\n * When an AnimatedValue is updated, we recursively go down through this\n * graph in order to find leaf nodes: the views that we flag as needing\n * an update.\n *\n * B) Bottom Up phase\n * When a view is flagged as needing an update, we recursively go back up\n * in order to build the new value that it needs. The reason why we need\n * this two-phases process is to deal with composite props such as\n * transform which can receive values from multiple parents.\n */\nfunction addAnimatedStyles(node, styles) {\n  if ('update' in node) {\n    styles.add(node);\n  } else {\n    node.getChildren().forEach(child => addAnimatedStyles(child, styles));\n  }\n}\n\nclass AnimatedValue extends Animated {\n  constructor(_value) {\n    var _this;\n\n    super();\n    _this = this;\n    this.animatedStyles = new Set();\n    this.value = void 0;\n    this.startPosition = void 0;\n    this.lastPosition = void 0;\n    this.lastVelocity = void 0;\n    this.startTime = void 0;\n    this.lastTime = void 0;\n    this.done = false;\n\n    this.setValue = function (value, flush) {\n      if (flush === void 0) {\n        flush = true;\n      }\n\n      _this.value = value;\n      if (flush) _this.flush();\n    };\n\n    this.value = _value;\n    this.startPosition = _value;\n    this.lastPosition = _value;\n  }\n\n  flush() {\n    if (this.animatedStyles.size === 0) {\n      addAnimatedStyles(this, this.animatedStyles);\n    }\n\n    this.animatedStyles.forEach(animatedStyle => animatedStyle.update());\n  }\n\n  clearStyles() {\n    this.animatedStyles.clear();\n  }\n\n  getValue() {\n    return this.value;\n  }\n\n  interpolate(range, output, extrapolate) {\n    return new AnimatedInterpolation(this, range, output, extrapolate);\n  }\n\n}\n\nclass AnimatedValueArray extends AnimatedArray {\n  constructor(values) {\n    super();\n    this.payload = values.map(n => new AnimatedValue(n));\n  }\n\n  setValue(value, flush) {\n    if (flush === void 0) {\n      flush = true;\n    }\n\n    if (Array.isArray(value)) {\n      if (value.length === this.payload.length) {\n        value.forEach((v, i) => this.payload[i].setValue(v, flush));\n      }\n    } else {\n      this.payload.forEach(p => p.setValue(value, flush));\n    }\n  }\n\n  getValue() {\n    return this.payload.map(v => v.getValue());\n  }\n\n  interpolate(range, output) {\n    return new AnimatedInterpolation(this, range, output);\n  }\n\n}\n\nlet G = 0;\n\nclass Controller {\n  constructor() {\n    this.id = void 0;\n    this.idle = true;\n    this.hasChanged = false;\n    this.guid = 0;\n    this.local = 0;\n    this.props = {};\n    this.merged = {};\n    this.animations = {};\n    this.interpolations = {};\n    this.values = {};\n    this.configs = [];\n    this.listeners = [];\n    this.queue = [];\n    this.localQueue = void 0;\n\n    this.getValues = () => this.interpolations;\n\n    this.id = G++;\n  }\n  /** update(props)\n   *  This function filters input props and creates an array of tasks which are executed in .start()\n   *  Each task is allowed to carry a delay, which means it can execute asnychroneously */\n\n\n  update(args) {\n    //this._id = n + this.id\n    if (!args) return this; // Extract delay and the to-prop from props\n\n    const _ref = interpolateTo(args),\n          _ref$delay = _ref.delay,\n          delay = _ref$delay === void 0 ? 0 : _ref$delay,\n          to = _ref.to,\n          props = _objectWithoutPropertiesLoose(_ref, [\"delay\", \"to\"]);\n\n    if (is.arr(to) || is.fun(to)) {\n      // If config is either a function or an array queue it up as is\n      this.queue.push(_extends({}, props, {\n        delay,\n        to\n      }));\n    } else if (to) {\n      // Otherwise go through each key since it could be delayed individually\n      let ops = {};\n      Object.entries(to).forEach((_ref2) => {\n        let k = _ref2[0],\n            v = _ref2[1];\n\n        // Fetch delay and create an entry, consisting of the to-props, the delay, and basic props\n        const entry = _extends({\n          to: {\n            [k]: v\n          },\n          delay: callProp(delay, k)\n        }, props);\n\n        const previous = ops[entry.delay] && ops[entry.delay].to;\n        ops[entry.delay] = _extends({}, ops[entry.delay], entry, {\n          to: _extends({}, previous, entry.to)\n        });\n      });\n      this.queue = Object.values(ops);\n    } // Sort queue, so that async calls go last\n\n\n    this.queue = this.queue.sort((a, b) => a.delay - b.delay); // Diff the reduced props immediately (they'll contain the from-prop and some config)\n\n    this.diff(props);\n    return this;\n  }\n  /** start(onEnd)\n   *  This function either executes a queue, if present, or starts the frameloop, which animates */\n\n\n  start(onEnd) {\n    // If a queue is present we must excecute it\n    if (this.queue.length) {\n      this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values\n\n      if (this.localQueue) {\n        this.localQueue.forEach((_ref3) => {\n          let _ref3$from = _ref3.from,\n              from = _ref3$from === void 0 ? {} : _ref3$from,\n              _ref3$to = _ref3.to,\n              to = _ref3$to === void 0 ? {} : _ref3$to;\n          if (is.obj(from)) this.merged = _extends({}, from, this.merged);\n          if (is.obj(to)) this.merged = _extends({}, this.merged, to);\n        });\n      } // The guid helps us tracking frames, a new queue over an old one means an override\n      // We discard async calls in that caseÍ\n\n\n      const local = this.local = ++this.guid;\n      const queue = this.localQueue = this.queue;\n      this.queue = []; // Go through each entry and execute it\n\n      queue.forEach((_ref4, index) => {\n        let delay = _ref4.delay,\n            props = _objectWithoutPropertiesLoose(_ref4, [\"delay\"]);\n\n        const cb = finished => {\n          if (index === queue.length - 1 && local === this.guid && finished) {\n            this.idle = true;\n            if (this.props.onRest) this.props.onRest(this.merged);\n          }\n\n          if (onEnd) onEnd();\n        }; // Entries can be delayed, ansyc or immediate\n\n\n        let async = is.arr(props.to) || is.fun(props.to);\n\n        if (delay) {\n          setTimeout(() => {\n            if (local === this.guid) {\n              if (async) this.runAsync(props, cb);else this.diff(props).start(cb);\n            }\n          }, delay);\n        } else if (async) this.runAsync(props, cb);else this.diff(props).start(cb);\n      });\n    } // Otherwise we kick of the frameloop\n    else {\n        if (is.fun(onEnd)) this.listeners.push(onEnd);\n        if (this.props.onStart) this.props.onStart();\n        start(this);\n      }\n\n    return this;\n  }\n\n  stop(finished) {\n    this.listeners.forEach(onEnd => onEnd(finished));\n    this.listeners = [];\n    return this;\n  }\n  /** Pause sets onEnd listeners free, but also removes the controller from the frameloop */\n\n\n  pause(finished) {\n    this.stop(true);\n    if (finished) stop(this);\n    return this;\n  }\n\n  runAsync(_ref5, onEnd) {\n    var _this = this;\n\n    let delay = _ref5.delay,\n        props = _objectWithoutPropertiesLoose(_ref5, [\"delay\"]);\n\n    const local = this.local; // If \"to\" is either a function or an array it will be processed async, therefor \"to\" should be empty right now\n    // If the view relies on certain values \"from\" has to be present\n\n    let queue = Promise.resolve(undefined);\n\n    if (is.arr(props.to)) {\n      for (let i = 0; i < props.to.length; i++) {\n        const index = i;\n\n        const fresh = _extends({}, props, interpolateTo(props.to[index]));\n\n        if (is.arr(fresh.config)) fresh.config = fresh.config[index];\n        queue = queue.then(() => {\n          //this.stop()\n          if (local === this.guid) return new Promise(r => this.diff(fresh).start(r));\n        });\n      }\n    } else if (is.fun(props.to)) {\n      let index = 0;\n      let last;\n      queue = queue.then(() => props.to( // next(props)\n      p => {\n        const fresh = _extends({}, props, interpolateTo(p));\n\n        if (is.arr(fresh.config)) fresh.config = fresh.config[index];\n        index++; //this.stop()\n\n        if (local === this.guid) return last = new Promise(r => this.diff(fresh).start(r));\n        return;\n      }, // cancel()\n      function (finished) {\n        if (finished === void 0) {\n          finished = true;\n        }\n\n        return _this.stop(finished);\n      }).then(() => last));\n    }\n\n    queue.then(onEnd);\n  }\n\n  diff(props) {\n    this.props = _extends({}, this.props, props);\n    let _this$props = this.props,\n        _this$props$from = _this$props.from,\n        from = _this$props$from === void 0 ? {} : _this$props$from,\n        _this$props$to = _this$props.to,\n        to = _this$props$to === void 0 ? {} : _this$props$to,\n        _this$props$config = _this$props.config,\n        config = _this$props$config === void 0 ? {} : _this$props$config,\n        reverse = _this$props.reverse,\n        attach = _this$props.attach,\n        reset = _this$props.reset,\n        immediate = _this$props.immediate; // Reverse values when requested\n\n    if (reverse) {\n      var _ref6 = [to, from];\n      from = _ref6[0];\n      to = _ref6[1];\n    } // This will collect all props that were ever set, reset merged props when necessary\n\n\n    this.merged = _extends({}, from, this.merged, to);\n    this.hasChanged = false; // Attachment handling, trailed springs can \"attach\" themselves to a previous spring\n\n    let target = attach && attach(this); // Reduces input { name: value } pairs into animated values\n\n    this.animations = Object.entries(this.merged).reduce((acc, _ref7) => {\n      let name = _ref7[0],\n          value = _ref7[1];\n      // Issue cached entries, except on reset\n      let entry = acc[name] || {}; // Figure out what the value is supposed to be\n\n      const isNumber = is.num(value);\n      const isString = is.str(value) && !value.startsWith('#') && !/\\d/.test(value) && !colorNames[value];\n      const isArray = is.arr(value);\n      const isInterpolation = !isNumber && !isArray && !isString;\n      let fromValue = !is.und(from[name]) ? from[name] : value;\n      let toValue = isNumber || isArray ? value : isString ? value : 1;\n      let toConfig = callProp(config, name);\n      if (target) toValue = target.animations[name].parent;\n      let parent = entry.parent,\n          interpolation$$1 = entry.interpolation,\n          toValues = toArray(target ? toValue.getPayload() : toValue),\n          animatedValues;\n      let newValue = value;\n      if (isInterpolation) newValue = interpolation({\n        range: [0, 1],\n        output: [value, value]\n      })(1);\n      let currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags\n\n      const isFirst = is.und(parent);\n      const isActive = !isFirst && entry.animatedValues.some(v => !v.done);\n      const currentValueDiffersFromGoal = !is.equ(newValue, currentValue);\n      const hasNewGoal = !is.equ(newValue, entry.previous);\n      const hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one)\n      // and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?)\n\n      if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) {\n        // Convert regular values into animated values, ALWAYS re-use if possible\n        if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) {\n          let prev = entry.interpolation && entry.interpolation.calc(entry.parent.value);\n          prev = prev !== void 0 && !reset ? prev : fromValue;\n\n          if (entry.parent) {\n            parent = entry.parent;\n            parent.setValue(0, false);\n          } else parent = new AnimatedValue(0);\n\n          const range = {\n            output: [prev, value]\n          };\n\n          if (entry.interpolation) {\n            interpolation$$1 = entry.interpolation;\n            entry.interpolation.updateConfig(range);\n          } else interpolation$$1 = parent.interpolate(range);\n        }\n        toValues = toArray(target ? toValue.getPayload() : toValue);\n        animatedValues = toArray(parent.getPayload());\n        if (reset && !isInterpolation) parent.setValue(fromValue, false);\n        this.hasChanged = true; // Reset animated values\n\n        animatedValues.forEach(value => {\n          value.startPosition = value.value;\n          value.lastPosition = value.value;\n          value.lastVelocity = isActive ? value.lastVelocity : undefined;\n          value.lastTime = isActive ? value.lastTime : undefined;\n          value.startTime = now();\n          value.done = false;\n          value.animatedStyles.clear();\n        }); // Set immediate values\n\n        if (callProp(immediate, name)) {\n          parent.setValue(isInterpolation ? toValue : value, false);\n        }\n\n        return _extends({}, acc, {\n          [name]: _extends({}, entry, {\n            name,\n            parent,\n            interpolation: interpolation$$1,\n            animatedValues,\n            toValues,\n            previous: newValue,\n            config: toConfig,\n            fromValues: toArray(parent.getValue()),\n            immediate: callProp(immediate, name),\n            initialVelocity: withDefault(toConfig.velocity, 0),\n            clamp: withDefault(toConfig.clamp, false),\n            precision: withDefault(toConfig.precision, 0.01),\n            tension: withDefault(toConfig.tension, 170),\n            friction: withDefault(toConfig.friction, 26),\n            mass: withDefault(toConfig.mass, 1),\n            duration: toConfig.duration,\n            easing: withDefault(toConfig.easing, t => t),\n            decay: toConfig.decay\n          })\n        });\n      } else {\n        if (!currentValueDiffersFromGoal) {\n          // So ... the current target value (newValue) appears to be different from the previous value,\n          // which normally constitutes an update, but the actual value (currentValue) matches the target!\n          // In order to resolve this without causing an animation update we silently flag the animation as done,\n          // which it technically is. Interpolations also needs a config update with their target set to 1.\n          if (isInterpolation) {\n            parent.setValue(1, false);\n            interpolation$$1.updateConfig({\n              output: [newValue, newValue]\n            });\n          }\n\n          parent.done = true;\n          this.hasChanged = true;\n          return _extends({}, acc, {\n            [name]: _extends({}, acc[name], {\n              previous: newValue\n            })\n          });\n        }\n\n        return acc;\n      }\n    }, this.animations);\n\n    if (this.hasChanged) {\n      // Make animations available to frameloop\n      this.configs = Object.values(this.animations);\n      this.values = {};\n      this.interpolations = {};\n\n      for (let key in this.animations) {\n        this.interpolations[key] = this.animations[key].interpolation;\n        this.values[key] = this.animations[key].interpolation.getValue();\n      }\n    }\n\n    return this;\n  }\n\n  destroy() {\n    this.stop();\n    this.props = {};\n    this.merged = {};\n    this.animations = {};\n    this.interpolations = {};\n    this.values = {};\n    this.configs = [];\n    this.local = 0;\n  }\n\n}\n\n/** API\n * const props = useSprings(number, [{ ... }, { ... }, ...])\n * const [props, set] = useSprings(number, (i, controller) => ({ ... }))\n */\n\nconst useSprings = (length, props) => {\n  const mounted = useRef(false);\n  const ctrl = useRef();\n  const isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations\n\n  const _useMemo = useMemo(() => {\n    // Remove old controllers\n    if (ctrl.current) {\n      ctrl.current.map(c => c.destroy());\n      ctrl.current = undefined;\n    }\n\n    let ref;\n    return [new Array(length).fill().map((_, i) => {\n      const ctrl = new Controller();\n      const newProps = isFn ? callProp(props, i, ctrl) : props[i];\n      if (i === 0) ref = newProps.ref;\n      ctrl.update(newProps);\n      if (!ref) ctrl.start();\n      return ctrl;\n    }), ref];\n  }, [length]),\n        controllers = _useMemo[0],\n        ref = _useMemo[1];\n\n  ctrl.current = controllers; // The hooks reference api gets defined here ...\n\n  const api = useImperativeHandle(ref, () => ({\n    start: () => Promise.all(ctrl.current.map(c => new Promise(r => c.start(r)))),\n    stop: finished => ctrl.current.forEach(c => c.stop(finished)),\n\n    get controllers() {\n      return ctrl.current;\n    }\n\n  })); // This function updates the controllers\n\n  const updateCtrl = useMemo(() => updateProps => ctrl.current.map((c, i) => {\n    c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]);\n    if (!ref) c.start();\n  }), [length]); // Update controller if props aren't functional\n\n  useEffect(() => {\n    if (mounted.current) {\n      if (!isFn) updateCtrl(props);\n    } else if (!ref) ctrl.current.forEach(c => c.start());\n  }); // Update mounted flag and destroy controller on unmount\n\n  useEffect(() => (mounted.current = true, () => ctrl.current.forEach(c => c.destroy())), []); // Return animated props, or, anim-props + the update-setter above\n\n  const propValues = ctrl.current.map(c => c.getValues());\n  return isFn ? [propValues, updateCtrl, finished => ctrl.current.forEach(c => c.pause(finished))] : propValues;\n};\n\n/** API\n * const props = useSpring({ ... })\n * const [props, set] = useSpring(() => ({ ... }))\n */\n\nconst useSpring = props => {\n  const isFn = is.fun(props);\n\n  const _useSprings = useSprings(1, isFn ? props : [props]),\n        result = _useSprings[0],\n        set = _useSprings[1],\n        pause = _useSprings[2];\n\n  return isFn ? [result[0], set, pause] : result;\n};\n\n/** API\n * const trails = useTrail(number, { ... })\n * const [trails, set] = useTrail(number, () => ({ ... }))\n */\n\nconst useTrail = (length, props) => {\n  const mounted = useRef(false);\n  const isFn = is.fun(props);\n  const updateProps = callProp(props);\n  const instances = useRef();\n\n  const _useSprings = useSprings(length, (i, ctrl) => {\n    if (i === 0) instances.current = [];\n    instances.current.push(ctrl);\n    return _extends({}, updateProps, {\n      config: callProp(updateProps.config, i),\n      attach: i > 0 && (() => instances.current[i - 1])\n    });\n  }),\n        result = _useSprings[0],\n        set = _useSprings[1],\n        pause = _useSprings[2]; // Set up function to update controller\n\n\n  const updateCtrl = useMemo(() => props => set((i, ctrl) => {\n    const last = props.reverse ? i === 0 : length - 1 === i;\n    const attachIdx = props.reverse ? i + 1 : i - 1;\n    const attachController = instances.current[attachIdx];\n    return _extends({}, props, {\n      config: callProp(props.config || updateProps.config, i),\n      attach: attachController && (() => attachController)\n    });\n  }), [length, updateProps.reverse]); // Update controller if props aren't functional\n\n  useEffect(() => void (mounted.current && !isFn && updateCtrl(props))); // Update mounted flag and destroy controller on unmount\n\n  useEffect(() => void (mounted.current = true), []);\n  return isFn ? [result, updateCtrl, pause] : result;\n};\n\n/** API\n * const transitions = useTransition(items, itemKeys, { ... })\n * const [transitions, update] = useTransition(items, itemKeys, () => ({ ... }))\n */\n\nlet guid = 0;\nconst ENTER = 'enter';\nconst LEAVE = 'leave';\nconst UPDATE = 'update';\n\nconst mapKeys = (items, keys) => (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String);\n\nconst get = props => {\n  let items = props.items,\n      _props$keys = props.keys,\n      keys = _props$keys === void 0 ? item => item : _props$keys,\n      rest = _objectWithoutPropertiesLoose(props, [\"items\", \"keys\"]);\n\n  items = toArray(items !== void 0 ? items : null);\n  return _extends({\n    items,\n    keys: mapKeys(items, keys)\n  }, rest);\n};\n\nfunction useTransition(input, keyTransform, config) {\n  const props = _extends({\n    items: input,\n    keys: keyTransform || (i => i)\n  }, config);\n\n  const _get = get(props),\n        _get$lazy = _get.lazy,\n        lazy = _get$lazy === void 0 ? false : _get$lazy,\n        _get$unique = _get.unique,\n        _get$reset = _get.reset,\n        reset = _get$reset === void 0 ? false : _get$reset,\n        enter = _get.enter,\n        leave = _get.leave,\n        update = _get.update,\n        onDestroyed = _get.onDestroyed,\n        keys = _get.keys,\n        items = _get.items,\n        onFrame = _get.onFrame,\n        _onRest = _get.onRest,\n        onStart = _get.onStart,\n        ref = _get.ref,\n        extra = _objectWithoutPropertiesLoose(_get, [\"lazy\", \"unique\", \"reset\", \"enter\", \"leave\", \"update\", \"onDestroyed\", \"keys\", \"items\", \"onFrame\", \"onRest\", \"onStart\", \"ref\"]);\n\n  const forceUpdate = useForceUpdate();\n  const mounted = useRef(false);\n  const state = useRef({\n    mounted: false,\n    first: true,\n    deleted: [],\n    current: {},\n    transitions: [],\n    prevProps: {},\n    paused: !!props.ref,\n    instances: !mounted.current && new Map(),\n    forceUpdate\n  });\n  useImperativeHandle(props.ref, () => ({\n    start: () => Promise.all(Array.from(state.current.instances).map((_ref) => {\n      let c = _ref[1];\n      return new Promise(r => c.start(r));\n    })),\n    stop: finished => Array.from(state.current.instances).forEach((_ref2) => {\n      let c = _ref2[1];\n      return c.stop(finished);\n    }),\n\n    get controllers() {\n      return Array.from(state.current.instances).map((_ref3) => {\n        let c = _ref3[1];\n        return c;\n      });\n    }\n\n  })); // Update state\n\n  state.current = diffItems(state.current, props);\n\n  if (state.current.changed) {\n    // Update state\n    state.current.transitions.forEach(transition => {\n      const slot = transition.slot,\n            from = transition.from,\n            to = transition.to,\n            config = transition.config,\n            trail = transition.trail,\n            key = transition.key,\n            item = transition.item;\n      if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object\n\n      const ctrl = state.current.instances.get(key);\n\n      const newProps = _extends({}, extra, {\n        to,\n        from,\n        config,\n        ref,\n        onRest: values => {\n          if (state.current.mounted) {\n            if (transition.destroyed) {\n              // If no ref is given delete destroyed items immediately\n              if (!ref && !lazy) cleanUp(state, key);\n              if (onDestroyed) onDestroyed(item);\n            } // A transition comes to rest once all its springs conclude\n\n\n            const curInstances = Array.from(state.current.instances);\n            const active = curInstances.some((_ref4) => {\n              let c = _ref4[1];\n              return !c.idle;\n            });\n            if (!active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state);\n            if (_onRest) _onRest(item, slot, values);\n          }\n        },\n        onStart: onStart && (() => onStart(item, slot)),\n        onFrame: onFrame && (values => onFrame(item, slot, values)),\n        delay: trail,\n        reset: reset && slot === ENTER // Update controller\n\n      });\n\n      ctrl.update(newProps);\n      if (!state.current.paused) ctrl.start();\n    });\n  }\n\n  useEffect(() => {\n    state.current.mounted = mounted.current = true;\n    return () => {\n      state.current.mounted = mounted.current = false;\n      Array.from(state.current.instances).map((_ref5) => {\n        let c = _ref5[1];\n        return c.destroy();\n      });\n      state.current.instances.clear();\n    };\n  }, []);\n  return state.current.transitions.map((_ref6) => {\n    let item = _ref6.item,\n        slot = _ref6.slot,\n        key = _ref6.key;\n    return {\n      item,\n      key,\n      state: slot,\n      props: state.current.instances.get(key).getValues()\n    };\n  });\n}\n\nfunction cleanUp(state, filterKey) {\n  const deleted = state.current.deleted;\n\n  for (let _ref7 of deleted) {\n    let key = _ref7.key;\n\n    const filter = t => t.key !== key;\n\n    if (is.und(filterKey) || filterKey === key) {\n      state.current.instances.delete(key);\n      state.current.transitions = state.current.transitions.filter(filter);\n      state.current.deleted = state.current.deleted.filter(filter);\n    }\n  }\n\n  state.current.forceUpdate();\n}\n\nfunction diffItems(_ref8, props) {\n  let first = _ref8.first,\n      prevProps = _ref8.prevProps,\n      state = _objectWithoutPropertiesLoose(_ref8, [\"first\", \"prevProps\"]);\n\n  let _get2 = get(props),\n      items = _get2.items,\n      keys = _get2.keys,\n      initial = _get2.initial,\n      from = _get2.from,\n      enter = _get2.enter,\n      leave = _get2.leave,\n      update = _get2.update,\n      _get2$trail = _get2.trail,\n      trail = _get2$trail === void 0 ? 0 : _get2$trail,\n      unique = _get2.unique,\n      config = _get2.config,\n      _get2$order = _get2.order,\n      order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order;\n\n  let _get3 = get(prevProps),\n      _keys = _get3.keys,\n      _items = _get3.items;\n\n  let current = _extends({}, state.current);\n\n  let deleted = [...state.deleted]; // Compare next keys with current keys\n\n  let currentKeys = Object.keys(current);\n  let currentSet = new Set(currentKeys);\n  let nextSet = new Set(keys);\n  let added = keys.filter(item => !currentSet.has(item));\n  let removed = state.transitions.filter(item => !item.destroyed && !nextSet.has(item.originalKey)).map(i => i.originalKey);\n  let updated = keys.filter(item => currentSet.has(item));\n  let delay = -trail;\n\n  while (order.length) {\n    const changeType = order.shift();\n\n    switch (changeType) {\n      case ENTER:\n        {\n          added.forEach((key, index) => {\n            // In unique mode, remove fading out transitions if their key comes in again\n            if (unique && deleted.find(d => d.originalKey === key)) deleted = deleted.filter(t => t.originalKey !== key);\n            const keyIndex = keys.indexOf(key);\n            const item = items[keyIndex];\n            const slot = first && initial !== void 0 ? 'initial' : ENTER;\n            current[key] = {\n              slot,\n              originalKey: key,\n              key: unique ? String(key) : guid++,\n              item,\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item),\n              to: callProp(enter, item)\n            };\n          });\n          break;\n        }\n\n      case LEAVE:\n        {\n          removed.forEach(key => {\n            const keyIndex = _keys.indexOf(key);\n\n            const item = _items[keyIndex];\n            const slot = LEAVE;\n            deleted.unshift(_extends({}, current[key], {\n              slot,\n              destroyed: true,\n              left: _keys[Math.max(0, keyIndex - 1)],\n              right: _keys[Math.min(_keys.length, keyIndex + 1)],\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              to: callProp(leave, item)\n            }));\n            delete current[key];\n          });\n          break;\n        }\n\n      case UPDATE:\n        {\n          updated.forEach(key => {\n            const keyIndex = keys.indexOf(key);\n            const item = items[keyIndex];\n            const slot = UPDATE;\n            current[key] = _extends({}, current[key], {\n              item,\n              slot,\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              to: callProp(update, item)\n            });\n          });\n          break;\n        }\n    }\n  }\n\n  let out = keys.map(key => current[key]); // This tries to restore order for deleted items by finding their last known siblings\n  // only using the left sibling to keep order placement consistent for all deleted items\n\n  deleted.forEach((_ref9) => {\n    let left = _ref9.left,\n        right = _ref9.right,\n        item = _objectWithoutPropertiesLoose(_ref9, [\"left\", \"right\"]);\n\n    let pos; // Was it the element on the left, if yes, move there ...\n\n    if ((pos = out.findIndex(t => t.originalKey === left)) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\\_(ツ)_/¯\n\n    pos = Math.max(0, pos);\n    out = [...out.slice(0, pos), item, ...out.slice(pos)];\n  });\n  return _extends({}, state, {\n    changed: added.length || removed.length || updated.length,\n    first: first && added.length === 0,\n    transitions: out,\n    current,\n    deleted,\n    prevProps: props\n  });\n}\n\nclass AnimatedStyle extends AnimatedObject {\n  constructor(style) {\n    if (style === void 0) {\n      style = {};\n    }\n\n    super();\n\n    if (style.transform && !(style.transform instanceof Animated)) {\n      style = applyAnimatedValues.transform(style);\n    }\n\n    this.payload = style;\n  }\n\n}\n\n// http://www.w3.org/TR/css3-color/#svg-color\nconst colors = {\n  transparent: 0x00000000,\n  aliceblue: 0xf0f8ffff,\n  antiquewhite: 0xfaebd7ff,\n  aqua: 0x00ffffff,\n  aquamarine: 0x7fffd4ff,\n  azure: 0xf0ffffff,\n  beige: 0xf5f5dcff,\n  bisque: 0xffe4c4ff,\n  black: 0x000000ff,\n  blanchedalmond: 0xffebcdff,\n  blue: 0x0000ffff,\n  blueviolet: 0x8a2be2ff,\n  brown: 0xa52a2aff,\n  burlywood: 0xdeb887ff,\n  burntsienna: 0xea7e5dff,\n  cadetblue: 0x5f9ea0ff,\n  chartreuse: 0x7fff00ff,\n  chocolate: 0xd2691eff,\n  coral: 0xff7f50ff,\n  cornflowerblue: 0x6495edff,\n  cornsilk: 0xfff8dcff,\n  crimson: 0xdc143cff,\n  cyan: 0x00ffffff,\n  darkblue: 0x00008bff,\n  darkcyan: 0x008b8bff,\n  darkgoldenrod: 0xb8860bff,\n  darkgray: 0xa9a9a9ff,\n  darkgreen: 0x006400ff,\n  darkgrey: 0xa9a9a9ff,\n  darkkhaki: 0xbdb76bff,\n  darkmagenta: 0x8b008bff,\n  darkolivegreen: 0x556b2fff,\n  darkorange: 0xff8c00ff,\n  darkorchid: 0x9932ccff,\n  darkred: 0x8b0000ff,\n  darksalmon: 0xe9967aff,\n  darkseagreen: 0x8fbc8fff,\n  darkslateblue: 0x483d8bff,\n  darkslategray: 0x2f4f4fff,\n  darkslategrey: 0x2f4f4fff,\n  darkturquoise: 0x00ced1ff,\n  darkviolet: 0x9400d3ff,\n  deeppink: 0xff1493ff,\n  deepskyblue: 0x00bfffff,\n  dimgray: 0x696969ff,\n  dimgrey: 0x696969ff,\n  dodgerblue: 0x1e90ffff,\n  firebrick: 0xb22222ff,\n  floralwhite: 0xfffaf0ff,\n  forestgreen: 0x228b22ff,\n  fuchsia: 0xff00ffff,\n  gainsboro: 0xdcdcdcff,\n  ghostwhite: 0xf8f8ffff,\n  gold: 0xffd700ff,\n  goldenrod: 0xdaa520ff,\n  gray: 0x808080ff,\n  green: 0x008000ff,\n  greenyellow: 0xadff2fff,\n  grey: 0x808080ff,\n  honeydew: 0xf0fff0ff,\n  hotpink: 0xff69b4ff,\n  indianred: 0xcd5c5cff,\n  indigo: 0x4b0082ff,\n  ivory: 0xfffff0ff,\n  khaki: 0xf0e68cff,\n  lavender: 0xe6e6faff,\n  lavenderblush: 0xfff0f5ff,\n  lawngreen: 0x7cfc00ff,\n  lemonchiffon: 0xfffacdff,\n  lightblue: 0xadd8e6ff,\n  lightcoral: 0xf08080ff,\n  lightcyan: 0xe0ffffff,\n  lightgoldenrodyellow: 0xfafad2ff,\n  lightgray: 0xd3d3d3ff,\n  lightgreen: 0x90ee90ff,\n  lightgrey: 0xd3d3d3ff,\n  lightpink: 0xffb6c1ff,\n  lightsalmon: 0xffa07aff,\n  lightseagreen: 0x20b2aaff,\n  lightskyblue: 0x87cefaff,\n  lightslategray: 0x778899ff,\n  lightslategrey: 0x778899ff,\n  lightsteelblue: 0xb0c4deff,\n  lightyellow: 0xffffe0ff,\n  lime: 0x00ff00ff,\n  limegreen: 0x32cd32ff,\n  linen: 0xfaf0e6ff,\n  magenta: 0xff00ffff,\n  maroon: 0x800000ff,\n  mediumaquamarine: 0x66cdaaff,\n  mediumblue: 0x0000cdff,\n  mediumorchid: 0xba55d3ff,\n  mediumpurple: 0x9370dbff,\n  mediumseagreen: 0x3cb371ff,\n  mediumslateblue: 0x7b68eeff,\n  mediumspringgreen: 0x00fa9aff,\n  mediumturquoise: 0x48d1ccff,\n  mediumvioletred: 0xc71585ff,\n  midnightblue: 0x191970ff,\n  mintcream: 0xf5fffaff,\n  mistyrose: 0xffe4e1ff,\n  moccasin: 0xffe4b5ff,\n  navajowhite: 0xffdeadff,\n  navy: 0x000080ff,\n  oldlace: 0xfdf5e6ff,\n  olive: 0x808000ff,\n  olivedrab: 0x6b8e23ff,\n  orange: 0xffa500ff,\n  orangered: 0xff4500ff,\n  orchid: 0xda70d6ff,\n  palegoldenrod: 0xeee8aaff,\n  palegreen: 0x98fb98ff,\n  paleturquoise: 0xafeeeeff,\n  palevioletred: 0xdb7093ff,\n  papayawhip: 0xffefd5ff,\n  peachpuff: 0xffdab9ff,\n  peru: 0xcd853fff,\n  pink: 0xffc0cbff,\n  plum: 0xdda0ddff,\n  powderblue: 0xb0e0e6ff,\n  purple: 0x800080ff,\n  rebeccapurple: 0x663399ff,\n  red: 0xff0000ff,\n  rosybrown: 0xbc8f8fff,\n  royalblue: 0x4169e1ff,\n  saddlebrown: 0x8b4513ff,\n  salmon: 0xfa8072ff,\n  sandybrown: 0xf4a460ff,\n  seagreen: 0x2e8b57ff,\n  seashell: 0xfff5eeff,\n  sienna: 0xa0522dff,\n  silver: 0xc0c0c0ff,\n  skyblue: 0x87ceebff,\n  slateblue: 0x6a5acdff,\n  slategray: 0x708090ff,\n  slategrey: 0x708090ff,\n  snow: 0xfffafaff,\n  springgreen: 0x00ff7fff,\n  steelblue: 0x4682b4ff,\n  tan: 0xd2b48cff,\n  teal: 0x008080ff,\n  thistle: 0xd8bfd8ff,\n  tomato: 0xff6347ff,\n  turquoise: 0x40e0d0ff,\n  violet: 0xee82eeff,\n  wheat: 0xf5deb3ff,\n  white: 0xffffffff,\n  whitesmoke: 0xf5f5f5ff,\n  yellow: 0xffff00ff,\n  yellowgreen: 0x9acd32ff\n};\n\n// const INTEGER = '[-+]?\\\\d+';\nconst NUMBER = '[-+]?\\\\d*\\\\.?\\\\d+';\nconst PERCENTAGE = NUMBER + '%';\n\nfunction call() {\n  for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {\n    parts[_key] = arguments[_key];\n  }\n\n  return '\\\\(\\\\s*(' + parts.join(')\\\\s*,\\\\s*(') + ')\\\\s*\\\\)';\n}\n\nconst rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));\nconst rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));\nconst hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));\nconst hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));\nconst hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nconst hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nconst hex6 = /^#([0-9a-fA-F]{6})$/;\nconst hex8 = /^#([0-9a-fA-F]{8})$/;\n\n/*\nhttps://github.com/react-community/normalize-css-color\n\nBSD 3-Clause License\n\nCopyright (c) 2016, React Community\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n  list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n  this list of conditions and the following disclaimer in the documentation\n  and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n  contributors may be used to endorse or promote products derived from\n  this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\nfunction normalizeColor(color) {\n  let match;\n\n  if (typeof color === 'number') {\n    return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null;\n  } // Ordered based on occurrences on Facebook codebase\n\n\n  if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;\n  if (colors.hasOwnProperty(color)) return colors[color];\n\n  if (match = rgb.exec(color)) {\n    return (parse255(match[1]) << 24 | // r\n    parse255(match[2]) << 16 | // g\n    parse255(match[3]) << 8 | // b\n    0x000000ff) >>> // a\n    0;\n  }\n\n  if (match = rgba.exec(color)) {\n    return (parse255(match[1]) << 24 | // r\n    parse255(match[2]) << 16 | // g\n    parse255(match[3]) << 8 | // b\n    parse1(match[4])) >>> // a\n    0;\n  }\n\n  if (match = hex3.exec(color)) {\n    return parseInt(match[1] + match[1] + // r\n    match[2] + match[2] + // g\n    match[3] + match[3] + // b\n    'ff', // a\n    16) >>> 0;\n  } // https://drafts.csswg.org/css-color-4/#hex-notation\n\n\n  if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;\n\n  if (match = hex4.exec(color)) {\n    return parseInt(match[1] + match[1] + // r\n    match[2] + match[2] + // g\n    match[3] + match[3] + // b\n    match[4] + match[4], // a\n    16) >>> 0;\n  }\n\n  if (match = hsl.exec(color)) {\n    return (hslToRgb(parse360(match[1]), // h\n    parsePercentage(match[2]), // s\n    parsePercentage(match[3]) // l\n    ) | 0x000000ff) >>> // a\n    0;\n  }\n\n  if (match = hsla.exec(color)) {\n    return (hslToRgb(parse360(match[1]), // h\n    parsePercentage(match[2]), // s\n    parsePercentage(match[3]) // l\n    ) | parse1(match[4])) >>> // a\n    0;\n  }\n\n  return null;\n}\n\nfunction hue2rgb(p, q, t) {\n  if (t < 0) t += 1;\n  if (t > 1) t -= 1;\n  if (t < 1 / 6) return p + (q - p) * 6 * t;\n  if (t < 1 / 2) return q;\n  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n  return p;\n}\n\nfunction hslToRgb(h, s, l) {\n  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n  const p = 2 * l - q;\n  const r = hue2rgb(p, q, h + 1 / 3);\n  const g = hue2rgb(p, q, h);\n  const b = hue2rgb(p, q, h - 1 / 3);\n  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;\n}\n\nfunction parse255(str) {\n  const int = parseInt(str, 10);\n  if (int < 0) return 0;\n  if (int > 255) return 255;\n  return int;\n}\n\nfunction parse360(str) {\n  const int = parseFloat(str);\n  return (int % 360 + 360) % 360 / 360;\n}\n\nfunction parse1(str) {\n  const num = parseFloat(str);\n  if (num < 0) return 0;\n  if (num > 1) return 255;\n  return Math.round(num * 255);\n}\n\nfunction parsePercentage(str) {\n  // parseFloat conveniently ignores the final %\n  const int = parseFloat(str);\n  if (int < 0) return 0;\n  if (int > 100) return 1;\n  return int / 100;\n}\n\nfunction colorToRgba(input) {\n  let int32Color = normalizeColor(input);\n  if (int32Color === null) return input;\n  int32Color = int32Color || 0;\n  let r = (int32Color & 0xff000000) >>> 24;\n  let g = (int32Color & 0x00ff0000) >>> 16;\n  let b = (int32Color & 0x0000ff00) >>> 8;\n  let a = (int32Color & 0x000000ff) / 255;\n  return `rgba(${r}, ${g}, ${b}, ${a})`;\n} // Problem: https://github.com/animatedjs/animated/pull/102\n// Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662\n\n\nconst stringShapeRegex = /[+\\-]?(?:0|[1-9]\\d*)(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g; // Covers rgb, rgba, hsl, hsla\n// Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e\n\nconst colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d\\.]+%?\\))/gi; // Covers color names (transparent, blue, etc.)\n\nconst colorNamesRegex = new RegExp(`(${Object.keys(colors).join('|')})`, 'g');\n/**\n * Supports string shapes by extracting numbers so new values can be computed,\n * and recombines those values into new strings of the same shape.  Supports\n * things like:\n *\n *   rgba(123, 42, 99, 0.36)           // colors\n *   -45deg                            // values with units\n *   0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows\n */\n\nconst createStringInterpolator = config => {\n  // Replace colors with rgba\n  const outputRange = config.output.map(rangeValue => rangeValue.replace(colorRegex, colorToRgba)).map(rangeValue => rangeValue.replace(colorNamesRegex, colorToRgba));\n  const outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);\n  outputRange.forEach(value => {\n    value.match(stringShapeRegex).forEach((number, i) => outputRanges[i].push(+number));\n  });\n  const interpolations = outputRange[0].match(stringShapeRegex).map((_value, i) => createInterpolator(_extends({}, config, {\n    output: outputRanges[i]\n  })));\n  return input => {\n    let i = 0;\n    return outputRange[0] // 'rgba(0, 100, 200, 0)'\n    // ->\n    // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'\n    .replace(stringShapeRegex, () => interpolations[i++](input)) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to\n    // round the opacity (4th column).\n    .replace(/rgba\\(([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+)\\)/gi, (_, p1, p2, p3, p4) => `rgba(${Math.round(p1)}, ${Math.round(p2)}, ${Math.round(p3)}, ${p4})`);\n  };\n};\n\nlet isUnitlessNumber = {\n  animationIterationCount: true,\n  borderImageOutset: true,\n  borderImageSlice: true,\n  borderImageWidth: true,\n  boxFlex: true,\n  boxFlexGroup: true,\n  boxOrdinalGroup: true,\n  columnCount: true,\n  columns: true,\n  flex: true,\n  flexGrow: true,\n  flexPositive: true,\n  flexShrink: true,\n  flexNegative: true,\n  flexOrder: true,\n  gridRow: true,\n  gridRowEnd: true,\n  gridRowSpan: true,\n  gridRowStart: true,\n  gridColumn: true,\n  gridColumnEnd: true,\n  gridColumnSpan: true,\n  gridColumnStart: true,\n  fontWeight: true,\n  lineClamp: true,\n  lineHeight: true,\n  opacity: true,\n  order: true,\n  orphans: true,\n  tabSize: true,\n  widows: true,\n  zIndex: true,\n  zoom: true,\n  // SVG-related properties\n  fillOpacity: true,\n  floodOpacity: true,\n  stopOpacity: true,\n  strokeDasharray: true,\n  strokeDashoffset: true,\n  strokeMiterlimit: true,\n  strokeOpacity: true,\n  strokeWidth: true\n};\n\nconst prefixKey = (prefix, key) => prefix + key.charAt(0).toUpperCase() + key.substring(1);\n\nconst prefixes = ['Webkit', 'Ms', 'Moz', 'O'];\nisUnitlessNumber = Object.keys(isUnitlessNumber).reduce((acc, prop) => {\n  prefixes.forEach(prefix => acc[prefixKey(prefix, prop)] = acc[prop]);\n  return acc;\n}, isUnitlessNumber);\n\nfunction dangerousStyleValue(name, value, isCustomProperty) {\n  if (value == null || typeof value === 'boolean' || value === '') return '';\n  if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n\n  return ('' + value).trim();\n}\n\nconst attributeCache = {};\ninjectCreateAnimatedStyle(style => new AnimatedStyle(style));\ninjectDefaultElement('div');\ninjectStringInterpolator(createStringInterpolator);\ninjectColorNames(colors);\ninjectApplyAnimatedValues((instance, props) => {\n  if (instance.nodeType && instance.setAttribute !== undefined) {\n    const style = props.style,\n          children = props.children,\n          scrollTop = props.scrollTop,\n          scrollLeft = props.scrollLeft,\n          attributes = _objectWithoutPropertiesLoose(props, [\"style\", \"children\", \"scrollTop\", \"scrollLeft\"]);\n\n    const filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';\n    if (scrollTop !== void 0) instance.scrollTop = scrollTop;\n    if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value\n\n    if (children !== void 0) instance.textContent = children; // Set styles ...\n\n    for (let styleName in style) {\n      if (!style.hasOwnProperty(styleName)) continue;\n      var isCustomProperty = styleName.indexOf('--') === 0;\n      var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty);\n      if (styleName === 'float') styleName = 'cssFloat';\n      if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue;\n    } // Set attributes ...\n\n\n    for (let name in attributes) {\n      // Attributes are written in dash case\n      const dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, n => '-' + n.toLowerCase()));\n      if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]);\n    }\n\n    return;\n  } else return false;\n}, style => style);\n\nconst domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG\n'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];\n// Extend animated with all the available THREE elements\nconst apply = merge(createAnimatedComponent, false);\nconst extendedAnimated = apply(domElements);\n\nexport { apply, config, update, extendedAnimated as animated, extendedAnimated as a, interpolate$1 as interpolate, Globals, useSpring, useTrail, useTransition, useChain, useSprings };\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n"],"sourceRoot":""}