{"version":3,"sources":["webpack:///./node_modules/lodash-es/isArray.js","webpack:///./node_modules/lodash-es/_isKey.js","webpack:///./node_modules/lodash-es/memoize.js","webpack:///./node_modules/lodash-es/_memoizeCapped.js","webpack:///./node_modules/lodash-es/_stringToPath.js","webpack:///./node_modules/lodash-es/_castPath.js","webpack:///./node_modules/lodash-es/_toKey.js","webpack:///./node_modules/lodash-es/_baseGet.js","webpack:///./node_modules/lodash-es/get.js","webpack:///./node_modules/lodash-es/_isMasked.js","webpack:///./node_modules/lodash-es/_coreJsData.js","webpack:///./node_modules/lodash-es/_baseIsNative.js","webpack:///./node_modules/lodash-es/_getValue.js","webpack:///./node_modules/lodash-es/_getNative.js","webpack:///./node_modules/@netc/lazy/src/Lazy.js","webpack:///./node_modules/@netc/lazy/src/index.js","webpack:///./node_modules/body-scroll-lock/lib/bodyScrollLock.min.js","webpack:///./node_modules/query-string/index.js","webpack:///./node_modules/lodash-es/_listCacheClear.js","webpack:///./node_modules/lodash-es/_assocIndexOf.js","webpack:///./node_modules/lodash-es/_listCacheDelete.js","webpack:///./node_modules/lodash-es/_listCacheGet.js","webpack:///./node_modules/lodash-es/_listCacheHas.js","webpack:///./node_modules/lodash-es/_listCacheSet.js","webpack:///./node_modules/lodash-es/_ListCache.js","webpack:///./node_modules/lodash-es/_Map.js","webpack:///./node_modules/lodash-es/_arrayMap.js","webpack:///./node_modules/lodash-es/_baseToString.js","webpack:///./node_modules/lodash-es/toString.js","webpack:///./node_modules/lodash-es/isFunction.js","webpack:///./node_modules/lodash-es/_toSource.js","webpack:///./node_modules/lodash-es/eq.js","webpack:///./node_modules/lodash-es/isNil.js","webpack:///./node_modules/query-string/node_modules/strict-uri-encode/index.js","webpack:///./node_modules/decode-uri-component/index.js","webpack:///./node_modules/split-on-first/index.js","webpack:///./node_modules/lodash-es/_nativeCreate.js","webpack:///./node_modules/lodash-es/_hashClear.js","webpack:///./node_modules/lodash-es/_hashDelete.js","webpack:///./node_modules/lodash-es/_hashGet.js","webpack:///./node_modules/lodash-es/_hashHas.js","webpack:///./node_modules/lodash-es/_hashSet.js","webpack:///./node_modules/lodash-es/_Hash.js","webpack:///./node_modules/lodash-es/_mapCacheClear.js","webpack:///./node_modules/lodash-es/_isKeyable.js","webpack:///./node_modules/lodash-es/_getMapData.js","webpack:///./node_modules/lodash-es/_mapCacheDelete.js","webpack:///./node_modules/lodash-es/_mapCacheGet.js","webpack:///./node_modules/lodash-es/_mapCacheHas.js","webpack:///./node_modules/lodash-es/_mapCacheSet.js","webpack:///./node_modules/lodash-es/_MapCache.js","webpack:///./node_modules/hammerjs/hammer.js"],"names":["isArray","Array","reIsDeepProp","reIsPlainProp","isKey","value","object","type","_typeof","isSymbol","test","Object","FUNC_ERROR_TEXT","memoize","func","resolver","TypeError","memoized","args","arguments","key","apply","this","cache","has","get","result","set","Cache","MapCache","MAX_MEMOIZE_SIZE","memoizeCapped","rePropName","reEscapeChar","stringToPath","size","clear","string","charCodeAt","push","replace","match","number","quote","subString","castPath","toString","INFINITY","toKey","baseGet","path","index","length","undefined","defaultValue","uid","coreJsData","root","maskSrcKey","exec","keys","IE_PROTO","isMasked","reIsHostCtor","funcProto","Function","prototype","objectProto","funcToString","hasOwnProperty","reIsNative","RegExp","call","baseIsNative","isObject","isFunction","toSource","getValue","getNative","baseObserverOptions","threshold","rootMargin","Lazy","_this","observerOptions","_classCallCheck","_defineProperty","element","callback","sendElementToCallback","callbacks","observer","observe","handleBgImages","handleSrcImages","entries","forEach","event","isIntersecting","pair","find","x","target","IntersectionObserver","handleEntries","url","getAttribute","image","Image","addEventListener","removeAttribute","setAttribute","concat","classList","add","src","window","setTimeout","__webpack_require__","d","__webpack_exports__","src_Lazy","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","exports","r","e","t","o","from","defineProperty","l","passive","removeEventListener","navigator","platform","c","u","a","s","v","f","some","options","allowTouchMove","m","touches","preventDefault","document","body","style","paddingRight","overflow","disableBodyScroll","i","console","error","targetElement","ontouchstart","targetTouches","clientY","ontouchmove","n","scrollTop","scrollHeight","clientHeight","stopPropagation","reserveScrollBarGap","innerWidth","documentElement","clientWidth","clearAllBodyScrollLocks","enableBodyScroll","filter","module","strictUriEncode","require","decodeComponent","splitOnFirst","validateArrayFormatSeparator","encode","strict","encodeURIComponent","decode","removeHash","input","hashStart","indexOf","slice","extract","queryStart","parseValue","parseNumbers","Number","isNaN","trim","parseBooleans","toLowerCase","parse","assign","sort","arrayFormat","arrayFormatSeparator","formatter","accumulator","newValue","split","map","item","parserForArrayFormat","ret","create","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","Symbol","iterator","next","done","param","_splitOnFirst2","_slicedToArray","includes","err","return","_i","_Object$keys","_i2","_Object$keys2","k","reduce","Boolean","keysSorter","b","stringify","shouldFilter","skipNull","skipEmptyString","_toConsumableArray","join","encoderForArrayFormat","objectCopy","_i3","_Object$keys3","parseUrl","_splitOnFirst4","hash","query","parseFragmentIdentifier","fragmentIdentifier","stringifyUrl","queryFromUrl","parsedQueryFromUrl","queryString","getHash","listCacheClear","__data__","assocIndexOf","array","eq","splice","listCacheDelete","data","pop","listCacheGet","listCacheHas","listCacheSet","ListCache","entry","_getNative_js__WEBPACK_IMPORTED_MODULE_0__","_root_js__WEBPACK_IMPORTED_MODULE_1__","Map","arrayMap","iteratee","symbolProto","symbolToString","baseToString","_baseGetTag_js__WEBPACK_IMPORTED_MODULE_0__","_isObject_js__WEBPACK_IMPORTED_MODULE_1__","asyncTag","funcTag","genTag","proxyTag","tag","baseGetTag","other","isNil","str","toUpperCase","singleMatcher","multiMatcher","decodeComponents","components","decodeURIComponent","left","right","tokens","encodedURI","replaceMap","%FE%FF","%FF%FE","customDecodeURIComponent","separator","separatorIndex","nativeCreate","hashClear","hashDelete","HASH_UNDEFINED","hashGet","hashHas","hashSet","Hash","mapCacheClear","isKeyable","getMapData","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","exportName","VENDOR_PREFIXES","TEST_ELEMENT","createElement","TYPE_FUNCTION","round","Math","abs","now","Date","setTimeoutContext","fn","timeout","context","bindFn","invokeArrayArg","arg","each","obj","deprecate","method","name","message","deprecationMessage","Error","stack","log","warn","output","source","nextKey","extend","dest","merge","inherit","child","base","properties","childP","baseP","constructor","_super","boolOrFn","val","ifUndefined","val1","val2","addEventListeners","types","handler","splitStr","removeEventListeners","hasParent","node","parent","parentNode","inStr","inArray","findByKey","toArray","uniqueArray","results","values","prefixed","property","prefix","prop","camelProp","_uniqueId","getWindowForElement","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","userAgent","COMPUTE_INTERVAL","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","PROPS_XY","PROPS_CLIENT_XY","Input","manager","self","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","deltaX","y","deltaY","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","scale","start","end","rotation","getRotation","maxPointers","velocity","velocityX","velocityY","direction","last","lastInterval","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","p1","p2","props","sqrt","atan2","PI","evEl","evTarget","evWin","destroy","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","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","SINGLE_TOUCH_TARGET_EVENTS","SINGLE_TOUCH_WINDOW_EVENTS","SingleTouchInput","started","all","changed","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","allTouches","identifier","changedTargetTouches","touch","DEDUP_TIMEOUT","DEDUP_DISTANCE","TouchMouseInput","mouse","primaryTouch","lastTouches","setLastTouch","eventData","lastTouch","lts","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","dx","dy","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","compute","actions","update","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","Recognizer","defaults","id","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","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","reset","process","attrTest","optionPointers","isRecognized","isValid","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","clearTimeout","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","inputClass","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","handlers","oldCssProps","toggleCssProps","stop","force","stopped","curRecognizer","existing","remove","on","events","off","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","STATE_FAILED","Tap","Pan","Swipe","Pinch","Rotate","Press"],"mappings":"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","file":"vendors~product-listing~product-range~product-search-results~promo-product-listing~trades-product-li~bd47ceab-206f526ec3ddd65211b5.js","sourcesContent":["/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nexport default isArray;\n","import isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  if (isArray(value)) {\n    return false;\n  }\n  var type = typeof value;\n  if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n      value == null || isSymbol(value)) {\n    return true;\n  }\n  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n    (object != null && value in Object(object));\n}\n\nexport default isKey;\n","import MapCache from './_MapCache.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nexport default memoize;\n","import memoize from './memoize.js';\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n  var result = memoize(func, function(key) {\n    if (cache.size === MAX_MEMOIZE_SIZE) {\n      cache.clear();\n    }\n    return key;\n  });\n\n  var cache = result.cache;\n  return result;\n}\n\nexport default memoizeCapped;\n","import memoizeCapped from './_memoizeCapped.js';\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n  var result = [];\n  if (string.charCodeAt(0) === 46 /* . */) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, subString) {\n    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\nexport default stringToPath;\n","import isArray from './isArray.js';\nimport isKey from './_isKey.js';\nimport stringToPath from './_stringToPath.js';\nimport toString from './toString.js';\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n  if (isArray(value)) {\n    return value;\n  }\n  return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nexport default castPath;\n","import isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default toKey;\n","import castPath from './_castPath.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n  path = castPath(path, object);\n\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[toKey(path[index++])];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nexport default baseGet;\n","import baseGet from './_baseGet.js';\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n  var result = object == null ? undefined : baseGet(object, path);\n  return result === undefined ? defaultValue : result;\n}\n\nexport default get;\n","import coreJsData from './_coreJsData.js';\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nexport default isMasked;\n","import root from './_root.js';\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nexport default coreJsData;\n","import isFunction from './isFunction.js';\nimport isMasked from './_isMasked.js';\nimport isObject from './isObject.js';\nimport toSource from './_toSource.js';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nexport default baseIsNative;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nexport default getValue;\n","import baseIsNative from './_baseIsNative.js';\nimport getValue from './_getValue.js';\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nexport default getNative;\n","const baseObserverOptions = {\r\n  threshold: 0.01,\r\n  rootMargin: '0px',\r\n};\r\n\r\nclass Lazy {\r\n  constructor(observerOptions = baseObserverOptions) {\r\n    this.observer = new IntersectionObserver(\r\n      entries => this.handleEntries(entries),\r\n      observerOptions,\r\n    );\r\n    this.callbacks = [];\r\n  }\r\n\r\n  /**\r\n   * Registers a new element with a callback, this is called when the element enters the viewport\r\n   */\r\n  registerNewElement = (element, callback, sendElementToCallback) => {\r\n    this.callbacks.push({ element, callback, sendElementToCallback });\r\n    this.observer.observe(element);\r\n  };\r\n\r\n  /**\r\n   * Registers a new element to load the data-src as a background image when entering the viewport\r\n   */\r\n  registerBackgroundImageElement = element => {\r\n    this.callbacks.push({ element, callback: this.handleBgImages, sendElementToCallback: true });\r\n    this.observer.observe(element);\r\n  };\r\n\r\n  /**\r\n   * Registers a new image element to load the data-src as the image src when entering the viewport\r\n   */\r\n  registerImageElement = element => {\r\n    this.callbacks.push({ element, callback: this.handleSrcImages, sendElementToCallback: true });\r\n    this.observer.observe(element);\r\n  };\r\n\r\n  /**\r\n   * handle entries run when a new element is observed (comes into view)\r\n   */\r\n  handleEntries = entries => {\r\n    Array.forEach(entries, event => {\r\n      if (!event.isIntersecting) {\r\n        return;\r\n      }\r\n\r\n      const pair = this.callbacks.find(x => x.element === event.target);\r\n\r\n      if (pair.sendElementToCallback) {\r\n        pair.callback(pair.element);\r\n      } else {\r\n        pair.callback();\r\n      }\r\n    });\r\n  };\r\n\r\n  /* built in styling functions */\r\n  handleBgImages(element) {\r\n    // Get the image url\r\n    const url = element.getAttribute('data-src');\r\n\r\n    if (url !== null && url !== '' && url !== undefined) {\r\n      // Create a new \"image\" object\r\n      const image = new Image();\r\n\r\n      // Add the load event\r\n      image.addEventListener('load', () => {\r\n        element.removeAttribute('data-src', url);\r\n        element.setAttribute('style', `background-image: url('${url}');`);\r\n        element.classList.add('loaded');\r\n      });\r\n\r\n      // Set the src\r\n      image.src = url;\r\n    }\r\n  }\r\n\r\n  handleSrcImages(element) {\r\n    // Get the image url\r\n    const url = element.getAttribute('data-src');\r\n    if (url !== null && url !== '' && url !== undefined) {\r\n      // Create a new \"image\" object\r\n      const image = new Image();\r\n\r\n      // Add the load event\r\n      image.addEventListener('load', () => {\r\n        element.removeAttribute('data-src', url);\r\n        element.setAttribute('src', url);\r\n        window.setTimeout(() => {\r\n          element.classList.add('loaded');\r\n        }, 50);\r\n      });\r\n\r\n      // Set the src\r\n      image.src = url;\r\n    }\r\n  }\r\n}\r\n\r\nexport default Lazy;\r\n","import _lazy from './Lazy';\r\n\r\nexport { _lazy as Lazy };\r\n","!function(e,t){if(\"function\"==typeof define&&define.amd)define([\"exports\"],t);else if(\"undefined\"!=typeof exports)t(exports);else{var o={};t(o),e.bodyScrollLock=o}}(this,function(exports){\"use strict\";function r(e){if(Array.isArray(e)){for(var t=0,o=Array(e.length);t<e.length;t++)o[t]=e[t];return o}return Array.from(e)}Object.defineProperty(exports,\"__esModule\",{value:!0});var l=!1;if(\"undefined\"!=typeof window){var e={get passive(){l=!0}};window.addEventListener(\"testPassive\",null,e),window.removeEventListener(\"testPassive\",null,e)}var d=\"undefined\"!=typeof window&&window.navigator&&window.navigator.platform&&/iP(ad|hone|od)/.test(window.navigator.platform),c=[],u=!1,a=-1,s=void 0,v=void 0,f=function(t){return c.some(function(e){return!(!e.options.allowTouchMove||!e.options.allowTouchMove(t))})},m=function(e){var t=e||window.event;return!!f(t.target)||(1<t.touches.length||(t.preventDefault&&t.preventDefault(),!1))},o=function(){setTimeout(function(){void 0!==v&&(document.body.style.paddingRight=v,v=void 0),void 0!==s&&(document.body.style.overflow=s,s=void 0)})};exports.disableBodyScroll=function(i,e){if(d){if(!i)return void console.error(\"disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.\");if(i&&!c.some(function(e){return e.targetElement===i})){var t={targetElement:i,options:e||{}};c=[].concat(r(c),[t]),i.ontouchstart=function(e){1===e.targetTouches.length&&(a=e.targetTouches[0].clientY)},i.ontouchmove=function(e){var t,o,n,r;1===e.targetTouches.length&&(o=i,r=(t=e).targetTouches[0].clientY-a,!f(t.target)&&(o&&0===o.scrollTop&&0<r?m(t):(n=o)&&n.scrollHeight-n.scrollTop<=n.clientHeight&&r<0?m(t):t.stopPropagation()))},u||(document.addEventListener(\"touchmove\",m,l?{passive:!1}:void 0),u=!0)}}else{n=e,setTimeout(function(){if(void 0===v){var e=!!n&&!0===n.reserveScrollBarGap,t=window.innerWidth-document.documentElement.clientWidth;e&&0<t&&(v=document.body.style.paddingRight,document.body.style.paddingRight=t+\"px\")}void 0===s&&(s=document.body.style.overflow,document.body.style.overflow=\"hidden\")});var o={targetElement:i,options:e||{}};c=[].concat(r(c),[o])}var n},exports.clearAllBodyScrollLocks=function(){d?(c.forEach(function(e){e.targetElement.ontouchstart=null,e.targetElement.ontouchmove=null}),u&&(document.removeEventListener(\"touchmove\",m,l?{passive:!1}:void 0),u=!1),c=[],a=-1):(o(),c=[])},exports.enableBodyScroll=function(t){if(d){if(!t)return void console.error(\"enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.\");t.ontouchstart=null,t.ontouchmove=null,c=c.filter(function(e){return e.targetElement!==t}),u&&0===c.length&&(document.removeEventListener(\"touchmove\",m,l?{passive:!1}:void 0),u=!1)}else 1===c.length&&c[0].targetElement===t?(o(),c=[]):c=c.filter(function(e){return e.targetElement!==t})}});\n","'use strict';\nconst strictUriEncode = require('strict-uri-encode');\nconst decodeComponent = require('decode-uri-component');\nconst splitOnFirst = require('split-on-first');\n\nconst isNullOrUndefined = value => value === null || value === undefined;\n\nfunction encoderForArrayFormat(options) {\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tconst index = result.length;\n\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[', index, ']'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [\n\t\t\t\t\t...result,\n\t\t\t\t\t[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')\n\t\t\t\t];\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[]'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '[]=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (value === null || value === undefined || value.length === 0) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (result.length === 0) {\n\t\t\t\t\treturn [[encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [[result, encode(value, options)].join(options.arrayFormatSeparator)];\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, encode(key, options)];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(options) {\n\tlet result;\n\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = typeof value === 'string' && value.split('').indexOf(options.arrayFormatSeparator) > -1;\n\t\t\t\tconst newValue = isArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);\n\t\t\t\taccumulator[key] = newValue;\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction validateArrayFormatSeparator(value) {\n\tif (typeof value !== 'string' || value.length !== 1) {\n\t\tthrow new TypeError('arrayFormatSeparator must be single character string');\n\t}\n}\n\nfunction encode(value, options) {\n\tif (options.encode) {\n\t\treturn options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction decode(value, options) {\n\tif (options.decode) {\n\t\treturn decodeComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t}\n\n\tif (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input))\n\t\t\t.sort((a, b) => Number(a) - Number(b))\n\t\t\t.map(key => input[key]);\n\t}\n\n\treturn input;\n}\n\nfunction removeHash(input) {\n\tconst hashStart = input.indexOf('#');\n\tif (hashStart !== -1) {\n\t\tinput = input.slice(0, hashStart);\n\t}\n\n\treturn input;\n}\n\nfunction getHash(url) {\n\tlet hash = '';\n\tconst hashStart = url.indexOf('#');\n\tif (hashStart !== -1) {\n\t\thash = url.slice(hashStart);\n\t}\n\n\treturn hash;\n}\n\nfunction extract(input) {\n\tinput = removeHash(input);\n\tconst queryStart = input.indexOf('?');\n\tif (queryStart === -1) {\n\t\treturn '';\n\t}\n\n\treturn input.slice(queryStart + 1);\n}\n\nfunction parseValue(value, options) {\n\tif (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {\n\t\tvalue = Number(value);\n\t} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n\t\tvalue = value.toLowerCase() === 'true';\n\t}\n\n\treturn value;\n}\n\nfunction parse(input, options) {\n\toptions = Object.assign({\n\t\tdecode: true,\n\t\tsort: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ',',\n\t\tparseNumbers: false,\n\t\tparseBooleans: false\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst formatter = parserForArrayFormat(options);\n\n\t// Create an object with no prototype\n\tconst ret = Object.create(null);\n\n\tif (typeof input !== 'string') {\n\t\treturn ret;\n\t}\n\n\tinput = input.trim().replace(/^[?#&]/, '');\n\n\tif (!input) {\n\t\treturn ret;\n\t}\n\n\tfor (const param of input.split('&')) {\n\t\tlet [key, value] = splitOnFirst(options.decode ? param.replace(/\\+/g, ' ') : param, '=');\n\n\t\t// Missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tvalue = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);\n\t\tformatter(decode(key, options), value, ret);\n\t}\n\n\tfor (const key of Object.keys(ret)) {\n\t\tconst value = ret[key];\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tvalue[k] = parseValue(value[k], options);\n\t\t\t}\n\t\t} else {\n\t\t\tret[key] = parseValue(value, options);\n\t\t}\n\t}\n\n\tif (options.sort === false) {\n\t\treturn ret;\n\t}\n\n\treturn (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {\n\t\tconst value = ret[key];\n\t\tif (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(value);\n\t\t} else {\n\t\t\tresult[key] = value;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n}\n\nexports.extract = extract;\nexports.parse = parse;\n\nexports.stringify = (object, options) => {\n\tif (!object) {\n\t\treturn '';\n\t}\n\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ','\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst shouldFilter = key => (\n\t\t(options.skipNull && isNullOrUndefined(object[key])) ||\n\t\t(options.skipEmptyString && object[key] === '')\n\t);\n\n\tconst formatter = encoderForArrayFormat(options);\n\n\tconst objectCopy = {};\n\n\tfor (const key of Object.keys(object)) {\n\t\tif (!shouldFilter(key)) {\n\t\t\tobjectCopy[key] = object[key];\n\t\t}\n\t}\n\n\tconst keys = Object.keys(objectCopy);\n\n\tif (options.sort !== false) {\n\t\tkeys.sort(options.sort);\n\t}\n\n\treturn keys.map(key => {\n\t\tconst value = object[key];\n\n\t\tif (value === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn encode(key, options);\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn value\n\t\t\t\t.reduce(formatter(key), [])\n\t\t\t\t.join('&');\n\t\t}\n\n\t\treturn encode(key, options) + '=' + encode(value, options);\n\t}).filter(x => x.length > 0).join('&');\n};\n\nexports.parseUrl = (input, options) => {\n\toptions = Object.assign({\n\t\tdecode: true\n\t}, options);\n\n\tconst [url, hash] = splitOnFirst(input, '#');\n\n\treturn Object.assign(\n\t\t{\n\t\t\turl: url.split('?')[0] || '',\n\t\t\tquery: parse(extract(input), options)\n\t\t},\n\t\toptions && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}\n\t);\n};\n\nexports.stringifyUrl = (input, options) => {\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true\n\t}, options);\n\n\tconst url = removeHash(input.url).split('?')[0] || '';\n\tconst queryFromUrl = exports.extract(input.url);\n\tconst parsedQueryFromUrl = exports.parse(queryFromUrl, {sort: false});\n\n\tconst query = Object.assign(parsedQueryFromUrl, input.query);\n\tlet queryString = exports.stringify(query, options);\n\tif (queryString) {\n\t\tqueryString = `?${queryString}`;\n\t}\n\n\tlet hash = getHash(input.url);\n\tif (input.fragmentIdentifier) {\n\t\thash = `#${encode(input.fragmentIdentifier, options)}`;\n\t}\n\n\treturn `${url}${queryString}${hash}`;\n};\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nexport default listCacheClear;\n","import eq from './eq.js';\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nexport default assocIndexOf;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nexport default listCacheDelete;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nexport default listCacheGet;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nexport default listCacheHas;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nexport default listCacheSet;\n","import listCacheClear from './_listCacheClear.js';\nimport listCacheDelete from './_listCacheDelete.js';\nimport listCacheGet from './_listCacheGet.js';\nimport listCacheHas from './_listCacheHas.js';\nimport listCacheSet from './_listCacheSet.js';\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nexport default ListCache;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nexport default Map;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nexport default arrayMap;\n","import Symbol from './_Symbol.js';\nimport arrayMap from './_arrayMap.js';\nimport isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isArray(value)) {\n    // Recursively convert values (susceptible to call stack limits).\n    return arrayMap(value, baseToString) + '';\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default baseToString;\n","import baseToString from './_baseToString.js';\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\nexport default toString;\n","import baseGetTag from './_baseGetTag.js';\nimport isObject from './isObject.js';\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nexport default isFunction;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nexport default toSource;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nexport default eq;\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n * @example\n *\n * _.isNil(null);\n * // => true\n *\n * _.isNil(void 0);\n * // => true\n *\n * _.isNil(NaN);\n * // => false\n */\nfunction isNil(value) {\n  return value == null;\n}\n\nexport default isNil;\n","'use strict';\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);\n","'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp(token, 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn decodeURIComponent(components.join(''));\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher);\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher);\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","'use strict';\n\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","import getNative from './_getNative.js';\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nexport default nativeCreate;\n","import nativeCreate from './_nativeCreate.js';\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nexport default hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nexport default hashDelete;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nexport default hashGet;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nexport default hashHas;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nexport default hashSet;\n","import hashClear from './_hashClear.js';\nimport hashDelete from './_hashDelete.js';\nimport hashGet from './_hashGet.js';\nimport hashHas from './_hashHas.js';\nimport hashSet from './_hashSet.js';\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nexport default Hash;\n","import Hash from './_Hash.js';\nimport ListCache from './_ListCache.js';\nimport Map from './_Map.js';\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nexport default mapCacheClear;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nexport default isKeyable;\n","import isKeyable from './_isKeyable.js';\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nexport default getMapData;\n","import getMapData from './_getMapData.js';\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nexport default mapCacheDelete;\n","import getMapData from './_getMapData.js';\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nexport default mapCacheGet;\n","import getMapData from './_getMapData.js';\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nexport default mapCacheHas;\n","import getMapData from './_getMapData.js';\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nexport default mapCacheSet;\n","import mapCacheClear from './_mapCacheClear.js';\nimport mapCacheDelete from './_mapCacheDelete.js';\nimport mapCacheGet from './_mapCacheGet.js';\nimport mapCacheHas from './_mapCacheHas.js';\nimport mapCacheSet from './_mapCacheSet.js';\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nexport default MapCache;\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":""}