{"version":3,"sources":["webpack:///./node_modules/core-js/internals/get-substitution.js","webpack:///./node_modules/core-js/modules/es.string.replace.js","webpack:///./node_modules/@webzlodimir/vue-bottom-sheet/dist/vue-bottom-sheet.esm.js","webpack:///./node_modules/hammerjs/hammer.js"],"names":["uncurryThis","toObject","floor","Math","charAt","replace","stringSlice","slice","SUBSTITUTION_SYMBOLS","SUBSTITUTION_SYMBOLS_NO_NAMED","module","exports","matched","str","position","captures","namedCaptures","replacement","tailPos","length","m","symbols","undefined","match","ch","capture","f","n","apply","call","fixRegExpWellKnownSymbolLogic","fails","anObject","isCallable","isNullOrUndefined","toIntegerOrInfinity","toLength","toString","requireObjectCoercible","advanceStringIndex","getMethod","getSubstitution","regExpExec","REPLACE","max","min","concat","push","stringIndexOf","indexOf","REPLACE_KEEPS_$0","REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE","_","nativeReplace","maybeCallNative","UNSAFE_SUBSTITUTE","searchValue","replaceValue","O","this","replacer","string","rx","S","res","done","value","fullUnicode","functionalReplace","global","results","unicode","lastIndex","result","it","accumulatedResult","nextSourcePosition","i","index","j","String","groups","replacerArgs","re","exec","a","script","name","data","inited","opened","contentH","hammer","pan","content","contentScroll","cardP","cardH","moving","stripe","handlers","mousedown","clickOnBottomSheet","touchstart","props","overlay","type","Boolean","default","maxWidth","maxHeight","clickToClose","effect","rounded","swipeAble","isFullScreen","overlayColor","backgroundScrollable","backgroundClickable","methods","isIphone","iPhone","test","navigator","userAgent","window","MSStream","aspect","screen","width","height","toFixed","move","event","delta","deltaY","$refs","bottomSheetCardContent","scrollTop","isFinal","document","body","style","overflow","$emit","init","_this","Promise","resolve","options","bottomSheetCard","clientHeight","recognizers","Pan","direction","DIRECTION_VERTICAL","on","e","setTimeout","open","_this2","then","$props","close","target","classList","contains","beforeDestroy","_this$hammer2$content","_this$hammer","_this$hammer$pan","destroy","_this$hammer2","normalizeComponent","template","scopeId","isFunctionalTemplate","moduleIdentifier","shadowMode","createInjector","createInjectorSSR","createInjectorShadow","render","staticRenderFns","_compiled","functional","_scopeId","let","hook","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","originalRender","h","existing","beforeCreate","isOldIE","toLowerCase","id","addStyle","nodes","group","css","media","styles","ids","Set","has","code","source","map","sources","btoa","unescape","encodeURIComponent","JSON","stringify","element","createElement","setAttribute","HEAD","head","getElementsByTagName","appendChild","styleSheet","cssText","filter","join","size","textNode","createTextNode","childNodes","removeChild","insertBefore","__vue_component__","_vm","_h","$createElement","_c","_self","_g","ref","class","closed","staticClass","_e","_v","square","bottom","_t","inject","installable","install","Vue","component","VENDOR_PREFIXES","TEST_ELEMENT","TYPE_FUNCTION","round","abs","now","Date","setTimeoutContext","fn","timeout","bindFn","invokeArrayArg","arg","Array","isArray","each","obj","iterator","forEach","hasOwnProperty","deprecate","method","message","deprecationMessage","Error","stack","log","console","warn","arguments","assign","Object","TypeError","output","nextKey","extend","dest","src","merge","keys","inherit","child","base","properties","baseP","prototype","childP","create","constructor","_super","boolOrFn","val","args","ifUndefined","val1","val2","addEventListeners","types","handler","splitStr","addEventListener","removeEventListeners","removeEventListener","hasParent","node","parentNode","inStr","find","trim","split","inArray","findByKey","toArray","uniqueArray","key","sort","values","b","prefixed","property","prop","camelProp","toUpperCase","prefix","_uniqueId","getWindowForElement","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","INPUT_TYPE_TOUCH","INPUT_TYPE_MOUSE","COMPUTE_INTERVAL","INPUT_START","INPUT_END","INPUT_CANCEL","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_HORIZONTAL","DIRECTION_ALL","PROPS_XY","PROPS_CLIENT_XY","Input","manager","callback","self","inputTarget","domHandler","ev","enable","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","overallVelocity","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offset","offsetDelta","prevDelta","prevInput","x","deltaX","y","offsetDirection","getDirection","getVelocity","overallVelocityX","overallVelocityY","scale","start","end","rotation","maxPointers","velocity","velocityX","velocityY","last","lastInterval","v","srcEvent","emit","recognize","clientX","clientY","p1","p2","sqrt","atan2","PI","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","MouseInput","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","2","3","4","5","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","splice","SINGLE_TOUCH_INPUT_MAP","touchmove","touchend","touchcancel","SingleTouchInput","started","touches","all","changed","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","allTouches","identifier","targetTouches","changedTargetTouches","touch","DEDUP_TIMEOUT","TouchMouseInput","mouse","primaryTouch","lastTouches","setLastTouch","eventData","lastTouch","lts","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","recordTouches","t","dx","dy","touchMap","cssSupports","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","CSS","supports","TouchAction","set","Recognizer","defaults","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","recognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","Manager","oldCssProps","inputClass","touchAction","toggleCssProps","item","recognizeWith","requireFailure","cssProps","compute","actions","update","hasPanX","hasPanY","getTouchAction","preventDefaults","prevented","hasNone","preventSrc","preventDefault","dropRecognizeWith","dropRequireFailure","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","process","reset","attrTest","optionPointers","isRecognized","isValid","threshold","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","clearTimeout","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","stop","force","stopped","curRecognizer","remove","events","off","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","INPUT_MOVE","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","STATE_FAILED","Tap","Swipe","Pinch","Rotate","Press"],"mappings":"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","file":"js/checkout~foodview~store~store-list~transaction.d847a808.js","sourcesContent":["'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar floor = Math.floor;\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar stringSlice = uncurryThis(''.slice);\n// eslint-disable-next-line redos/no-vulnerable -- safe\nvar SUBSTITUTION_SYMBOLS = /\\$([$&'`]|\\d{1,2}|<[^>]*>)/g;\nvar SUBSTITUTION_SYMBOLS_NO_NAMED = /\\$([$&'`]|\\d{1,2})/g;\n\n// `GetSubstitution` abstract operation\n// https://tc39.es/ecma262/#sec-getsubstitution\nmodule.exports = function (matched, str, position, captures, namedCaptures, replacement) {\n  var tailPos = position + matched.length;\n  var m = captures.length;\n  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;\n  if (namedCaptures !== undefined) {\n    namedCaptures = toObject(namedCaptures);\n    symbols = SUBSTITUTION_SYMBOLS;\n  }\n  return replace(replacement, symbols, function (match, ch) {\n    var capture;\n    switch (charAt(ch, 0)) {\n      case '$': return '$';\n      case '&': return matched;\n      case '`': return stringSlice(str, 0, position);\n      case \"'\": return stringSlice(str, tailPos);\n      case '<':\n        capture = namedCaptures[stringSlice(ch, 1, -1)];\n        break;\n      default: // \\d\\d?\n        var n = +ch;\n        if (n === 0) return match;\n        if (n > m) {\n          var f = floor(n / 10);\n          if (f === 0) return match;\n          if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);\n          return match;\n        }\n        capture = captures[n - 1];\n    }\n    return capture === undefined ? '' : capture;\n  });\n};\n","'use strict';\nvar apply = require('../internals/function-apply');\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');\nvar fails = require('../internals/fails');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar advanceStringIndex = require('../internals/advance-string-index');\nvar getMethod = require('../internals/get-method');\nvar getSubstitution = require('../internals/get-substitution');\nvar regExpExec = require('../internals/regexp-exec-abstract');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar REPLACE = wellKnownSymbol('replace');\nvar max = Math.max;\nvar min = Math.min;\nvar concat = uncurryThis([].concat);\nvar push = uncurryThis([].push);\nvar stringIndexOf = uncurryThis(''.indexOf);\nvar stringSlice = uncurryThis(''.slice);\n\nvar maybeToString = function (it) {\n  return it === undefined ? it : String(it);\n};\n\n// IE <= 11 replaces $0 with the whole match, as if it was $&\n// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0\nvar REPLACE_KEEPS_$0 = (function () {\n  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing\n  return 'a'.replace(/./, '$0') === '$0';\n})();\n\n// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string\nvar REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {\n  if (/./[REPLACE]) {\n    return /./[REPLACE]('a', '$0') === '';\n  }\n  return false;\n})();\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n  var re = /./;\n  re.exec = function () {\n    var result = [];\n    result.groups = { a: '7' };\n    return result;\n  };\n  // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive\n  return ''.replace(re, '$<a>') !== '7';\n});\n\n// @@replace logic\nfixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {\n  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';\n\n  return [\n    // `String.prototype.replace` method\n    // https://tc39.es/ecma262/#sec-string.prototype.replace\n    function replace(searchValue, replaceValue) {\n      var O = requireObjectCoercible(this);\n      var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);\n      return replacer\n        ? call(replacer, searchValue, O, replaceValue)\n        : call(nativeReplace, toString(O), searchValue, replaceValue);\n    },\n    // `RegExp.prototype[@@replace]` method\n    // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace\n    function (string, replaceValue) {\n      var rx = anObject(this);\n      var S = toString(string);\n\n      if (\n        typeof replaceValue == 'string' &&\n        stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&\n        stringIndexOf(replaceValue, '$<') === -1\n      ) {\n        var res = maybeCallNative(nativeReplace, rx, S, replaceValue);\n        if (res.done) return res.value;\n      }\n\n      var functionalReplace = isCallable(replaceValue);\n      if (!functionalReplace) replaceValue = toString(replaceValue);\n\n      var global = rx.global;\n      var fullUnicode;\n      if (global) {\n        fullUnicode = rx.unicode;\n        rx.lastIndex = 0;\n      }\n\n      var results = [];\n      var result;\n      while (true) {\n        result = regExpExec(rx, S);\n        if (result === null) break;\n\n        push(results, result);\n        if (!global) break;\n\n        var matchStr = toString(result[0]);\n        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n      }\n\n      var accumulatedResult = '';\n      var nextSourcePosition = 0;\n      for (var i = 0; i < results.length; i++) {\n        result = results[i];\n\n        var matched = toString(result[0]);\n        var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);\n        var captures = [];\n        var replacement;\n        // NOTE: This is equivalent to\n        //   captures = result.slice(1).map(maybeToString)\n        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in\n        // the slice polyfill when slicing native arrays) \"doesn't work\" in safari 9 and\n        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.\n        for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));\n        var namedCaptures = result.groups;\n        if (functionalReplace) {\n          var replacerArgs = concat([matched], captures, position, S);\n          if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);\n          replacement = toString(apply(replaceValue, undefined, replacerArgs));\n        } else {\n          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);\n        }\n        if (position >= nextSourcePosition) {\n          accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;\n          nextSourcePosition = position + matched.length;\n        }\n      }\n\n      return accumulatedResult + stringSlice(S, nextSourcePosition);\n    }\n  ];\n}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);\n","import Hammer from 'hammerjs';\n\n//\nvar script = {\n  name: \"VueBottomSheet\",\n  data: function data() {\n    var vm = this;\n    return {\n      inited: false,\n      opened: false,\n      contentH: \"auto\",\n      hammer: {\n        pan: null,\n        content: null\n      },\n      contentScroll: 0,\n      cardP: null,\n      cardH: null,\n      moving: false,\n      stripe: 0,\n      handlers: {\n        mousedown: vm.clickOnBottomSheet,\n        touchstart: vm.clickOnBottomSheet\n      }\n    };\n  },\n  props: {\n    overlay: {\n      type: Boolean,\n      default: true\n    },\n    maxWidth: {\n      type: String,\n      default: \"640px\"\n    },\n    maxHeight: {\n      type: String,\n      default: \"95%\"\n    },\n    clickToClose: {\n      type: Boolean,\n      default: true\n    },\n    effect: {\n      type: String,\n      default: \"fx-default\"\n    },\n    rounded: {\n      type: Boolean,\n      default: true\n    },\n    swipeAble: {\n      type: Boolean,\n      default: true\n    },\n    isFullScreen: {\n      type: Boolean,\n      default: false\n    },\n    overlayColor: {\n      type: String,\n      default: \"#0000004D\"\n    },\n    backgroundScrollable: {\n      type: Boolean,\n      default: false\n    },\n    backgroundClickable: {\n      type: Boolean,\n      default: false\n    }\n  },\n  methods: {\n    isIphone: function isIphone() {\n      var iPhone = /iPhone/.test(navigator.userAgent) && !window.MSStream;\n      var aspect = window.screen.width / window.screen.height;\n      return iPhone && aspect.toFixed(3) === \"0.462\";\n    },\n    move: function move(event, type) {\n      if (this.swipeAble) {\n        var delta = -event.deltaY;\n\n        if (type === 'content' && event.type === 'panup' || type === 'content' && event.type === 'pandown' && this.contentScroll > 0) {\n          this.$refs.bottomSheetCardContent.scrollTop = this.contentScroll + delta;\n        } else if (event.type === 'panup' || event.type === 'pandown') {\n          this.moving = true;\n\n          if (event.deltaY > 0) {\n            this.cardP = delta;\n          }\n        }\n\n        if (event.isFinal) {\n          this.contentScroll = this.$refs.bottomSheetCardContent.scrollTop;\n          this.moving = false;\n\n          if (this.cardP < -30) {\n            this.opened = false;\n            this.cardP = -this.cardH - this.stripe;\n            document.body.style.overflow = \"\";\n            this.$emit(\"closed\");\n          } else {\n            this.cardP = 0;\n          }\n        }\n      }\n    },\n    init: function init() {\n      var _this = this;\n\n      return new Promise(function (resolve) {\n        _this.contentH = \"auto\";\n        _this.stripe = _this.isIphone() ? 20 : 0;\n        _this.cardH = _this.$refs.bottomSheetCard.clientHeight;\n        _this.contentH = \"\".concat(_this.cardH - _this.$refs.pan.clientHeight, \"px\");\n        _this.$refs.bottomSheetCard.style.maxHeight = _this.maxHeight;\n        _this.cardP = _this.effect === \"fx-slide-from-right\" || _this.effect === \"fx-slide-from-left\" ? 0 : -_this.cardH - _this.stripe;\n\n        if (!_this.inited) {\n          _this.inited = true;\n          var options = {\n            recognizers: [[Hammer.Pan, {\n              direction: Hammer.DIRECTION_VERTICAL\n            }]]\n          };\n          _this.hammer.pan = new Hammer(_this.$refs.pan, options);\n\n          _this.hammer.pan.on(\"panstart panup pandown panend\", function (e) {\n            _this.move(e, 'pan');\n          });\n\n          _this.hammer.content = new Hammer(_this.$refs.bottomSheetCardContent, options);\n\n          _this.hammer.content.on(\"panstart panup pandown panend\", function (e) {\n            _this.move(e, 'content');\n          });\n        }\n\n        setTimeout(function () {\n          resolve();\n        }, 10);\n      });\n    },\n    open: function open() {\n      var _this2 = this;\n\n      this.init().then(function () {\n        _this2.opened = true;\n        _this2.cardP = 0;\n\n        if (!_this2.$props.backgroundScrollable) {\n          document.body.style.overflow = \"hidden\";\n        }\n\n        _this2.$emit(\"opened\");\n      });\n    },\n    close: function close() {\n      this.opened = false;\n      this.cardP = this.effect === \"fx-slide-from-right\" || this.effect === \"fx-slide-from-left\" ? 0 : -this.cardH - this.stripe;\n      document.body.style.overflow = \"\";\n      this.$emit(\"closed\");\n    },\n    clickOnBottomSheet: function clickOnBottomSheet(event) {\n      if (this.clickToClose) {\n        if (event.target.classList.contains(\"bottom-sheet__backdrop\") || event.target.classList.contains(\"bottom-sheet\")) {\n          this.close();\n        }\n      }\n    }\n  },\n  beforeDestroy: function beforeDestroy() {\n    var _this$hammer, _this$hammer$pan, _this$hammer2, _this$hammer2$content;\n\n    (_this$hammer = this.hammer) === null || _this$hammer === void 0 ? void 0 : (_this$hammer$pan = _this$hammer.pan) === null || _this$hammer$pan === void 0 ? void 0 : _this$hammer$pan.destroy();\n    (_this$hammer2 = this.hammer) === null || _this$hammer2 === void 0 ? void 0 : (_this$hammer2$content = _this$hammer2.content) === null || _this$hammer2$content === void 0 ? void 0 : _this$hammer2$content.destroy();\n  }\n};\n\nfunction normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\r\n    if (typeof shadowMode !== 'boolean') {\r\n        createInjectorSSR = createInjector;\r\n        createInjector = shadowMode;\r\n        shadowMode = false;\r\n    }\r\n    // Vue.extend constructor export interop.\r\n    const options = typeof script === 'function' ? script.options : script;\r\n    // render functions\r\n    if (template && template.render) {\r\n        options.render = template.render;\r\n        options.staticRenderFns = template.staticRenderFns;\r\n        options._compiled = true;\r\n        // functional template\r\n        if (isFunctionalTemplate) {\r\n            options.functional = true;\r\n        }\r\n    }\r\n    // scopedId\r\n    if (scopeId) {\r\n        options._scopeId = scopeId;\r\n    }\r\n    let hook;\r\n    if (moduleIdentifier) {\r\n        // server build\r\n        hook = function (context) {\r\n            // 2.3 injection\r\n            context =\r\n                context || // cached call\r\n                    (this.$vnode && this.$vnode.ssrContext) || // stateful\r\n                    (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional\r\n            // 2.2 with runInNewContext: true\r\n            if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\r\n                context = __VUE_SSR_CONTEXT__;\r\n            }\r\n            // inject component styles\r\n            if (style) {\r\n                style.call(this, createInjectorSSR(context));\r\n            }\r\n            // register component module identifier for async chunk inference\r\n            if (context && context._registeredComponents) {\r\n                context._registeredComponents.add(moduleIdentifier);\r\n            }\r\n        };\r\n        // used by ssr in case component is cached and beforeCreate\r\n        // never gets called\r\n        options._ssrRegister = hook;\r\n    }\r\n    else if (style) {\r\n        hook = shadowMode\r\n            ? function (context) {\r\n                style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));\r\n            }\r\n            : function (context) {\r\n                style.call(this, createInjector(context));\r\n            };\r\n    }\r\n    if (hook) {\r\n        if (options.functional) {\r\n            // register for functional component in vue file\r\n            const originalRender = options.render;\r\n            options.render = function renderWithStyleInjection(h, context) {\r\n                hook.call(context);\r\n                return originalRender(h, context);\r\n            };\r\n        }\r\n        else {\r\n            // inject component registration as beforeCreate hook\r\n            const existing = options.beforeCreate;\r\n            options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\r\n        }\r\n    }\r\n    return script;\r\n}\n\nconst isOldIE = typeof navigator !== 'undefined' &&\r\n    /msie [6-9]\\\\b/.test(navigator.userAgent.toLowerCase());\r\nfunction createInjector(context) {\r\n    return (id, style) => addStyle(id, style);\r\n}\r\nlet HEAD;\r\nconst styles = {};\r\nfunction addStyle(id, css) {\r\n    const group = isOldIE ? css.media || 'default' : id;\r\n    const style = styles[group] || (styles[group] = { ids: new Set(), styles: [] });\r\n    if (!style.ids.has(id)) {\r\n        style.ids.add(id);\r\n        let code = css.source;\r\n        if (css.map) {\r\n            // https://developer.chrome.com/devtools/docs/javascript-debugging\r\n            // this makes source maps inside style tags work properly in Chrome\r\n            code += '\\n/*# sourceURL=' + css.map.sources[0] + ' */';\r\n            // http://stackoverflow.com/a/26603875\r\n            code +=\r\n                '\\n/*# sourceMappingURL=data:application/json;base64,' +\r\n                    btoa(unescape(encodeURIComponent(JSON.stringify(css.map)))) +\r\n                    ' */';\r\n        }\r\n        if (!style.element) {\r\n            style.element = document.createElement('style');\r\n            style.element.type = 'text/css';\r\n            if (css.media)\r\n                style.element.setAttribute('media', css.media);\r\n            if (HEAD === undefined) {\r\n                HEAD = document.head || document.getElementsByTagName('head')[0];\r\n            }\r\n            HEAD.appendChild(style.element);\r\n        }\r\n        if ('styleSheet' in style.element) {\r\n            style.styles.push(code);\r\n            style.element.styleSheet.cssText = style.styles\r\n                .filter(Boolean)\r\n                .join('\\n');\r\n        }\r\n        else {\r\n            const index = style.ids.size - 1;\r\n            const textNode = document.createTextNode(code);\r\n            const nodes = style.element.childNodes;\r\n            if (nodes[index])\r\n                style.element.removeChild(nodes[index]);\r\n            if (nodes.length)\r\n                style.element.insertBefore(textNode, nodes[index]);\r\n            else\r\n                style.element.appendChild(textNode);\r\n        }\r\n    }\r\n}\n\n/* script */\nvar __vue_script__ = script;\n/* template */\n\nvar __vue_render__ = function __vue_render__() {\n  var _vm = this;\n\n  var _h = _vm.$createElement;\n\n  var _c = _vm._self._c || _h;\n\n  return _c('div', _vm._g({\n    ref: \"bottomSheet\",\n    class: ['bottom-sheet', {\n      opened: _vm.opened,\n      closed: _vm.opened === false,\n      moving: _vm.moving\n    }],\n    style: {\n      'pointer-events': _vm.backgroundClickable && _vm.clickToClose == false ? 'none' : 'all'\n    }\n  }, _vm.handlers), [_vm.overlay ? _c('div', {\n    staticClass: \"bottom-sheet__backdrop\",\n    style: {\n      'background': _vm.overlayColor\n    }\n  }) : _vm._e(), _vm._v(\" \"), _c('div', {\n    ref: \"bottomSheetCard\",\n    class: ['bottom-sheet__card', {\n      stripe: _vm.stripe,\n      square: !_vm.rounded\n    }, _vm.effect],\n    style: [{\n      bottom: _vm.cardP + 'px',\n      maxWidth: _vm.maxWidth,\n      maxHeight: _vm.maxHeight\n    }, {\n      'height': _vm.isFullScreen ? '100%' : 'auto'\n    }, {\n      'pointer-events': 'all'\n    }]\n  }, [_c('div', {\n    ref: \"pan\",\n    staticClass: \"bottom-sheet__pan\"\n  }, [_c('div', {\n    staticClass: \"bottom-sheet__bar\"\n  })]), _vm._v(\" \"), _c('div', {\n    ref: \"bottomSheetCardContent\",\n    staticClass: \"bottom-sheet__content\",\n    style: {\n      height: _vm.contentH\n    }\n  }, [_vm._t(\"default\")], 2)])]);\n};\n\nvar __vue_staticRenderFns__ = [];\n/* style */\n\nvar __vue_inject_styles__ = function __vue_inject_styles__(inject) {\n  if (!inject) return;\n  inject(\"data-v-61ac11a0_0\", {\n    source: \".bottom-sheet[data-v-61ac11a0]{z-index:99999;-webkit-transition:all .4s ease;transition:all .4s ease;position:relative}.bottom-sheet *[data-v-61ac11a0]{-webkit-box-sizing:border-box;box-sizing:border-box}.bottom-sheet__content[data-v-61ac11a0]{overflow-y:scroll}.bottom-sheet__backdrop[data-v-61ac11a0]{position:fixed;top:0;left:0;right:0;bottom:0;z-index:9999;opacity:0;visibility:hidden}.bottom-sheet__card[data-v-61ac11a0]{width:100%;position:fixed;background:#fff;border-radius:14px 14px 0 0;left:50%;z-index:9999;margin:0 auto}.bottom-sheet__card.square[data-v-61ac11a0]{border-radius:0}.bottom-sheet__card.stripe[data-v-61ac11a0]{padding-bottom:20px}.bottom-sheet__card.fx-default[data-v-61ac11a0]{-webkit-transform:translate(-50%,0);transform:translate(-50%,0);-webkit-transition:bottom .3s ease;transition:bottom .3s ease}.bottom-sheet__card.fx-fadein-scale[data-v-61ac11a0]{-webkit-transform:translate(-50%,0) scale(.7);transform:translate(-50%,0) scale(.7);opacity:0;-webkit-transition:all .3s;transition:all .3s}.bottom-sheet__card.fx-slide-from-right[data-v-61ac11a0]{-webkit-transform:translate(100%,0);transform:translate(100%,0);opacity:0;-webkit-transition:all .3s cubic-bezier(.25,.5,.5,.9);transition:all .3s cubic-bezier(.25,.5,.5,.9)}.bottom-sheet__card.fx-slide-from-left[data-v-61ac11a0]{-webkit-transform:translate(-100%,0);transform:translate(-100%,0);opacity:0;-webkit-transition:all .3s cubic-bezier(.25,.5,.5,.9);transition:all .3s cubic-bezier(.25,.5,.5,.9)}.bottom-sheet__pan[data-v-61ac11a0]{padding-bottom:20px;padding-top:15px;height:38px}.bottom-sheet__bar[data-v-61ac11a0]{display:block;width:50px;height:3px;border-radius:14px;margin:0 auto;cursor:pointer;background:rgba(0,0,0,.3)}.bottom-sheet.closed[data-v-61ac11a0]{opacity:0;visibility:hidden}.bottom-sheet.closed .bottom-sheet__backdrop[data-v-61ac11a0]{-webkit-animation:hide-data-v-61ac11a0 .3s ease;animation:hide-data-v-61ac11a0 .3s ease}.bottom-sheet.moving .bottom-sheet__card[data-v-61ac11a0]{-webkit-transition:none;transition:none}.bottom-sheet.opened[data-v-61ac11a0]{position:fixed;top:0;left:0;width:100%;height:100%}.bottom-sheet.opened .bottom-sheet__backdrop[data-v-61ac11a0]{-webkit-animation:show-data-v-61ac11a0 .3s ease;animation:show-data-v-61ac11a0 .3s ease;opacity:1;visibility:visible}.bottom-sheet.opened .bottom-sheet__card.fx-fadein-scale[data-v-61ac11a0]{-webkit-transform:translate(-50%,0) scale(1);transform:translate(-50%,0) scale(1);opacity:1}.bottom-sheet.opened .bottom-sheet__card.fx-slide-from-right[data-v-61ac11a0]{-webkit-transform:translate(-50%,0);transform:translate(-50%,0);opacity:1}.bottom-sheet.opened .bottom-sheet__card.fx-slide-from-left[data-v-61ac11a0]{-webkit-transform:translate(-50%,0);transform:translate(-50%,0);opacity:1}@-webkit-keyframes show-data-v-61ac11a0{0%{opacity:0;visibility:hidden}100%{opacity:1;visibility:visible}}@keyframes show-data-v-61ac11a0{0%{opacity:0;visibility:hidden}100%{opacity:1;visibility:visible}}@-webkit-keyframes hide-data-v-61ac11a0{0%{opacity:1;visibility:visible}100%{opacity:0;visibility:hidden}}@keyframes hide-data-v-61ac11a0{0%{opacity:1;visibility:visible}100%{opacity:0;visibility:hidden}}\",\n    map: undefined,\n    media: undefined\n  });\n};\n/* scoped */\n\n\nvar __vue_scope_id__ = \"data-v-61ac11a0\";\n/* module identifier */\n\nvar __vue_module_identifier__ = undefined;\n/* functional template */\n\nvar __vue_is_functional_template__ = false;\n/* style inject SSR */\n\n/* style inject shadow dom */\n\nvar __vue_component__ = /*#__PURE__*/normalizeComponent({\n  render: __vue_render__,\n  staticRenderFns: __vue_staticRenderFns__\n}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, createInjector, undefined, undefined);\n\n// Import vue component\n// IIFE injects install function into component, allowing component\n// to be registered via Vue.use() as well as Vue.component(),\n\nvar entry_esm = /*#__PURE__*/(function () {\n  // Get component instance\n  var installable = __vue_component__; // Attach install function executed by Vue.use()\n\n  installable.install = function (Vue) {\n    Vue.component('VueBottomSheet', installable);\n  };\n\n  return installable;\n})(); // It's possible to expose named exports when writing components that can\n// also be used as directives, etc. - eg. import { RollupDemoDirective } from 'rollup-demo';\n// export const RollupDemoDirective = directive;\n\nexport default entry_esm;\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n"],"sourceRoot":""}