{"version":3,"names":["loader","define","requireModule","require","requirejs","global","dict","obj","Object","create","undefined","oldGlobals","id","pending","mod","findModule","i","length","exports","module","noConflict","aliases","oldName","newName","hasOwnProperty","makeDefaultExport","registry","uuid","defaultDeps","Module","deps","callback","alias","this","hasExportsAsDep","isAlias","reified","Array","state","noop","Alias","referrer","Error","missingModule","findDeps","push","resolve","child","charAt","parts","split","parentBase","slice","l","part","pop","join","has","prototype","isExtensible","wrapModules","reify","result","apply","unsee","_reify","dep","entry","makeRequire","r","moduleId","arguments","unsupportedModule","isArray","name","defaultExport","target","entries","_eak_seen","clear","root","factory","amd","ResizeSensor","window","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","fn","setTimeout","forEachElement","elements","elementsType","toString","call","isCollectionTyped","jQuery","Elements","j","element","EventQueue","q","add","ev","remove","newQueue","attachResizeEvent","resized","resizedAttached","resizeSensor","document","createElement","className","style","styleChild","cssText","innerHTML","appendChild","prop","currentStyle","getComputedStyle","getPropertyValue","position","dirty","rafId","newWidth","newHeight","expand","childNodes","expandChild","shrink","lastWidth","offsetWidth","lastHeight","offsetHeight","reset","width","height","scrollLeft","scrollTop","onResized","onScroll","addEvent","el","cb","attachEvent","addEventListener","elem","detach","contains","removeChild","exportName","assign","VENDOR_PREFIXES","TEST_ELEMENT","round","Math","abs","now","Date","setTimeoutContext","timeout","context","bindFn","invokeArrayArg","arg","each","iterator","forEach","deprecate","method","message","deprecationMessage","e","stack","replace","log","console","warn","TypeError","output","index","source","nextKey","extend","dest","src","merge","keys","inherit","base","properties","childP","baseP","constructor","_super","boolOrFn","val","args","ifUndefined","val1","val2","addEventListeners","types","handler","splitStr","type","removeEventListeners","removeEventListener","hasParent","node","parent","parentNode","inStr","str","find","indexOf","trim","inArray","findByKey","toArray","uniqueArray","key","sort","results","values","a","b","prefixed","property","prefix","camelProp","toUpperCase","_uniqueId","getWindowForElement","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","test","navigator","userAgent","INPUT_TYPE_TOUCH","INPUT_TYPE_MOUSE","DIRECTION_VERTICAL","DIRECTION_UP","PROPS_XY","PROPS_CLIENT_XY","Input","manager","self","options","inputTarget","domHandler","enable","init","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offset","offsetDelta","prevDelta","prevInput","x","deltaX","y","deltaY","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","scale","start","end","rotation","getRotation","maxPointers","velocity","velocityX","velocityY","direction","last","lastInterval","v","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","clientY","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","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","toLowerCase","isTouch","storeIndex","pointerId","splice","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SingleTouchInput","started","normalizeSingleTouches","all","touches","changed","changedTouches","concat","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","filter","touch","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","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","value","set","compute","actions","update","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","DIRECTION_LEFT","preventSrc","STATE_FAILED","Recognizer","defaults","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","event","additionalEvent","tryEmit","canEmit","inputDataClone","process","attrTest","optionPointers","isRecognized","isValid","threshold","DIRECTION_HORIZONTAL","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","item","stop","force","stopped","curRecognizer","existing","on","events","off","data","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","DIRECTION_NONE","DIRECTION_RIGHT","DIRECTION_DOWN","DIRECTION_ALL","Tap","Pan","Swipe","Pinch","Rotate","Press","ic","Intercom","default","_setup","config","intercom","enabled","c","d","s","async","appId","getElementsByTagName","insertBefore"],"sources":["../rewritten-packages/@embroider/synthesized-vendor/vendor/loader/loader.js","../../../../../../node_modules/.pnpm/ember-table@5.0.6_@ember+test-helpers@3.3.1_@babel+core@7.26.9_@glint+template@1.5.2_em_3115f5eddf4ca8964515f8c5c56ecc99/node_modules/css-element-queries/src/ResizeSensor.js","../../../../../../node_modules/.pnpm/ember-table@5.0.6_@ember+test-helpers@3.3.1_@babel+core@7.26.9_@glint+template@1.5.2_em_3115f5eddf4ca8964515f8c5c56ecc99/node_modules/hammerjs/hammer.js","../rewritten-packages/@embroider/synthesized-vendor/vendor/intercom-shim.js"],"sourcesContent":["var loader, define, requireModule, require, requirejs;\n\n(function (global) {\n  'use strict';\n\n  function dict() {\n    var obj = Object.create(null);\n    obj['__'] = undefined;\n    delete obj['__'];\n    return obj;\n  }\n\n  // Save off the original values of these globals, so we can restore them if someone asks us to\n  var oldGlobals = {\n    loader: loader,\n    define: define,\n    requireModule: requireModule,\n    require: require,\n    requirejs: requirejs\n  };\n\n  requirejs = require = requireModule = function (id) {\n    var pending = [];\n    var mod = findModule(id, '(require)', pending);\n\n    for (var i = pending.length - 1; i >= 0; i--) {\n      pending[i].exports();\n    }\n\n    return mod.module.exports;\n  };\n\n  loader = {\n    noConflict: function (aliases) {\n      var oldName, newName;\n\n      for (oldName in aliases) {\n        if (aliases.hasOwnProperty(oldName)) {\n          if (oldGlobals.hasOwnProperty(oldName)) {\n            newName = aliases[oldName];\n\n            global[newName] = global[oldName];\n            global[oldName] = oldGlobals[oldName];\n          }\n        }\n      }\n    },\n    // Option to enable or disable the generation of default exports\n    makeDefaultExport: true\n  };\n\n  var registry = dict();\n  var seen = dict();\n\n  var uuid = 0;\n\n  function unsupportedModule(length) {\n    throw new Error('an unsupported module was defined, expected `define(id, deps, module)` instead got: `' + length + '` arguments to define`');\n  }\n\n  var defaultDeps = ['require', 'exports', 'module'];\n\n  function Module(id, deps, callback, alias) {\n    this.uuid = uuid++;\n    this.id = id;\n    this.deps = !deps.length && callback.length ? defaultDeps : deps;\n    this.module = { exports: {} };\n    this.callback = callback;\n    this.hasExportsAsDep = false;\n    this.isAlias = alias;\n    this.reified = new Array(deps.length);\n\n    /*\n       Each module normally passes through these states, in order:\n         new       : initial state\n         pending   : this module is scheduled to be executed\n         reifying  : this module's dependencies are being executed\n         reified   : this module's dependencies finished executing successfully\n         errored   : this module's dependencies failed to execute\n         finalized : this module executed successfully\n     */\n    this.state = 'new';\n  }\n\n  Module.prototype.makeDefaultExport = function () {\n    var exports = this.module.exports;\n    if (exports !== null && (typeof exports === 'object' || typeof exports === 'function') && exports['default'] === undefined && Object.isExtensible(exports)) {\n      exports['default'] = exports;\n    }\n  };\n\n  Module.prototype.exports = function () {\n    // if finalized, there is no work to do. If reifying, there is a\n    // circular dependency so we must return our (partial) exports.\n    if (this.state === 'finalized' || this.state === 'reifying') {\n      return this.module.exports;\n    }\n\n\n    if (loader.wrapModules) {\n      this.callback = loader.wrapModules(this.id, this.callback);\n    }\n\n    this.reify();\n\n    var result = this.callback.apply(this, this.reified);\n    this.reified.length = 0;\n    this.state = 'finalized';\n\n    if (!(this.hasExportsAsDep && result === undefined)) {\n      this.module.exports = result;\n    }\n    if (loader.makeDefaultExport) {\n      this.makeDefaultExport();\n    }\n    return this.module.exports;\n  };\n\n  Module.prototype.unsee = function () {\n    this.state = 'new';\n    this.module = { exports: {} };\n  };\n\n  Module.prototype.reify = function () {\n    if (this.state === 'reified') {\n      return;\n    }\n    this.state = 'reifying';\n    try {\n      this.reified = this._reify();\n      this.state = 'reified';\n    } finally {\n      if (this.state === 'reifying') {\n        this.state = 'errored';\n      }\n    }\n  };\n\n  Module.prototype._reify = function () {\n    var reified = this.reified.slice();\n    for (var i = 0; i < reified.length; i++) {\n      var mod = reified[i];\n      reified[i] = mod.exports ? mod.exports : mod.module.exports();\n    }\n    return reified;\n  };\n\n  Module.prototype.findDeps = function (pending) {\n    if (this.state !== 'new') {\n      return;\n    }\n\n    this.state = 'pending';\n\n    var deps = this.deps;\n\n    for (var i = 0; i < deps.length; i++) {\n      var dep = deps[i];\n      var entry = this.reified[i] = { exports: undefined, module: undefined };\n      if (dep === 'exports') {\n        this.hasExportsAsDep = true;\n        entry.exports = this.module.exports;\n      } else if (dep === 'require') {\n        entry.exports = this.makeRequire();\n      } else if (dep === 'module') {\n        entry.exports = this.module;\n      } else {\n        entry.module = findModule(resolve(dep, this.id), this.id, pending);\n      }\n    }\n  };\n\n  Module.prototype.makeRequire = function () {\n    var id = this.id;\n    var r = function (dep) {\n      return require(resolve(dep, id));\n    };\n    r['default'] = r;\n    r.moduleId = id;\n    r.has = function (dep) {\n      return has(resolve(dep, id));\n    };\n    return r;\n  };\n\n  define = function (id, deps, callback) {\n    var module = registry[id];\n\n    // If a module for this id has already been defined and is in any state\n    // other than `new` (meaning it has been or is currently being required),\n    // then we return early to avoid redefinition.\n    if (module && module.state !== 'new') {\n      return;\n    }\n\n    if (arguments.length < 2) {\n      unsupportedModule(arguments.length);\n    }\n\n    if (!Array.isArray(deps)) {\n      callback = deps;\n      deps = [];\n    }\n\n    if (callback instanceof Alias) {\n      registry[id] = new Module(callback.id, deps, callback, true);\n    } else {\n      registry[id] = new Module(id, deps, callback, false);\n    }\n  };\n\n  define.exports = function (name, defaultExport) {\n    var module = registry[name];\n\n    // If a module for this name has already been defined and is in any state\n    // other than `new` (meaning it has been or is currently being required),\n    // then we return early to avoid redefinition.\n    if (module && module.state !== 'new') {\n      return;\n    }\n\n    module = new Module(name, [], noop, null);\n    module.module.exports = defaultExport;\n    module.state = 'finalized';\n    registry[name] = module;\n\n    return module;\n  };\n\n  function noop() {}\n  // we don't support all of AMD\n  // define.amd = {};\n\n  function Alias(id) {\n    this.id = id;\n  }\n\n  define.alias = function (id, target) {\n    if (arguments.length === 2) {\n      return define(target, new Alias(id));\n    }\n\n    return new Alias(id);\n  };\n\n  function missingModule(id, referrer) {\n    throw new Error('Could not find module `' + id + '` imported from `' + referrer + '`');\n  }\n\n  function findModule(id, referrer, pending) {\n    var mod = registry[id] || registry[id + '/index'];\n\n    while (mod && mod.isAlias) {\n      mod = registry[mod.id] || registry[mod.id + '/index'];\n    }\n\n    if (!mod) {\n      missingModule(id, referrer);\n    }\n\n    if (pending && mod.state !== 'pending' && mod.state !== 'finalized') {\n      mod.findDeps(pending);\n      pending.push(mod);\n    }\n    return mod;\n  }\n\n  function resolve(child, id) {\n    if (child.charAt(0) !== '.') {\n      return child;\n    }\n\n\n    var parts = child.split('/');\n    var nameParts = id.split('/');\n    var parentBase = nameParts.slice(0, -1);\n\n    for (var i = 0, l = parts.length; i < l; i++) {\n      var part = parts[i];\n\n      if (part === '..') {\n        if (parentBase.length === 0) {\n          throw new Error('Cannot access parent module of root');\n        }\n        parentBase.pop();\n      } else if (part === '.') {\n        continue;\n      } else {\n        parentBase.push(part);\n      }\n    }\n\n    return parentBase.join('/');\n  }\n\n  function has(id) {\n    return !!(registry[id] || registry[id + '/index']);\n  }\n\n  requirejs.entries = requirejs._eak_seen = registry;\n  requirejs.has = has;\n  requirejs.unsee = function (id) {\n    findModule(id, '(unsee)', false).unsee();\n  };\n\n  requirejs.clear = function () {\n    requirejs.entries = requirejs._eak_seen = registry = dict();\n    seen = dict();\n  };\n\n  // This code primes the JS engine for good performance by warming the\n  // JIT compiler for these functions.\n  define('foo', function () {});\n  define('foo/bar', [], function () {});\n  define('foo/asdf', ['module', 'exports', 'require'], function (module, exports, require) {\n    if (require.has('foo/bar')) {\n      require('foo/bar');\n    }\n  });\n  define('foo/baz', [], define.alias('foo'));\n  define('foo/quz', define.alias('foo'));\n  define.alias('foo', 'foo/qux');\n  define('foo/bar', ['foo', './quz', './baz', './asdf', './bar', '../foo'], function () {});\n  define('foo/main', ['foo/bar'], function () {});\n  define.exports('foo/exports', {});\n\n  require('foo/exports');\n  require('foo/main');\n  require.unsee('foo/bar');\n\n  requirejs.clear();\n\n  if (typeof exports === 'object' && typeof module === 'object' && module.exports) {\n    module.exports = { require: require, define: define };\n  }\n})(this);","/**\n * Copyright Marc J. Schmidt. See the LICENSE file at the top-level\n * directory of this distribution and at\n * https://github.com/marcj/css-element-queries/blob/master/LICENSE.\n */\n;\n(function (root, factory) {\n    if (typeof define === \"function\" && define.amd) {\n        define(factory);\n    } else if (typeof exports === \"object\") {\n        module.exports = factory();\n    } else {\n        root.ResizeSensor = factory();\n    }\n}(this, function () {\n\n    //Make sure it does not throw in a SSR (Server Side Rendering) situation\n    if (typeof window === \"undefined\") {\n        return null;\n    }\n    // Only used for the dirty checking, so the event callback count is limted to max 1 call per fps per sensor.\n    // In combination with the event based resize sensor this saves cpu time, because the sensor is too fast and\n    // would generate too many unnecessary events.\n    var requestAnimationFrame = window.requestAnimationFrame ||\n        window.mozRequestAnimationFrame ||\n        window.webkitRequestAnimationFrame ||\n        function (fn) {\n            return window.setTimeout(fn, 20);\n        };\n\n    /**\n     * Iterate over each of the provided element(s).\n     *\n     * @param {HTMLElement|HTMLElement[]} elements\n     * @param {Function}                  callback\n     */\n    function forEachElement(elements, callback){\n        var elementsType = Object.prototype.toString.call(elements);\n        var isCollectionTyped = ('[object Array]' === elementsType\n            || ('[object NodeList]' === elementsType)\n            || ('[object HTMLCollection]' === elementsType)\n            || ('[object Object]' === elementsType)\n            || ('undefined' !== typeof jQuery && elements instanceof jQuery) //jquery\n            || ('undefined' !== typeof Elements && elements instanceof Elements) //mootools\n        );\n        var i = 0, j = elements.length;\n        if (isCollectionTyped) {\n            for (; i < j; i++) {\n                callback(elements[i]);\n            }\n        } else {\n            callback(elements);\n        }\n    }\n\n    /**\n     * Class for dimension change detection.\n     *\n     * @param {Element|Element[]|Elements|jQuery} element\n     * @param {Function} callback\n     *\n     * @constructor\n     */\n    var ResizeSensor = function(element, callback) {\n        /**\n         *\n         * @constructor\n         */\n        function EventQueue() {\n            var q = [];\n            this.add = function(ev) {\n                q.push(ev);\n            };\n\n            var i, j;\n            this.call = function() {\n                for (i = 0, j = q.length; i < j; i++) {\n                    q[i].call();\n                }\n            };\n\n            this.remove = function(ev) {\n                var newQueue = [];\n                for(i = 0, j = q.length; i < j; i++) {\n                    if(q[i] !== ev) newQueue.push(q[i]);\n                }\n                q = newQueue;\n            }\n\n            this.length = function() {\n                return q.length;\n            }\n        }\n\n        /**\n         * @param {HTMLElement} element\n         * @param {String}      prop\n         * @returns {String|Number}\n         */\n        function getComputedStyle(element, prop) {\n            if (element.currentStyle) {\n                return element.currentStyle[prop];\n            } else if (window.getComputedStyle) {\n                return window.getComputedStyle(element, null).getPropertyValue(prop);\n            } else {\n                return element.style[prop];\n            }\n        }\n\n        /**\n         *\n         * @param {HTMLElement} element\n         * @param {Function}    resized\n         */\n        function attachResizeEvent(element, resized) {\n            if (!element.resizedAttached) {\n                element.resizedAttached = new EventQueue();\n                element.resizedAttached.add(resized);\n            } else if (element.resizedAttached) {\n                element.resizedAttached.add(resized);\n                return;\n            }\n\n            element.resizeSensor = document.createElement('div');\n            element.resizeSensor.className = 'resize-sensor';\n            var style = 'position: absolute; left: 0; top: 0; right: 0; bottom: 0; overflow: hidden; z-index: -1; visibility: hidden;';\n            var styleChild = 'position: absolute; left: 0; top: 0; transition: 0s;';\n\n            element.resizeSensor.style.cssText = style;\n            element.resizeSensor.innerHTML =\n                '<div class=\"resize-sensor-expand\" style=\"' + style + '\">' +\n                    '<div style=\"' + styleChild + '\"></div>' +\n                '</div>' +\n                '<div class=\"resize-sensor-shrink\" style=\"' + style + '\">' +\n                    '<div style=\"' + styleChild + ' width: 200%; height: 200%\"></div>' +\n                '</div>';\n            element.appendChild(element.resizeSensor);\n\n            if (getComputedStyle(element, 'position') == 'static') {\n                element.style.position = 'relative';\n            }\n\n            var expand = element.resizeSensor.childNodes[0];\n            var expandChild = expand.childNodes[0];\n            var shrink = element.resizeSensor.childNodes[1];\n            var dirty, rafId, newWidth, newHeight;\n            var lastWidth = element.offsetWidth;\n            var lastHeight = element.offsetHeight;\n\n            var reset = function() {\n                expandChild.style.width = '100000px';\n                expandChild.style.height = '100000px';\n\n                expand.scrollLeft = 100000;\n                expand.scrollTop = 100000;\n\n                shrink.scrollLeft = 100000;\n                shrink.scrollTop = 100000;\n            };\n\n            reset();\n\n            var onResized = function() {\n                rafId = 0;\n\n                if (!dirty) return;\n\n                lastWidth = newWidth;\n                lastHeight = newHeight;\n\n                if (element.resizedAttached) {\n                    element.resizedAttached.call();\n                }\n            };\n\n            var onScroll = function() {\n                newWidth = element.offsetWidth;\n                newHeight = element.offsetHeight;\n                dirty = newWidth != lastWidth || newHeight != lastHeight;\n\n                if (dirty && !rafId) {\n                    rafId = requestAnimationFrame(onResized);\n                }\n\n                reset();\n            };\n\n            var addEvent = function(el, name, cb) {\n                if (el.attachEvent) {\n                    el.attachEvent('on' + name, cb);\n                } else {\n                    el.addEventListener(name, cb);\n                }\n            };\n\n            addEvent(expand, 'scroll', onScroll);\n            addEvent(shrink, 'scroll', onScroll);\n        }\n\n        forEachElement(element, function(elem){\n            attachResizeEvent(elem, callback);\n        });\n\n        this.detach = function(ev) {\n            ResizeSensor.detach(element, ev);\n        };\n    };\n\n    ResizeSensor.detach = function(element, ev) {\n        forEachElement(element, function(elem){\n            if(elem.resizedAttached && typeof ev == \"function\"){\n                elem.resizedAttached.remove(ev);\n                if(elem.resizedAttached.length()) return;\n            }\n            if (elem.resizeSensor) {\n                if (elem.contains(elem.resizeSensor)) {\n                    elem.removeChild(elem.resizeSensor);\n                }\n                delete elem.resizeSensor;\n                delete elem.resizedAttached;\n            }\n        });\n    };\n\n    return ResizeSensor;\n\n}));\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","(function() {\n  /* globals define */\n  'use strict';\n\n  function l(config) {\n    if (config.intercom.enabled === false) {\n      return;\n    }\n\n    var i = function() {\n      i.c(arguments);\n    };\n    i.q = [];\n    i.c = function(args) {\n      i.q.push(args);\n    };\n\n    window.Intercom = i;\n\n    var d = document;\n    var s = d.createElement('script');\n    s.type = 'text/javascript';\n    s.async = true;\n    s.src = 'https://widget.intercom.io/widget/' + config.intercom.appId;\n    var x = d.getElementsByTagName('script')[0];\n    x.parentNode.insertBefore(s, x);\n  }\n\n  var ic = window.Intercom;\n  if (typeof ic === 'function') {\n    ic('reattach_activator');\n    ic('update', {});\n  }\n\n  function generateModule(name, values) {\n    define(name, [], function() {\n      'use strict'; // jshint ignore:line\n\n      return values;\n    });\n  }\n\n  generateModule('intercom', {\n    default: function() {\n      if (window.Intercom && typeof window.Intercom.apply === 'function') {\n        return window.Intercom.apply(null, arguments);\n      }\n    },\n    _setup: l\n  });\n})();\n"],"mappings":"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","ignoreList":[]}