{"version":3,"sources":["webpack:///./src/components/Card.vue?9cf3","webpack:///./node_modules/vue-chartjs/es/mixins/index.js","webpack:///./node_modules/vue-chartjs/es/BaseCharts.js","webpack:///./src/components/chart/base/PeriodSelect.vue?9e44","webpack:///./node_modules/cache-loader/dist/cjs.js","webpack:///./src/components/chart/base/PeriodSelect.vue?5780","webpack:///./src/components/chart/base/PeriodSelect.vue","webpack:///./src/components/inputs/SelectInput.vue?b196","webpack:///./src/components/inputs/SelectInput.vue?0e3b","webpack:///./src/components/inputs/SelectInput.vue","webpack:///./src/components/inputs/SelectInput.vue?cbc9","webpack:///./node_modules/core-js/internals/create-html.js","webpack:///./node_modules/core-js/modules/es.string.link.js","webpack:///./node_modules/chartjs-plugin-zoom/node_modules/hammerjs/hammer.js","webpack:///./src/components/Card.vue?834c","webpack:///./src/components/Card.vue?a40d","webpack:///./src/components/Card.vue","webpack:///./node_modules/core-js/internals/string-html-forced.js","webpack:///./src/components/BackNavigationToolbar.vue?6b15","webpack:///./src/components/BackNavigationToolbar.vue?b85b","webpack:///./src/components/BackNavigationToolbar.vue?badb","webpack:///./src/components/BackNavigationToolbar.vue","webpack:///./src/components/CardContainer.vue?fb39","webpack:///./src/components/CardContainer.vue?c526","webpack:///./src/components/CardContainer.vue","webpack:///./src/components/CardContainer.vue?b1f2","webpack:///./node_modules/chartjs-plugin-zoom/src/chart.zoom.js"],"names":["generateChart","chartId","chartType","render","createElement","style","this","styles","class","cssClasses","attrs","id","width","height","ref","props","default","type","String","Number","Object","plugins","Array","data","_chart","_plugins","methods","addPlugin","plugin","$data","push","generateLegend","renderChart","options","destroy","$refs","canvas","getContext","beforeDestroy","Bar","Doughnut","Line","_vm","_h","$createElement","_c","_self","small","compact","items","rules","value","required","clearable","chevronIcon","disabled","on","handleSelect","staticRenderFns","PeriodSelect","getItems","hourlyOptions","text","i18n","t","code","Period","Today","Yesterday","dailyOptions","Last7Days","ThisWeek","PreviousWeek","ThisMonth","PreviousMonth","showHourlyOptions","$emit","Vue","__decorate","Prop","undefined","Component","components","SelectInput","component","staticClass","fluid","wide","hideLabel","$t","label","prependIcon","top","dropdownOrientationUp","scopedSlots","_u","key","fn","proxy","uncurryThis","requireObjectCoercible","toString","quot","replace","module","exports","string","tag","attribute","S","p1","$","createHTML","forcedStringHTMLMethod","target","proto","forced","link","url","window","document","exportName","assign","VENDOR_PREFIXES","TEST_ELEMENT","TYPE_FUNCTION","round","Math","abs","now","Date","setTimeoutContext","timeout","context","setTimeout","bindFn","invokeArrayArg","arg","isArray","each","obj","iterator","i","forEach","length","call","hasOwnProperty","deprecate","method","name","message","deprecationMessage","e","Error","stack","log","console","warn","apply","arguments","TypeError","output","index","source","nextKey","extend","dest","src","merge","keys","inherit","child","base","properties","childP","baseP","prototype","create","constructor","_super","boolOrFn","val","args","ifUndefined","val1","val2","addEventListeners","types","handler","splitStr","addEventListener","removeEventListeners","removeEventListener","hasParent","node","parent","parentNode","inStr","str","find","indexOf","trim","split","inArray","findByKey","toArray","slice","uniqueArray","sort","results","values","a","b","prefixed","property","prefix","prop","camelProp","toUpperCase","_uniqueId","uniqueId","getWindowForElement","element","doc","ownerDocument","defaultView","parentWindow","MOBILE_REGEX","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","test","navigator","userAgent","INPUT_TYPE_TOUCH","INPUT_TYPE_PEN","INPUT_TYPE_MOUSE","INPUT_TYPE_KINECT","COMPUTE_INTERVAL","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","PROPS_XY","PROPS_CLIENT_XY","Input","manager","callback","self","inputTarget","domHandler","ev","enable","init","createInputInstance","Type","inputClass","PointerEventInput","TouchInput","TouchMouseInput","MouseInput","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","computeInputData","emit","recognize","prevInput","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","computeDeltaXY","offsetDirection","getDirection","deltaX","deltaY","overallVelocity","getVelocity","overallVelocityX","x","overallVelocityY","y","scale","getScale","rotation","getRotation","maxPointers","computeIntervalInputData","srcEvent","offset","offsetDelta","prevDelta","velocity","velocityX","velocityY","direction","last","lastInterval","v","clientX","clientY","p2","sqrt","atan2","PI","start","end","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","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","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","toLowerCase","isTouch","storeIndex","pointerId","splice","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SINGLE_TOUCH_TARGET_EVENTS","SINGLE_TOUCH_WINDOW_EVENTS","SingleTouchInput","started","normalizeSingleTouches","all","touches","changed","changedTouches","concat","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","filter","touch","DEDUP_TIMEOUT","DEDUP_DISTANCE","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","removeLastTouch","isSyntheticEvent","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","getTouchActionProps","TouchAction","set","cleanTouchActions","actions","hasPanX","hasPanY","touchMap","cssSupports","CSS","supports","compute","update","touchAction","recognizers","recognizer","getTouchAction","join","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","STATE_FAILED","Recognizer","defaults","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","event","additionalEvent","tryEmit","canEmit","inputDataClone","reset","process","attrTest","optionPointers","isRecognized","isValid","threshold","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","clearTimeout","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","STOP","FORCED_STOP","handlers","oldCssProps","toggleCssProps","item","add","triggerDomEvent","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","stop","force","stopped","curRecognizer","existing","remove","events","off","Tap","Pan","Swipe","Pinch","Rotate","Press","freeGlobal","_b","$attrs","title","routeName","titleAbsolute","navigate","_v","_s","_e","translate","_t","Card","$router","params","routeParams","editIcon","fails","METHOD_NAME","$event","goToPage","BackNavigationToolbar","go","CardContainer","Chart","helpers","zoomNS","Zoom","zoomFunctions","panFunctions","defaultOptions","pan","enabled","mode","speed","zoom","sensitivity","directionEnabled","dir","rangeMaxLimiter","zoomPanOptions","newMax","scaleAxes","rangeMax","isNullOrUndef","rangeMinLimiter","newMin","rangeMin","zoomIndexScale","zoomOptions","labels","chart","minIndex","lastLabelIndex","maxIndex","chartCenter","isHorizontal","left","centerPointer","zoomCumulativeDelta","min","max","ticks","zoomTimeScale","range","min_percent","right","bottom","max_percent","newDiff","minDelta","maxDelta","getValueForPixel","getPixelForValue","diffMinMax","diff","minLimitExceeded","maxLimitExceeded","zoomNumericalScale","cursorPixel","zoomScale","doZoom","chartInstance","whichAxes","ca","chartArea","getValueOrDefault","_whichAxes","zoomMode","scales","panIndexScale","delta","panOptions","offsetAmt","gridLines","panSpeed","step","panCumulativeDelta","panTimeScale","limitedMax","limitedMin","limitedTimeDelta","panNumericalScale","tickOpts","reverse","panScale","doPan","panMode","getYAxis","scaleId","category","linear","logarithmic","zoomPlugin","afterInit","originalOptions","JSON","parse","stringify","resetZoom","timeOptions","tickOptions","configMerge","datasets","dataset","_meta","beforeInit","ctx","panThreshold","drag","_mouseDownHandler","_dragZoomStart","_mouseMoveHandler","_dragZoomEnd","_mouseUpHandler","yAxis","beginPoint","offsetX","getBoundingClientRect","startX","endX","dragDistance","chartDistance","_wheelHandler","rect","offsetY","currentPinchScaling","mc","handlePinch","xy","p","currentDeltaX","currentDeltaY","panning","handlePan","_ghostClickHandler","stopImmediatePropagation","_mc","beforeDatasetsDraw","save","beginPath","endPoint","rectWidth","fillStyle","lineWidth","fillRect","clip","afterDatasetsDraw","restore","pluginService","register"],"mappings":"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","file":"js/chunk-3c43cc4a.8339270d.js","sourcesContent":["export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Card.vue?vue&type=style&index=0&id=5778e0a5&lang=scss&scoped=true&\"","function dataHandler(newData, oldData) {\n  if (oldData) {\n    var chart = this.$data._chart;\n    var newDatasetLabels = newData.datasets.map(function (dataset) {\n      return dataset.label;\n    });\n    var oldDatasetLabels = oldData.datasets.map(function (dataset) {\n      return dataset.label;\n    });\n    var oldLabels = JSON.stringify(oldDatasetLabels);\n    var newLabels = JSON.stringify(newDatasetLabels);\n\n    if (newLabels === oldLabels && oldData.datasets.length === newData.datasets.length) {\n      newData.datasets.forEach(function (dataset, i) {\n        var oldDatasetKeys = Object.keys(oldData.datasets[i]);\n        var newDatasetKeys = Object.keys(dataset);\n        var deletionKeys = oldDatasetKeys.filter(function (key) {\n          return key !== '_meta' && newDatasetKeys.indexOf(key) === -1;\n        });\n        deletionKeys.forEach(function (deletionKey) {\n          delete chart.data.datasets[i][deletionKey];\n        });\n\n        for (var attribute in dataset) {\n          if (dataset.hasOwnProperty(attribute)) {\n            chart.data.datasets[i][attribute] = dataset[attribute];\n          }\n        }\n      });\n\n      if (newData.hasOwnProperty('labels')) {\n        chart.data.labels = newData.labels;\n        this.$emit('labels:update');\n      }\n\n      if (newData.hasOwnProperty('xLabels')) {\n        chart.data.xLabels = newData.xLabels;\n        this.$emit('xlabels:update');\n      }\n\n      if (newData.hasOwnProperty('yLabels')) {\n        chart.data.yLabels = newData.yLabels;\n        this.$emit('ylabels:update');\n      }\n\n      chart.update();\n      this.$emit('chart:update');\n    } else {\n      if (chart) {\n        chart.destroy();\n        this.$emit('chart:destroy');\n      }\n\n      this.renderChart(this.chartData, this.options);\n      this.$emit('chart:render');\n    }\n  } else {\n    if (this.$data._chart) {\n      this.$data._chart.destroy();\n\n      this.$emit('chart:destroy');\n    }\n\n    this.renderChart(this.chartData, this.options);\n    this.$emit('chart:render');\n  }\n}\n\nexport var reactiveData = {\n  data: function data() {\n    return {\n      chartData: null\n    };\n  },\n  watch: {\n    'chartData': dataHandler\n  }\n};\nexport var reactiveProp = {\n  props: {\n    chartData: {\n      type: Object,\n      required: true,\n      default: function _default() {}\n    }\n  },\n  watch: {\n    'chartData': dataHandler\n  }\n};\nexport default {\n  reactiveData: reactiveData,\n  reactiveProp: reactiveProp\n};","import Chart from 'chart.js';\nexport function generateChart(chartId, chartType) {\n  return {\n    render: function render(createElement) {\n      return createElement('div', {\n        style: this.styles,\n        class: this.cssClasses\n      }, [createElement('canvas', {\n        attrs: {\n          id: this.chartId,\n          width: this.width,\n          height: this.height\n        },\n        ref: 'canvas'\n      })]);\n    },\n    props: {\n      chartId: {\n        default: chartId,\n        type: String\n      },\n      width: {\n        default: 400,\n        type: Number\n      },\n      height: {\n        default: 400,\n        type: Number\n      },\n      cssClasses: {\n        type: String,\n        default: ''\n      },\n      styles: {\n        type: Object\n      },\n      plugins: {\n        type: Array,\n        default: function _default() {\n          return [];\n        }\n      }\n    },\n    data: function data() {\n      return {\n        _chart: null,\n        _plugins: this.plugins\n      };\n    },\n    methods: {\n      addPlugin: function addPlugin(plugin) {\n        this.$data._plugins.push(plugin);\n      },\n      generateLegend: function generateLegend() {\n        if (this.$data._chart) {\n          return this.$data._chart.generateLegend();\n        }\n      },\n      renderChart: function renderChart(data, options) {\n        if (this.$data._chart) this.$data._chart.destroy();\n        this.$data._chart = new Chart(this.$refs.canvas.getContext('2d'), {\n          type: chartType,\n          data: data,\n          options: options,\n          plugins: this.$data._plugins\n        });\n      }\n    },\n    beforeDestroy: function beforeDestroy() {\n      if (this.$data._chart) {\n        this.$data._chart.destroy();\n      }\n    }\n  };\n}\nexport var Bar = generateChart('bar-chart', 'bar');\nexport var HorizontalBar = generateChart('horizontalbar-chart', 'horizontalBar');\nexport var Doughnut = generateChart('doughnut-chart', 'doughnut');\nexport var Line = generateChart('line-chart', 'line');\nexport var Pie = generateChart('pie-chart', 'pie');\nexport var PolarArea = generateChart('polar-chart', 'polarArea');\nexport var Radar = generateChart('radar-chart', 'radar');\nexport var Bubble = generateChart('bubble-chart', 'bubble');\nexport var Scatter = generateChart('scatter-chart', 'scatter');\nexport default {\n  Bar: Bar,\n  HorizontalBar: HorizontalBar,\n  Doughnut: Doughnut,\n  Line: Line,\n  Pie: Pie,\n  PolarArea: PolarArea,\n  Radar: Radar,\n  Bubble: Bubble,\n  Scatter: Scatter\n};","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('n-select-input',{attrs:{\"small\":_vm.small,\"compact\":_vm.compact,\"items\":_vm.items,\"rules\":_vm.rules || [],\"value\":_vm.value,\"required\":_vm.required,\"clearable\":_vm.clearable,\"chevron-icon\":_vm.chevronIcon,\"disabled\":_vm.disabled},on:{\"change\":_vm.handleSelect}})}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\nimport { Component, Vue, Prop } from 'vue-property-decorator';\n\n@Component\nexport default class CardContainer extends Vue {\n}\n","import mod from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/ts-loader/index.js??ref--14-3!../../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./PeriodSelect.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/ts-loader/index.js??ref--14-3!../../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./PeriodSelect.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./PeriodSelect.vue?vue&type=template&id=58ca0a02&\"\nimport script from \"./PeriodSelect.vue?vue&type=script&lang=ts&\"\nexport * from \"./PeriodSelect.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('v-select',{staticClass:\"select\",class:{'select--small': _vm.small, 'select--fluid': _vm.fluid, 'select--wide': _vm.wide, 'select--fluid-hidelabel': _vm.hideLabel, 'select--compact': _vm.compact },attrs:{\"items\":_vm.items,\"rules\":_vm.rules || [],\"label\":_vm.$t(_vm.label),\"value\":_vm.value,\"item-text\":\"text\",\"item-value\":\"code\",\"clearable\":_vm.clearable,\"required\":_vm.required,\"disabled\":_vm.disabled,\"prepend-icon\":_vm.prependIcon,\"data-test\":_vm.label,\"attach\":\"\",\"menu-props\":{ top: _vm.dropdownOrientationUp }},on:{\"change\":_vm.handleSelect},scopedSlots:_vm._u([(_vm.small || _vm.chevronIcon)?{key:\"append\",fn:function(){return [_c('i',{staticClass:\"icon-angle-down select--small__icon\"})]},proxy:true}:null],null,true)})}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--14-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SelectInput.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--14-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SelectInput.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./SelectInput.vue?vue&type=template&id=3c2490d4&scoped=true&\"\nimport script from \"./SelectInput.vue?vue&type=script&lang=ts&\"\nexport * from \"./SelectInput.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./SelectInput.vue?vue&type=style&index=0&id=3c2490d4&lang=scss&scoped=true&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"3c2490d4\",\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SelectInput.vue?vue&type=style&index=0&id=3c2490d4&lang=scss&scoped=true&\"","var uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\n\nvar quot = /\"/g;\nvar replace = uncurryThis(''.replace);\n\n// `CreateHTML` abstract operation\n// https://tc39.es/ecma262/#sec-createhtml\nmodule.exports = function (string, tag, attribute, value) {\n  var S = toString(requireObjectCoercible(string));\n  var p1 = '<' + tag;\n  if (attribute !== '') p1 += ' ' + attribute + '=\"' + replace(toString(value), quot, '&quot;') + '\"';\n  return p1 + '>' + S + '</' + tag + '>';\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar createHTML = require('../internals/create-html');\nvar forcedStringHTMLMethod = require('../internals/string-html-forced');\n\n// `String.prototype.link` method\n// https://tc39.es/ecma262/#sec-string.prototype.link\n$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, {\n  link: function link(url) {\n    return createHTML(this, 'a', 'href', url);\n  }\n});\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',_vm._b({staticClass:\"card\",class:{\n          'card--xs': _vm.type === 'xs',\n          'card--s': _vm.type === 's',\n          'card--m': _vm.type === 'm',\n          'card--l': _vm.type === 'l',\n          'card--xl': _vm.type === 'xl',\n          'card--xxl': _vm.type === 'xxl',\n          'card--full': _vm.type === 'full',\n      }},'div',_vm.$attrs,false),[_c('div',{staticClass:\"card__header\"},[(!!_vm.title)?_c('span',{staticClass:\"card__title\",class:{'card__title--link': !!_vm.routeName, 'card__title--absolute': _vm.titleAbsolute },on:{\"click\":_vm.navigate}},[(_vm.translate)?_c('span',[_vm._v(_vm._s(_vm.$t(_vm.title)))]):_vm._e(),(!_vm.translate)?_c('span',[_vm._v(_vm._s(_vm.title))]):_vm._e(),(_vm.editIcon)?_c('v-icon',{staticClass:\"ml-1\",attrs:{\"size\":\"large\"}},[_vm._v(\"mdi-pencil\")]):_vm._e(),(_vm.showArrowRight)?_c('i',{staticClass:\"icon-angle-right card__icon\"}):_vm._e()],1):_vm._e(),_c('div',{staticClass:\"card__actions\"},[_vm._t(\"actions\")],2)]),_vm._t(\"default\")],2)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--14-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Card.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--14-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Card.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./Card.vue?vue&type=template&id=5778e0a5&scoped=true&\"\nimport script from \"./Card.vue?vue&type=script&lang=ts&\"\nexport * from \"./Card.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./Card.vue?vue&type=style&index=0&id=5778e0a5&lang=scss&scoped=true&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"5778e0a5\",\n  null\n  \n)\n\nexport default component.exports","var fails = require('../internals/fails');\n\n// check the existence of a method, lowercase\n// of a tag and escaping quotes in arguments\nmodule.exports = function (METHOD_NAME) {\n  return fails(function () {\n    var test = ''[METHOD_NAME]('\"');\n    return test !== test.toLowerCase() || test.split('\"').length > 3;\n  });\n};\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./BackNavigationToolbar.vue?vue&type=style&index=0&id=8a8411b2&lang=scss&scoped=true&\"","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"toolbar\"},[_c('div',{staticClass:\"toolbar__title\"},[(_vm.allowBack)?_c('i',{staticClass:\"icon-arrow-left\",on:{\"click\":function($event){return _vm.goToPage()}}}):_vm._e(),_c('span',[_vm._v(_vm._s(_vm.title))])]),_c('div',{staticClass:\"toolbar__actions\"},[_vm._t(\"actions\")],2)])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--14-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./BackNavigationToolbar.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--14-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./BackNavigationToolbar.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./BackNavigationToolbar.vue?vue&type=template&id=8a8411b2&scoped=true&\"\nimport script from \"./BackNavigationToolbar.vue?vue&type=script&lang=ts&\"\nexport * from \"./BackNavigationToolbar.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./BackNavigationToolbar.vue?vue&type=style&index=0&id=8a8411b2&lang=scss&scoped=true&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"8a8411b2\",\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"card-container\"},[_vm._t(\"default\")],2)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--14-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./CardContainer.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--14-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--14-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./CardContainer.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./CardContainer.vue?vue&type=template&id=4bfdfbdd&scoped=true&\"\nimport script from \"./CardContainer.vue?vue&type=script&lang=ts&\"\nexport * from \"./CardContainer.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./CardContainer.vue?vue&type=style&index=0&id=4bfdfbdd&lang=scss&scoped=true&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"4bfdfbdd\",\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./CardContainer.vue?vue&type=style&index=0&id=4bfdfbdd&lang=scss&scoped=true&\"","/*jslint browser:true, devel:true, white:true, vars:true */\n/*global require*/\n\n// hammer JS for touch support\nvar Hammer = require('hammerjs');\nHammer = typeof(Hammer) === 'function' ? Hammer : window.Hammer;\n\n// Get the chart variable\nvar Chart = require('chart.js');\nChart = typeof(Chart) === 'function' ? Chart : window.Chart;\nvar helpers = Chart.helpers;\n\n// Take the zoom namespace of Chart\nvar zoomNS = Chart.Zoom = Chart.Zoom || {};\n\n// Where we store functions to handle different scale types\nvar zoomFunctions = zoomNS.zoomFunctions = zoomNS.zoomFunctions || {};\nvar panFunctions = zoomNS.panFunctions = zoomNS.panFunctions || {};\n\n// Default options if none are provided\nvar defaultOptions = zoomNS.defaults = {\n\tpan: {\n\t\tenabled: true,\n\t\tmode: 'xy',\n\t\tspeed: 20,\n\t\tthreshold: 10\n\t},\n\tzoom: {\n\t\tenabled: true,\n\t\tmode: 'xy',\n\t\tsensitivity: 3\n\t}\n};\n\nfunction directionEnabled(mode, dir) {\n\tif (mode === undefined) {\n\t\treturn true;\n\t} else if (typeof mode === 'string') {\n\t\treturn mode.indexOf(dir) !== -1;\n\t}\n\n\treturn false;\n}\n\nfunction rangeMaxLimiter(zoomPanOptions, newMax) {\n\tif (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMax &&\n\t\t\t!helpers.isNullOrUndef(zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes])) {\n\t\tvar rangeMax = zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes];\n\t\tif (newMax > rangeMax) {\n\t\t\tnewMax = rangeMax;\n\t\t}\n\t}\n\treturn newMax;\n}\n\nfunction rangeMinLimiter(zoomPanOptions, newMin) {\n\tif (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMin &&\n\t\t\t!helpers.isNullOrUndef(zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes])) {\n\t\tvar rangeMin = zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes];\n\t\tif (newMin < rangeMin) {\n\t\t\tnewMin = rangeMin;\n\t\t}\n\t}\n\treturn newMin;\n}\n\nfunction zoomIndexScale(scale, zoom, center, zoomOptions) {\n\tvar labels = scale.chart.data.labels;\n\tvar minIndex = scale.minIndex;\n\tvar lastLabelIndex = labels.length - 1;\n\tvar maxIndex = scale.maxIndex;\n\tvar sensitivity = zoomOptions.sensitivity;\n\tvar chartCenter =  scale.isHorizontal() ? scale.left + (scale.width/2) : scale.top + (scale.height/2);\n\tvar centerPointer = scale.isHorizontal() ? center.x : center.y;\n\n\tzoomNS.zoomCumulativeDelta = zoom > 1 ? zoomNS.zoomCumulativeDelta + 1 : zoomNS.zoomCumulativeDelta - 1;\n\n\tif (Math.abs(zoomNS.zoomCumulativeDelta) > sensitivity){\n\t\tif(zoomNS.zoomCumulativeDelta < 0){\n\t\t\tif(centerPointer >= chartCenter){\n\t\t\t\tif (minIndex <= 0){\n\t\t\t\t\tmaxIndex = Math.min(lastLabelIndex, maxIndex + 1);\n\t\t\t\t} else{\n\t\t\t\t\tminIndex = Math.max(0, minIndex - 1);\n\t\t\t\t}\n\t\t\t} else if(centerPointer < chartCenter){\n\t\t\t\tif (maxIndex >= lastLabelIndex){\n\t\t\t\t\tminIndex = Math.max(0, minIndex - 1);\n\t\t\t\t} else{\n\t\t\t\t\tmaxIndex = Math.min(lastLabelIndex, maxIndex + 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\tzoomNS.zoomCumulativeDelta = 0;\n\t\t}\n\t\telse if(zoomNS.zoomCumulativeDelta > 0){\n\t\t\tif(centerPointer >= chartCenter){\n\t\t\t\tminIndex = minIndex < maxIndex ? minIndex = Math.min(maxIndex, minIndex + 1) : minIndex;\n\t\t\t} else if(centerPointer < chartCenter){\n\t\t\t\tmaxIndex = maxIndex > minIndex ? maxIndex = Math.max(minIndex, maxIndex - 1) : maxIndex;\n\t\t\t}\n\t\t\tzoomNS.zoomCumulativeDelta = 0;\n\t\t}\n\t\tscale.options.ticks.min = rangeMinLimiter(zoomOptions, labels[minIndex]);\n\t\tscale.options.ticks.max = rangeMaxLimiter(zoomOptions, labels[maxIndex]);\n\t}\n}\n\nfunction zoomTimeScale(scale, zoom, center, zoomOptions) {\n\tvar options = scale.options;\n\n\tvar range;\n\tvar min_percent;\n\tif (scale.isHorizontal()) {\n\t\trange = scale.right - scale.left;\n\t\tmin_percent = (center.x - scale.left) / range;\n\t} else {\n\t\trange = scale.bottom - scale.top;\n\t\tmin_percent = (center.y - scale.top) / range;\n\t}\n\n\tvar max_percent = 1 - min_percent;\n\tvar newDiff = range * (zoom - 1);\n\n\tvar minDelta = newDiff * min_percent;\n\tvar maxDelta = newDiff * max_percent;\n\n\tvar newMin = scale.getValueForPixel(scale.getPixelForValue(scale.min) + minDelta);\n\tvar newMax = scale.getValueForPixel(scale.getPixelForValue(scale.max) - maxDelta);\n\n\tvar diffMinMax = newMax.diff(newMin);\n\tvar minLimitExceeded = rangeMinLimiter(zoomOptions, diffMinMax) != diffMinMax;\n\tvar maxLimitExceeded = rangeMaxLimiter(zoomOptions, diffMinMax) != diffMinMax;\n\n\tif (!minLimitExceeded && !maxLimitExceeded) {\n\t\toptions.time.min = newMin;\n\t\toptions.time.max = newMax;\n\t}\n}\n\nfunction zoomNumericalScale(scale, zoom, center, zoomOptions) {\n\tvar range = scale.max - scale.min;\n\tvar newDiff = range * (zoom - 1);\n\n\tvar cursorPixel = scale.isHorizontal() ? center.x : center.y;\n\tvar min_percent = (scale.getValueForPixel(cursorPixel) - scale.min) / range;\n\tvar max_percent = 1 - min_percent;\n\n\tvar minDelta = newDiff * min_percent;\n\tvar maxDelta = newDiff * max_percent;\n\n\tscale.options.ticks.min = rangeMinLimiter(zoomOptions, scale.min + minDelta);\n\tscale.options.ticks.max = rangeMaxLimiter(zoomOptions, scale.max - maxDelta);\n}\n\nfunction zoomScale(scale, zoom, center, zoomOptions) {\n\tvar fn = zoomFunctions[scale.options.type];\n\tif (fn) {\n\t\tfn(scale, zoom, center, zoomOptions);\n\t}\n}\n\nfunction doZoom(chartInstance, zoom, center, whichAxes) {\n\tvar ca = chartInstance.chartArea;\n\tif (!center) {\n\t\tcenter = {\n\t\t\tx: (ca.left + ca.right) / 2,\n\t\t\ty: (ca.top + ca.bottom) / 2,\n\t\t};\n\t}\n\n\tvar zoomOptions = chartInstance.options.zoom;\n\n\tif (zoomOptions && helpers.getValueOrDefault(zoomOptions.enabled, defaultOptions.zoom.enabled)) {\n\t\t// Do the zoom here\n\t\tvar zoomMode = helpers.getValueOrDefault(chartInstance.options.zoom.mode, defaultOptions.zoom.mode);\n\t\tzoomOptions.sensitivity = helpers.getValueOrDefault(chartInstance.options.zoom.sensitivity, defaultOptions.zoom.sensitivity);\n\n\t\t// Which axe should be modified when figers were used.\n\t\tvar _whichAxes;\n\t\tif (zoomMode == 'xy' && whichAxes !== undefined) {\n\t\t\t// based on fingers positions\n\t\t\t_whichAxes = whichAxes;\n\t\t} else {\n\t\t\t// no effect\n\t\t\t_whichAxes = 'xy';\n\t\t}\n\n\t\thelpers.each(chartInstance.scales, function(scale, id) {\n\t\t\tif (scale.isHorizontal() && directionEnabled(zoomMode, 'x') && directionEnabled(_whichAxes, 'x')) {\n\t\t\t\tzoomOptions.scaleAxes = \"x\";\n\t\t\t\tzoomScale(scale, zoom, center, zoomOptions);\n\t\t\t} else if (!scale.isHorizontal() && directionEnabled(zoomMode, 'y') && directionEnabled(_whichAxes, 'y')) {\n\t\t\t\t// Do Y zoom\n\t\t\t\tzoomOptions.scaleAxes = \"y\";\n\t\t\t\tzoomScale(scale, zoom, center, zoomOptions);\n\t\t\t}\n\t\t});\n\n\t\tchartInstance.update(0);\n\t}\n}\n\nfunction panIndexScale(scale, delta, panOptions) {\n\tvar labels = scale.chart.data.labels;\n\tvar lastLabelIndex = labels.length - 1;\n\tvar offsetAmt = Math.max((scale.ticks.length - ((scale.options.gridLines.offsetGridLines) ? 0 : 1)), 1);\n\tvar panSpeed = panOptions.speed;\n\tvar minIndex = scale.minIndex;\n\tvar step = Math.round(scale.width / (offsetAmt * panSpeed));\n\tvar maxIndex;\n\n\tzoomNS.panCumulativeDelta += delta;\n\n\tminIndex = zoomNS.panCumulativeDelta > step ? Math.max(0, minIndex -1) : zoomNS.panCumulativeDelta < -step ? Math.min(lastLabelIndex - offsetAmt + 1, minIndex + 1) : minIndex;\n\tzoomNS.panCumulativeDelta = minIndex !== scale.minIndex ? 0 : zoomNS.panCumulativeDelta;\n\n\tmaxIndex = Math.min(lastLabelIndex, minIndex + offsetAmt - 1);\n\n\tscale.options.ticks.min = rangeMinLimiter(panOptions, labels[minIndex]);\n\tscale.options.ticks.max = rangeMaxLimiter(panOptions, labels[maxIndex]);\n}\n\nfunction panTimeScale(scale, delta, panOptions) {\n\tvar options = scale.options;\n\tvar limitedMax = rangeMaxLimiter(panOptions, scale.getValueForPixel(scale.getPixelForValue(scale.max) - delta));\n\tvar limitedMin = rangeMinLimiter(panOptions, scale.getValueForPixel(scale.getPixelForValue(scale.min) - delta));\n\n\tvar limitedTimeDelta = delta < 0 ? limitedMax - scale.max : limitedMin - scale.min;\n\n\toptions.time.max = scale.max + limitedTimeDelta;\n\toptions.time.min = scale.min + limitedTimeDelta;\n}\n\nfunction panNumericalScale(scale, delta, panOptions) {\n\tvar tickOpts = scale.options.ticks;\n\tvar start = scale.start,\n\t\tend = scale.end;\n\n\tif (tickOpts.reverse) {\n\t\ttickOpts.max = scale.getValueForPixel(scale.getPixelForValue(start) - delta);\n\t\ttickOpts.min = scale.getValueForPixel(scale.getPixelForValue(end) - delta);\n\t} else {\n\t\ttickOpts.min = scale.getValueForPixel(scale.getPixelForValue(start) - delta);\n\t\ttickOpts.max = scale.getValueForPixel(scale.getPixelForValue(end) - delta);\n\t}\n\ttickOpts.min = rangeMinLimiter(panOptions, tickOpts.min);\n\ttickOpts.max = rangeMaxLimiter(panOptions, tickOpts.max);\n}\n\nfunction panScale(scale, delta, panOptions) {\n\tvar fn = panFunctions[scale.options.type];\n\tif (fn) {\n\t\tfn(scale, delta, panOptions);\n\t}\n}\n\nfunction doPan(chartInstance, deltaX, deltaY) {\n\tvar panOptions = chartInstance.options.pan;\n\tif (panOptions && helpers.getValueOrDefault(panOptions.enabled, defaultOptions.pan.enabled)) {\n\t\tvar panMode = helpers.getValueOrDefault(chartInstance.options.pan.mode, defaultOptions.pan.mode);\n\t\tpanOptions.speed = helpers.getValueOrDefault(chartInstance.options.pan.speed, defaultOptions.pan.speed);\n\n\t\thelpers.each(chartInstance.scales, function(scale, id) {\n\t\t\tif (scale.isHorizontal() && directionEnabled(panMode, 'x') && deltaX !== 0) {\n\t\t\t\tpanOptions.scaleAxes = \"x\";\n\t\t\t\tpanScale(scale, deltaX, panOptions);\n\t\t\t} else if (!scale.isHorizontal() && directionEnabled(panMode, 'y') && deltaY !== 0) {\n\t\t\t\tpanOptions.scaleAxes = \"y\";\n\t\t\t\tpanScale(scale, deltaY, panOptions);\n\t\t\t}\n\t\t});\n\n\t\tchartInstance.update(0);\n\t}\n}\n\nfunction positionInChartArea(chartInstance, position) {\n\treturn \t(position.x >= chartInstance.chartArea.left && position.x <= chartInstance.chartArea.right) &&\n\t\t(position.y >= chartInstance.chartArea.top && position.y <= chartInstance.chartArea.bottom);\n}\n\nfunction getYAxis(chartInstance) {\n\tvar scales = chartInstance.scales;\n\n\tfor (var scaleId in scales) {\n\t\tvar scale = scales[scaleId];\n\n\t\tif (!scale.isHorizontal()) {\n\t\t\treturn scale;\n\t\t}\n\t}\n}\n\n// Store these for later\nzoomNS.zoomFunctions.category = zoomIndexScale;\nzoomNS.zoomFunctions.time = zoomTimeScale;\nzoomNS.zoomFunctions.linear = zoomNumericalScale;\nzoomNS.zoomFunctions.logarithmic = zoomNumericalScale;\nzoomNS.panFunctions.category = panIndexScale;\nzoomNS.panFunctions.time = panTimeScale;\nzoomNS.panFunctions.linear = panNumericalScale;\nzoomNS.panFunctions.logarithmic = panNumericalScale;\n// Globals for catergory pan and zoom\nzoomNS.panCumulativeDelta = 0;\nzoomNS.zoomCumulativeDelta = 0;\n\n// Chartjs Zoom Plugin\nvar zoomPlugin = {\n\tafterInit: function(chartInstance) {\n\t\thelpers.each(chartInstance.scales, function(scale) {\n\t\t\tscale.originalOptions = JSON.parse(JSON.stringify(scale.options));\n\t\t});\n\n\t\tchartInstance.resetZoom = function() {\n\t\t\thelpers.each(chartInstance.scales, function(scale, id) {\n\t\t\t\tvar timeOptions = scale.options.time;\n\t\t\t\tvar tickOptions = scale.options.ticks;\n\n\t\t\t\tif (timeOptions) {\n\t\t\t\t\tdelete timeOptions.min;\n\t\t\t\t\tdelete timeOptions.max;\n\t\t\t\t}\n\n\t\t\t\tif (tickOptions) {\n\t\t\t\t\tdelete tickOptions.min;\n\t\t\t\t\tdelete tickOptions.max;\n\t\t\t\t}\n\n\t\t\t\tscale.options = helpers.configMerge(scale.options, scale.originalOptions);\n\t\t\t});\n\n\t\t\thelpers.each(chartInstance.data.datasets, function(dataset, id) {\n\t\t\t\tdataset._meta = null;\n\t\t\t});\n\n\t\t\tchartInstance.update();\n\t\t};\n\n\t},\n\tbeforeInit: function(chartInstance) {\n\t\tchartInstance.zoom = {};\n\n\t\tvar node = chartInstance.zoom.node = chartInstance.chart.ctx.canvas;\n\n\t\tvar options = chartInstance.options;\n\t\tvar panThreshold = helpers.getValueOrDefault(options.pan ? options.pan.threshold : undefined, zoomNS.defaults.pan.threshold);\n\t\tif (!options.zoom || !options.zoom.enabled) {\n\t\t\treturn;\n\t\t}\n\t\tif (options.zoom.drag) {\n\t\t\t// Only want to zoom horizontal axis\n\t\t\toptions.zoom.mode = 'x';\n\n\t\t\tchartInstance.zoom._mouseDownHandler = function(event) {\n\t\t\t\tchartInstance.zoom._dragZoomStart = event;\n\t\t\t};\n\t\t\tnode.addEventListener('mousedown', chartInstance.zoom._mouseDownHandler);\n\n\t\t\tchartInstance.zoom._mouseMoveHandler = function(event){\n\t\t\t\tif (chartInstance.zoom._dragZoomStart) {\n\t\t\t\t\tchartInstance.zoom._dragZoomEnd = event;\n\t\t\t\t\tchartInstance.update(0);\n\t\t\t\t}\n\n\t\t\t\tchartInstance.update(0);\n\t\t\t};\n\t\t\tnode.addEventListener('mousemove', chartInstance.zoom._mouseMoveHandler);\n\n\t\t\tchartInstance.zoom._mouseUpHandler = function(event){\n\t\t\t\tif (chartInstance.zoom._dragZoomStart) {\n\t\t\t\t\tvar chartArea = chartInstance.chartArea;\n\t\t\t\t\tvar yAxis = getYAxis(chartInstance);\n\t\t\t\t\tvar beginPoint = chartInstance.zoom._dragZoomStart;\n\t\t\t\t\tvar offsetX = beginPoint.target.getBoundingClientRect().left;\n\t\t\t\t\tvar startX = Math.min(beginPoint.clientX, event.clientX) - offsetX;\n\t\t\t\t\tvar endX = Math.max(beginPoint.clientX, event.clientX) - offsetX;\n\t\t\t\t\tvar dragDistance = endX - startX;\n\t\t\t\t\tvar chartDistance = chartArea.right - chartArea.left;\n\t\t\t\t\tvar zoom = 1 + ((chartDistance - dragDistance) / chartDistance );\n\n\t\t\t\t\tif (dragDistance > 0) {\n\t\t\t\t\t\tdoZoom(chartInstance, zoom, {\n\t\t\t\t\t\t\tx: (dragDistance / 2) + startX,\n\t\t\t\t\t\t\ty: (yAxis.bottom - yAxis.top) / 2,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\n\t\t\t\t\tchartInstance.zoom._dragZoomStart = null;\n\t\t\t\t\tchartInstance.zoom._dragZoomEnd = null;\n\t\t\t\t}\n\t\t\t};\n\t\t\tnode.addEventListener('mouseup', chartInstance.zoom._mouseUpHandler);\n\t\t} else {\n\t\t\tchartInstance.zoom._wheelHandler = function(event) {\n\t\t\t\tvar rect = event.target.getBoundingClientRect();\n\t\t\t\tvar offsetX = event.clientX - rect.left;\n\t\t\t\tvar offsetY = event.clientY - rect.top;\n\n\t\t\t\tvar center = {\n\t\t\t\t\tx : offsetX,\n\t\t\t\t\ty : offsetY\n\t\t\t\t};\n\n\t\t\t\tif (event.deltaY < 0) {\n\t\t\t\t\tdoZoom(chartInstance, 1.1, center);\n\t\t\t\t} else {\n\t\t\t\t\tdoZoom(chartInstance, 0.909, center);\n\t\t\t\t}\n\t\t\t\t// Prevent the event from triggering the default behavior (eg. Content scrolling).\n\t\t\t\tevent.preventDefault();\n\t\t\t};\n\n\t\t\tnode.addEventListener('wheel', chartInstance.zoom._wheelHandler);\n\t\t}\n\n\t\tif (Hammer) {\n\t\t\tvar mc = new Hammer.Manager(node);\n\t\t\tmc.add(new Hammer.Pinch());\n\t\t\tmc.add(new Hammer.Pan({\n\t\t\t\tthreshold: panThreshold\n\t\t\t}));\n\n\t\t\t// Hammer reports the total scaling. We need the incremental amount\n\t\t\tvar currentPinchScaling;\n\t\t\tvar handlePinch = function handlePinch(e) {\n\t\t\t\tvar diff = 1 / (currentPinchScaling) * e.scale;\n\t\t\t\tvar rect = e.target.getBoundingClientRect();\n\t\t\t\tvar offsetX = e.center.x - rect.left;\n\t\t\t\tvar offsetY = e.center.y - rect.top;\n\t\t\t\tvar center = {\n\t\t\t\t\tx : offsetX,\n\t\t\t\t\ty : offsetY\n\t\t\t\t};\n\n\t\t\t\t// fingers position difference\n\t\t\t\tvar x = Math.abs(e.pointers[0].clientX - e.pointers[1].clientX);\n\t\t\t\tvar y = Math.abs(e.pointers[0].clientY - e.pointers[1].clientY);\n\n\t\t\t\t// diagonal fingers will change both (xy) axes\n\t\t\t\tvar p = x / y;\n\t\t\t\tvar xy;\n\t\t\t\tif (p > 0.3 && p < 1.7) {\n\t\t\t\t\txy = 'xy';\n\t\t\t\t}\n\t\t\t\t// x axis\n\t\t\t\telse if (x > y) {\n\t\t\t\t\txy = 'x';\n\t\t\t\t}\n\t\t\t\t// y axis\n\t\t\t\telse {\n\t\t\t\t\txy = 'y';\n\t\t\t\t}\n\n\t\t\t\tdoZoom(chartInstance, diff, center, xy);\n\n\t\t\t\t// Keep track of overall scale\n\t\t\t\tcurrentPinchScaling = e.scale;\n\t\t\t};\n\n\t\t\tmc.on('pinchstart', function(e) {\n\t\t\t\tcurrentPinchScaling = 1; // reset tracker\n\t\t\t});\n\t\t\tmc.on('pinch', handlePinch);\n\t\t\tmc.on('pinchend', function(e) {\n\t\t\t\thandlePinch(e);\n\t\t\t\tcurrentPinchScaling = null; // reset\n\t\t\t\tzoomNS.zoomCumulativeDelta = 0;\n\t\t\t});\n\n\t\t\tvar currentDeltaX = null, currentDeltaY = null, panning = false;\n\t\t\tvar handlePan = function handlePan(e) {\n\t\t\t\tif (currentDeltaX !== null && currentDeltaY !== null) {\n\t\t\t\t\tpanning = true;\n\t\t\t\t\tvar deltaX = e.deltaX - currentDeltaX;\n\t\t\t\t\tvar deltaY = e.deltaY - currentDeltaY;\n\t\t\t\t\tcurrentDeltaX = e.deltaX;\n\t\t\t\t\tcurrentDeltaY = e.deltaY;\n\t\t\t\t\tdoPan(chartInstance, deltaX, deltaY);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tmc.on('panstart', function(e) {\n\t\t\t\tcurrentDeltaX = 0;\n\t\t\t\tcurrentDeltaY = 0;\n\t\t\t\thandlePan(e);\n\t\t\t});\n\t\t\tmc.on('panmove', handlePan);\n\t\t\tmc.on('panend', function(e) {\n\t\t\t\tcurrentDeltaX = null;\n\t\t\t\tcurrentDeltaY = null;\n\t\t\t\tzoomNS.panCumulativeDelta = 0;\n\t\t\t\tsetTimeout(function() { panning = false; }, 500);\n\t\t\t});\n\n\t\t\tchartInstance.zoom._ghostClickHandler = function(e) {\n\t\t\t\tif (panning) {\n\t\t\t\t\te.stopImmediatePropagation();\n\t\t\t\t\te.preventDefault();\n\t\t\t\t}\n\t\t\t};\n\t\t\tnode.addEventListener('click', chartInstance.zoom._ghostClickHandler);\n\n\t\t\tchartInstance._mc = mc;\n\t\t}\n\t},\n\n\tbeforeDatasetsDraw: function(chartInstance) {\n\t\tvar ctx = chartInstance.chart.ctx;\n\t\tvar chartArea = chartInstance.chartArea;\n\t\tctx.save();\n\t\tctx.beginPath();\n\n\t\tif (chartInstance.zoom._dragZoomEnd) {\n\t\t\tvar yAxis = getYAxis(chartInstance);\n\t\t\tvar beginPoint = chartInstance.zoom._dragZoomStart;\n\t\t\tvar endPoint = chartInstance.zoom._dragZoomEnd;\n\t\t\tvar offsetX = beginPoint.target.getBoundingClientRect().left;\n\t\t\tvar startX = Math.min(beginPoint.clientX, endPoint.clientX) - offsetX;\n\t\t\tvar endX = Math.max(beginPoint.clientX, endPoint.clientX) - offsetX;\n\t\t\tvar rectWidth = endX - startX;\n\n\n\t\t\tctx.fillStyle = 'rgba(225,225,225,0.3)';\n\t\t\tctx.lineWidth = 5;\n\t\t\tctx.fillRect(startX, yAxis.top, rectWidth, yAxis.bottom - yAxis.top);\n\t\t}\n\n\t\tctx.rect(chartArea.left, chartArea.top, chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);\n\t\tctx.clip();\n\t},\n\n\tafterDatasetsDraw: function(chartInstance) {\n\t\tchartInstance.chart.ctx.restore();\n\t},\n\n\tdestroy: function(chartInstance) {\n\t\tif (chartInstance.zoom) {\n\t\t\tvar options = chartInstance.options;\n\t\t\tvar node = chartInstance.zoom.node;\n\n\t\t\tif (options.zoom && options.zoom.drag) {\n\t\t\t\tnode.removeEventListener('mousedown', chartInstance.zoom._mouseDownHandler);\n\t\t\t\tnode.removeEventListener('mousemove', chartInstance.zoom._mouseMoveHandler);\n\t\t\t\tnode.removeEventListener('mouseup', chartInstance.zoom._mouseUpHandler);\n\t\t\t} else {\n\t\t\t\tnode.removeEventListener('wheel', chartInstance.zoom._wheelHandler);\n\t\t\t}\n\n\t\t\tif (Hammer) {\n\t\t\t\tnode.removeEventListener('click', chartInstance.zoom._ghostClickHandler);\n\t\t\t}\n\n\t\t\tdelete chartInstance.zoom;\n\n\t\t\tvar mc = chartInstance._mc;\n\t\t\tif (mc) {\n\t\t\t\tmc.remove('pinchstart');\n\t\t\t\tmc.remove('pinch');\n\t\t\t\tmc.remove('pinchend');\n\t\t\t\tmc.remove('panstart');\n\t\t\t\tmc.remove('pan');\n\t\t\t\tmc.remove('panend');\n\t\t\t}\n\t\t}\n\t}\n};\n\nmodule.exports = zoomPlugin;\nChart.pluginService.register(zoomPlugin);\n"],"sourceRoot":""}