{"version":3,"sources":["webpack:///./node_modules/core-js/modules/es.string.split.js","webpack:///./node_modules/chartjs-adapter-moment/dist/chartjs-adapter-moment.esm.js","webpack:///./node_modules/file-saver/dist/FileSaver.min.js","webpack:///./src/components/CamDetails.vue?76cf","webpack:///./node_modules/core-js/internals/object-is-extensible.js","webpack:///./node_modules/core-js/modules/es.set.js","webpack:///./node_modules/core-js/internals/collection-strong.js","webpack:///./node_modules/core-js/internals/collection.js","webpack:///./node_modules/chartjs-plugin-zoom/dist/chartjs-plugin-zoom.esm.js","webpack:///./node_modules/core-js/internals/freezing.js","webpack:///./src/components/CamMaintenance.vue?1817","webpack:///./node_modules/hammerjs/hammer.js","webpack:///./src/components/CamDetailsChart.vue","webpack:///./src/components/CamDetailsChart.vue?86ed","webpack:///./src/components/CamDetails.vue","webpack:///./src/components/CamDetails.vue?706a","webpack:///./src/components/CamMaintenance.vue","webpack:///./src/components/CamMaintenance.vue?e745","webpack:///./src/assets/left_arrow.svg","webpack:///./node_modules/core-js/internals/array-buffer-non-extensible.js","webpack:///./src/assets/right_arrow.svg","webpack:///./node_modules/core-js/internals/internal-metadata.js","webpack:///./src/components/CamDetailsChart.vue?fc0c"],"names":["apply","call","uncurryThis","fixRegExpWellKnownSymbolLogic","isRegExp","anObject","requireObjectCoercible","speciesConstructor","advanceStringIndex","toLength","toString","getMethod","arraySlice","callRegExpExec","regexpExec","stickyHelpers","fails","UNSUPPORTED_Y","MAX_UINT32","min","Math","$push","push","exec","stringSlice","slice","SPLIT_WORKS_WITH_OVERWRITTEN_EXEC","re","originalExec","this","arguments","result","split","length","SPLIT","nativeSplit","maybeCallNative","internalSplit","separator","limit","string","lim","undefined","match","lastIndex","lastLength","output","flags","ignoreCase","multiline","unicode","sticky","lastLastIndex","separatorCopy","RegExp","source","index","O","splitter","rx","S","res","done","value","C","unicodeMatching","p","q","A","e","z","i","FORMATS","datetime","millisecond","second","minute","hour","day","week","month","quarter","year","_date","override","_id","formats","parse","format","isValid","valueOf","time","add","amount","unit","diff","max","startOf","weekday","trunc","isoWeekday","endOf","b","a","autoBom","console","warn","test","type","Blob","c","d","XMLHttpRequest","open","responseType","onload","g","response","onerror","error","send","status","dispatchEvent","MouseEvent","document","createEvent","initMouseEvent","window","f","self","global","navigator","userAgent","saveAs","HTMLAnchorElement","prototype","h","URL","webkitURL","j","createElement","name","download","rel","href","origin","location","target","createObjectURL","setTimeout","revokeObjectURL","msSaveOrOpenBlob","title","body","innerText","HTMLElement","safari","FileReader","k","onloadend","replace","readAsDataURL","l","m","module","exports","isObject","classof","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","Object","isExtensible","FAILS_ON_PRIMITIVES","it","collection","collectionStrong","init","defineProperty","create","redefineAll","bind","anInstance","iterate","defineIterator","setSpecies","DESCRIPTORS","fastKey","InternalStateModule","setInternalState","set","internalStateGetterFor","getterFor","getConstructor","wrapper","CONSTRUCTOR_NAME","IS_MAP","ADDER","Constructor","that","iterable","Prototype","first","last","size","AS_ENTRIES","getInternalState","define","key","previous","state","entry","getEntry","next","removed","clear","data","prev","forEach","callbackfn","boundFunction","has","get","setStrong","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","iterated","kind","$","isForced","redefine","InternalMetadataModule","isCallable","checkCorrectnessOfIteration","setToStringTag","inheritIfRequired","common","indexOf","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","KEY","uncurriedNativeMethod","REPLACE","entries","enable","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","dummy","constructor","forced","getModifierKey","opts","enabled","modifierKey","keyPressed","event","keyNotPressed","directionEnabled","mode","dir","chart","directionsEnabled","x","y","debounce","fn","delay","timeout","clearTimeout","getScaleUnderPoint","scales","scaleIds","keys","scale","top","bottom","left","right","getEnabledScalesByPoint","options","point","scaleMode","overScaleMode","scaleEnabled","overScaleEnabled","axis","enabledScales","scaleItem","chartStates","WeakMap","getState","originalScaleLimits","updatedScaleLimits","handlers","panDelta","removeState","delete","zoomDelta","zoom","center","range","newRange","centerPoint","isHorizontal","minPercent","getValueForPixel","maxPercent","getLimit","scaleLimits","prop","fallback","original","id","getRange","pixel0","pixel1","v0","v1","updateRange","limits","scaleOpts","minRange","minLimit","Infinity","maxLimit","offset","zoomNumericalScale","delta","zoomRectNumericalScale","from","to","integerChange","v","isNaN","round","existCategoryFromMaxZoom","labels","getLabels","maxIndex","zoomCategoryScale","scaleLength","width","height","panCategoryScale","lastLabelIndex","stepDelta","stepSize","abs","applied","OFFSETS","panNumericalScale","canZoom","prevStart","prevEnd","newMin","getPixelForValue","newMax","panNonLinearScale","zoomFunctions","category","default","zoomRectFunctions","panFunctions","logarithmic","timeseries","shouldUpdateScaleLimits","removeMissingScales","opt","storeOriginalScaleLimits","doZoom","doZoomRect","getCenter","ca","chartArea","transition","focalPoint","zoomOptions","xEnabled","yEnabled","update","onZoom","zoomRect","p0","p1","zoomScale","scaleId","resetZoom","scaleOptions","onZoomComplete","getOriginalRange","getZoomLevel","origRange","level","panScale","storedDelta","pan","panOptions","onPan","getInitialScaleBounds","scaleBounds","isZoomedOrPanned","originalMin","originalMax","removeHandler","handler","removeEventListener","addHandler","oldHandler","addEventListener","mouseMove","dragStart","dragging","dragEnd","keyDown","zoomStart","onZoomStart","onZoomRejected","mouseDown","button","drag","canvas","computeDragRect","beginPointEvent","endPointEvent","chartWidth","chartHeight","beginPoint","endPoint","zoomX","zoomY","mouseUp","threshold","rect","distanceX","distanceY","distance","sqrt","wheelPreconditions","wheel","cancelable","preventDefault","deltaY","getBoundingClientRect","speed","clientX","clientY","addDebouncedHandler","addListeners","wheelOptions","dragOptions","ownerDocument","removeListeners","createEnabler","recognizer","srcEvent","panning","pointerType","onPanRejected","pinchAxes","pinchX","pinchY","handlePinch","pointers","zoomPercent","pinch","startPinch","endPinch","handlePan","deltaX","panScales","startPan","onPanStart","panEndTimeout","endPan","onPanComplete","hammers","startHammer","mc","Manager","Pinch","on","Pan","stopHammer","remove","destroy","version","draw","caller","drawTime","ctx","save","beginPath","fillStyle","backgroundColor","fillRect","borderWidth","lineWidth","strokeStyle","borderColor","strokeRect","restore","defaults","start","_args","hasOwnProperty","args","beforeUpdate","stop","preventExtensions","exportName","assign","VENDOR_PREFIXES","TEST_ELEMENT","TYPE_FUNCTION","now","Date","setTimeoutContext","context","bindFn","invokeArrayArg","arg","Array","isArray","each","obj","iterator","deprecate","method","message","deprecationMessage","Error","stack","log","TypeError","nextKey","extend","dest","src","merge","inherit","child","base","properties","childP","baseP","_super","boolOrFn","val","ifUndefined","val1","val2","addEventListeners","types","splitStr","removeEventListeners","hasParent","node","parent","parentNode","inStr","str","find","trim","inArray","findByKey","toArray","uniqueArray","sort","results","values","prefixed","property","prefix","camelProp","toUpperCase","_uniqueId","uniqueId","getWindowForElement","element","doc","defaultView","parentWindow","MOBILE_REGEX","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","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","inputTarget","domHandler","ev","createInputInstance","Type","inputClass","PointerEventInput","TouchInput","TouchMouseInput","MouseInput","inputHandler","eventType","input","pointersLen","changedPointersLen","changedPointers","isFirst","isFinal","session","computeInputData","emit","recognize","prevInput","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","timeStamp","deltaTime","angle","getAngle","getDistance","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","getScale","rotation","getRotation","maxPointers","computeIntervalInputData","offsetDelta","prevDelta","velocity","velocityX","velocityY","direction","lastInterval","p2","props","atan2","PI","end","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","pressed","which","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","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","style","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","cleanTouchActions","actions","hasPanX","hasPanY","touchMap","cssSupports","CSS","supports","compute","touchAction","recognizers","getTouchAction","join","preventDefaults","prevented","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","STATE_FAILED","Recognizer","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","preset","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","reset","process","attrTest","optionPointers","isRecognized","directionTest","hasMoved","inOut","validPointers","validMovement","validTime","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","STOP","FORCED_STOP","oldCssProps","toggleCssProps","item","triggerDomEvent","gestureEvent","initEvent","gesture","force","stopped","curRecognizer","existing","events","off","Tap","Swipe","Rotate","Press","freeGlobal","_hoisted_1","class","_hoisted_2","_hoisted_3","acquisitions","required","weights","batch","weights_v2","model_name","String","showRefCurve","Boolean","showTrendline","setup","__props","isModalOpen","modalData","getAge","first_date","second_date","acquisition_date","getTime","accommodation_date","ceil","mapAcquisition","map","acquisition","date_fetched","toISOString","weight","mapWeight","datetime_fetched","mapWeightsV2","weightsV2","start_datetime","average_weight","JSON","stringify","mapRefCurve","mapV1Trendline","v1_weights","v1_trendline","w","dates","date","mapV2Trendline","v2_weights","v2_trendline","refCurveData","V1Trendline","V2Trendline","chartData","datasets","label","pointRadius","register","responsive","maintainAspectRatio","interaction","intersect","parser","tooltipFormat","displayFormats","onClick","evt","datasetIndex","dataIndex","datasetLabel","inputKeys","additional_info","input_key","fetch","blob","url","plugins","tooltip","callbacks","dataset","afterLabel","raw","date_accomodation","pig_pen","standard_deviation","min_weight","max_weight","total_reading_count","valid_reading_count","movement_index","end_datetime","uniformity","camera_mac","datetime_received","growth","reading_count","beforeFooter","additionalInfo","batch_coverage","movement_coverage","num_pigs","scatterChartProps","_ctx","_cache","alt","$event","__exports__","n","_hoisted_4","_hoisted_5","_hoisted_6","cam","show_ref_curve_status","show_trendline_status","dynamic_model_name","currentBatchIndex","currentBatchData","batches","dynamicModelName","showRefCurveStatus","showTrendlineStatus","newVal","oldVal","reportAnomaly","prevBatch","nextBatch","sensor","pk","CamDetailsChart","batch_acquisitions","batch_weights","batch_weights_v2","_hoisted_7","maintenance_store","showTrendLine","showTrendLineStatus","globalShowRefCurve","loaded","searchQuery","modelNames","selectedModelName","sortedCamsData","getCamsData","filteredCamsData","includes","initializeData","setCamInfo","sortedByDate","highestPkBatchA","reduce","current","highestPkBatchB","lastBatchADate","lastBatchBDate","openBatches","closedBatches","highestPkBatch","modelSet","Set","getFormattedDateTime","getFullYear","getMonth","padStart","getDate","hours","getHours","minutes","getMinutes","seconds","getSeconds","exportData","csvContent","batchInfo","barn","weightV2","filename","placeholder","model","CamDetails","Loading","ArrayBuffer","buffer","hiddenKeys","hasOwn","getOwnPropertyNamesModule","getOwnPropertyNamesExternalModule","uid","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","getWeakData","onFreeze","meta","getOwnPropertyNames","stat"],"mappings":"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","file":"js/chunk-357ddb88.4beaf404.js","sourcesContent":["'use strict';\nvar apply = require('../internals/function-apply');\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');\nvar isRegExp = require('../internals/is-regexp');\nvar anObject = require('../internals/an-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar speciesConstructor = require('../internals/species-constructor');\nvar advanceStringIndex = require('../internals/advance-string-index');\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar getMethod = require('../internals/get-method');\nvar arraySlice = require('../internals/array-slice-simple');\nvar callRegExpExec = require('../internals/regexp-exec-abstract');\nvar regexpExec = require('../internals/regexp-exec');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar fails = require('../internals/fails');\n\nvar UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;\nvar MAX_UINT32 = 0xFFFFFFFF;\nvar min = Math.min;\nvar $push = [].push;\nvar exec = uncurryThis(/./.exec);\nvar push = uncurryThis($push);\nvar stringSlice = uncurryThis(''.slice);\n\n// Chrome 51 has a buggy \"split\" implementation when RegExp#exec !== nativeExec\n// Weex JS has frozen built-in prototypes, so use try / catch wrapper\nvar SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {\n  // eslint-disable-next-line regexp/no-empty-group -- required for testing\n  var re = /(?:)/;\n  var originalExec = re.exec;\n  re.exec = function () { return originalExec.apply(this, arguments); };\n  var result = 'ab'.split(re);\n  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';\n});\n\n// @@split logic\nfixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {\n  var internalSplit;\n  if (\n    'abbc'.split(/(b)*/)[1] == 'c' ||\n    // eslint-disable-next-line regexp/no-empty-group -- required for testing\n    'test'.split(/(?:)/, -1).length != 4 ||\n    'ab'.split(/(?:ab)*/).length != 2 ||\n    '.'.split(/(.?)(.?)/).length != 4 ||\n    // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing\n    '.'.split(/()()/).length > 1 ||\n    ''.split(/.?/).length\n  ) {\n    // based on es5-shim implementation, need to rework it\n    internalSplit = function (separator, limit) {\n      var string = toString(requireObjectCoercible(this));\n      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;\n      if (lim === 0) return [];\n      if (separator === undefined) return [string];\n      // If `separator` is not a regex, use native split\n      if (!isRegExp(separator)) {\n        return call(nativeSplit, string, separator, lim);\n      }\n      var output = [];\n      var flags = (separator.ignoreCase ? 'i' : '') +\n                  (separator.multiline ? 'm' : '') +\n                  (separator.unicode ? 'u' : '') +\n                  (separator.sticky ? 'y' : '');\n      var lastLastIndex = 0;\n      // Make `global` and avoid `lastIndex` issues by working with a copy\n      var separatorCopy = new RegExp(separator.source, flags + 'g');\n      var match, lastIndex, lastLength;\n      while (match = call(regexpExec, separatorCopy, string)) {\n        lastIndex = separatorCopy.lastIndex;\n        if (lastIndex > lastLastIndex) {\n          push(output, stringSlice(string, lastLastIndex, match.index));\n          if (match.length > 1 && match.index < string.length) apply($push, output, arraySlice(match, 1));\n          lastLength = match[0].length;\n          lastLastIndex = lastIndex;\n          if (output.length >= lim) break;\n        }\n        if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop\n      }\n      if (lastLastIndex === string.length) {\n        if (lastLength || !exec(separatorCopy, '')) push(output, '');\n      } else push(output, stringSlice(string, lastLastIndex));\n      return output.length > lim ? arraySlice(output, 0, lim) : output;\n    };\n  // Chakra, V8\n  } else if ('0'.split(undefined, 0).length) {\n    internalSplit = function (separator, limit) {\n      return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit);\n    };\n  } else internalSplit = nativeSplit;\n\n  return [\n    // `String.prototype.split` method\n    // https://tc39.es/ecma262/#sec-string.prototype.split\n    function split(separator, limit) {\n      var O = requireObjectCoercible(this);\n      var splitter = separator == undefined ? undefined : getMethod(separator, SPLIT);\n      return splitter\n        ? call(splitter, separator, O, limit)\n        : call(internalSplit, toString(O), separator, limit);\n    },\n    // `RegExp.prototype[@@split]` method\n    // https://tc39.es/ecma262/#sec-regexp.prototype-@@split\n    //\n    // NOTE: This cannot be properly polyfilled in engines that don't support\n    // the 'y' flag.\n    function (string, limit) {\n      var rx = anObject(this);\n      var S = toString(string);\n      var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);\n\n      if (res.done) return res.value;\n\n      var C = speciesConstructor(rx, RegExp);\n\n      var unicodeMatching = rx.unicode;\n      var flags = (rx.ignoreCase ? 'i' : '') +\n                  (rx.multiline ? 'm' : '') +\n                  (rx.unicode ? 'u' : '') +\n                  (UNSUPPORTED_Y ? 'g' : 'y');\n\n      // ^(? + rx + ) is needed, in combination with some S slicing, to\n      // simulate the 'y' flag.\n      var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);\n      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;\n      if (lim === 0) return [];\n      if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];\n      var p = 0;\n      var q = 0;\n      var A = [];\n      while (q < S.length) {\n        splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;\n        var z = callRegExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);\n        var e;\n        if (\n          z === null ||\n          (e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p\n        ) {\n          q = advanceStringIndex(S, q, unicodeMatching);\n        } else {\n          push(A, stringSlice(S, p, q));\n          if (A.length === lim) return A;\n          for (var i = 1; i <= z.length - 1; i++) {\n            push(A, z[i]);\n            if (A.length === lim) return A;\n          }\n          q = p = e;\n        }\n      }\n      push(A, stringSlice(S, p));\n      return A;\n    }\n  ];\n}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);\n","/*!\n  * chartjs-adapter-moment v1.0.0\n  * https://www.chartjs.org\n  * (c) 2021 chartjs-adapter-moment Contributors\n  * Released under the MIT license\n  */\nimport moment from 'moment';\nimport { _adapters } from 'chart.js';\n\nconst FORMATS = {\n  datetime: 'MMM D, YYYY, h:mm:ss a',\n  millisecond: 'h:mm:ss.SSS a',\n  second: 'h:mm:ss a',\n  minute: 'h:mm a',\n  hour: 'hA',\n  day: 'MMM D',\n  week: 'll',\n  month: 'MMM YYYY',\n  quarter: '[Q]Q - YYYY',\n  year: 'YYYY'\n};\n\n_adapters._date.override(typeof moment === 'function' ? {\n  _id: 'moment', // DEBUG ONLY\n\n  formats: function() {\n    return FORMATS;\n  },\n\n  parse: function(value, format) {\n    if (typeof value === 'string' && typeof format === 'string') {\n      value = moment(value, format);\n    } else if (!(value instanceof moment)) {\n      value = moment(value);\n    }\n    return value.isValid() ? value.valueOf() : null;\n  },\n\n  format: function(time, format) {\n    return moment(time).format(format);\n  },\n\n  add: function(time, amount, unit) {\n    return moment(time).add(amount, unit).valueOf();\n  },\n\n  diff: function(max, min, unit) {\n    return moment(max).diff(moment(min), unit);\n  },\n\n  startOf: function(time, unit, weekday) {\n    time = moment(time);\n    if (unit === 'isoWeek') {\n      weekday = Math.trunc(Math.min(Math.max(0, weekday), 6));\n      return time.isoWeekday(weekday).startOf('day').valueOf();\n    }\n    return time.startOf(unit).valueOf();\n  },\n\n  endOf: function(time, unit) {\n    return moment(time).endOf(unit).valueOf();\n  }\n} : {});\n","(function(a,b){if(\"function\"==typeof define&&define.amd)define([],b);else if(\"undefined\"!=typeof exports)b();else{b(),a.FileSaver={exports:{}}.exports}})(this,function(){\"use strict\";function b(a,b){return\"undefined\"==typeof b?b={autoBom:!1}:\"object\"!=typeof b&&(console.warn(\"Deprecated: Expected third argument to be a object\"),b={autoBom:!b}),b.autoBom&&/^\\s*(?:text\\/\\S*|application\\/xml|\\S*\\/\\S*\\+xml)\\s*;.*charset\\s*=\\s*utf-8/i.test(a.type)?new Blob([\"\\uFEFF\",a],{type:a.type}):a}function c(a,b,c){var d=new XMLHttpRequest;d.open(\"GET\",a),d.responseType=\"blob\",d.onload=function(){g(d.response,b,c)},d.onerror=function(){console.error(\"could not download file\")},d.send()}function d(a){var b=new XMLHttpRequest;b.open(\"HEAD\",a,!1);try{b.send()}catch(a){}return 200<=b.status&&299>=b.status}function e(a){try{a.dispatchEvent(new MouseEvent(\"click\"))}catch(c){var b=document.createEvent(\"MouseEvents\");b.initMouseEvent(\"click\",!0,!0,window,0,0,0,80,20,!1,!1,!1,!1,0,null),a.dispatchEvent(b)}}var f=\"object\"==typeof window&&window.window===window?window:\"object\"==typeof self&&self.self===self?self:\"object\"==typeof global&&global.global===global?global:void 0,a=f.navigator&&/Macintosh/.test(navigator.userAgent)&&/AppleWebKit/.test(navigator.userAgent)&&!/Safari/.test(navigator.userAgent),g=f.saveAs||(\"object\"!=typeof window||window!==f?function(){}:\"download\"in HTMLAnchorElement.prototype&&!a?function(b,g,h){var i=f.URL||f.webkitURL,j=document.createElement(\"a\");g=g||b.name||\"download\",j.download=g,j.rel=\"noopener\",\"string\"==typeof b?(j.href=b,j.origin===location.origin?e(j):d(j.href)?c(b,g,h):e(j,j.target=\"_blank\")):(j.href=i.createObjectURL(b),setTimeout(function(){i.revokeObjectURL(j.href)},4E4),setTimeout(function(){e(j)},0))}:\"msSaveOrOpenBlob\"in navigator?function(f,g,h){if(g=g||f.name||\"download\",\"string\"!=typeof f)navigator.msSaveOrOpenBlob(b(f,h),g);else if(d(f))c(f,g,h);else{var i=document.createElement(\"a\");i.href=f,i.target=\"_blank\",setTimeout(function(){e(i)})}}:function(b,d,e,g){if(g=g||open(\"\",\"_blank\"),g&&(g.document.title=g.document.body.innerText=\"downloading...\"),\"string\"==typeof b)return c(b,d,e);var h=\"application/octet-stream\"===b.type,i=/constructor/i.test(f.HTMLElement)||f.safari,j=/CriOS\\/[\\d]+/.test(navigator.userAgent);if((j||h&&i||a)&&\"undefined\"!=typeof FileReader){var k=new FileReader;k.onloadend=function(){var a=k.result;a=j?a:a.replace(/^data:[^;]*;/,\"data:attachment/file;\"),g?g.location.href=a:location=a,g=null},k.readAsDataURL(b)}else{var l=f.URL||f.webkitURL,m=l.createObjectURL(b);g?g.location=m:location.href=m,g=null,setTimeout(function(){l.revokeObjectURL(m)},4E4)}});f.saveAs=g.saveAs=g,\"undefined\"!=typeof module&&(module.exports=g)});\n\n//# sourceMappingURL=FileSaver.min.js.map","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader-v16/dist/index.js??ref--1-1!./CamDetails.vue?vue&type=style&index=0&id=d0cfe9fc&scoped=true&lang=css\"","var fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n  if (!isObject(it)) return false;\n  if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) == 'ArrayBuffer') return false;\n  return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.es/ecma262/#sec-set-objects\ncollection('Set', function (init) {\n  return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var Constructor = wrapper(function (that, iterable) {\n      anInstance(that, Prototype);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n    });\n\n    var Prototype = Constructor.prototype;\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(Prototype, {\n      // `{ Map, Set }.prototype.clear()` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.clear\n      // https://tc39.es/ecma262/#sec-set.prototype.clear\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // `{ Map, Set }.prototype.delete(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.delete\n      // https://tc39.es/ecma262/#sec-set.prototype.delete\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.foreach\n      // https://tc39.es/ecma262/#sec-set.prototype.foreach\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // `{ Map, Set}.prototype.has(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.has\n      // https://tc39.es/ecma262/#sec-set.prototype.has\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(Prototype, IS_MAP ? {\n      // `Map.prototype.get(key)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.get\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // `Map.prototype.set(key, value)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.set\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // `Set.prototype.add(value)` method\n      // https://tc39.es/ecma262/#sec-set.prototype.add\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(Prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return Constructor;\n  },\n  setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n    // https://tc39.es/ecma262/#sec-map.prototype.entries\n    // https://tc39.es/ecma262/#sec-map.prototype.keys\n    // https://tc39.es/ecma262/#sec-map.prototype.values\n    // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n    // https://tc39.es/ecma262/#sec-set.prototype.entries\n    // https://tc39.es/ecma262/#sec-set.prototype.keys\n    // https://tc39.es/ecma262/#sec-set.prototype.values\n    // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n    defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // `{ Map, Set }.prototype[@@species]` accessors\n    // https://tc39.es/ecma262/#sec-get-map-@@species\n    // https://tc39.es/ecma262/#sec-get-set-@@species\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        uncurriedNativeMethod(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  var REPLACE = isForced(\n    CONSTRUCTOR_NAME,\n    !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n      new NativeConstructor().entries().next();\n    }))\n  );\n\n  if (REPLACE) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.enable();\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new -- required for testing\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, NativePrototype);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","/*!\n* chartjs-plugin-zoom v2.0.1\n* undefined\n * (c) 2016-2023 chartjs-plugin-zoom Contributors\n * Released under the MIT License\n */\nimport Hammer from 'hammerjs';\nimport { each, valueOrDefault, callback, sign, getRelativePosition } from 'chart.js/helpers';\n\nconst getModifierKey = opts => opts && opts.enabled && opts.modifierKey;\nconst keyPressed = (key, event) => key && event[key + 'Key'];\nconst keyNotPressed = (key, event) => key && !event[key + 'Key'];\n\n/**\n * @param {string|function} mode can be 'x', 'y' or 'xy'\n * @param {string} dir can be 'x' or 'y'\n * @param {import('chart.js').Chart} chart instance of the chart in question\n * @returns {boolean}\n */\nfunction directionEnabled(mode, dir, chart) {\n  if (mode === undefined) {\n    return true;\n  } else if (typeof mode === 'string') {\n    return mode.indexOf(dir) !== -1;\n  } else if (typeof mode === 'function') {\n    return mode({chart}).indexOf(dir) !== -1;\n  }\n\n  return false;\n}\n\nfunction directionsEnabled(mode, chart) {\n  if (typeof mode === 'function') {\n    mode = mode({chart});\n  }\n  if (typeof mode === 'string') {\n    return {x: mode.indexOf('x') !== -1, y: mode.indexOf('y') !== -1};\n  }\n\n  return {x: false, y: false};\n}\n\n/**\n * Debounces calling `fn` for `delay` ms\n * @param {function} fn - Function to call. No arguments are passed.\n * @param {number} delay - Delay in ms. 0 = immediate invocation.\n * @returns {function}\n */\nfunction debounce(fn, delay) {\n  let timeout;\n  return function() {\n    clearTimeout(timeout);\n    timeout = setTimeout(fn, delay);\n    return delay;\n  };\n}\n\n/**\n * Checks which axis is under the mouse cursor.\n * @param {{x: number, y: number}} point - the mouse location\n * @param {import('chart.js').Chart} [chart] instance of the chart in question\n * @return {import('chart.js').Scale}\n */\nfunction getScaleUnderPoint({x, y}, chart) {\n  const scales = chart.scales;\n  const scaleIds = Object.keys(scales);\n  for (let i = 0; i < scaleIds.length; i++) {\n    const scale = scales[scaleIds[i]];\n    if (y >= scale.top && y <= scale.bottom && x >= scale.left && x <= scale.right) {\n      return scale;\n    }\n  }\n  return null;\n}\n\n/**\n * Evaluate the chart's mode, scaleMode, and overScaleMode properties to\n * determine which axes are eligible for scaling.\n * options.overScaleMode can be a function if user want zoom only one scale of many for example.\n * @param options - Zoom or pan options\n * @param {{x: number, y: number}} point - the mouse location\n * @param {import('chart.js').Chart} [chart] instance of the chart in question\n * @return {import('chart.js').Scale[]}\n */\nfunction getEnabledScalesByPoint(options, point, chart) {\n  const {mode = 'xy', scaleMode, overScaleMode} = options || {};\n  const scale = getScaleUnderPoint(point, chart);\n\n  const enabled = directionsEnabled(mode, chart);\n  const scaleEnabled = directionsEnabled(scaleMode, chart);\n\n  // Convert deprecated overScaleEnabled to new scaleEnabled.\n  if (overScaleMode) {\n    const overScaleEnabled = directionsEnabled(overScaleMode, chart);\n    for (const axis of ['x', 'y']) {\n      if (overScaleEnabled[axis]) {\n        scaleEnabled[axis] = enabled[axis];\n        enabled[axis] = false;\n      }\n    }\n  }\n\n  if (scale && scaleEnabled[scale.axis]) {\n    return [scale];\n  }\n\n  const enabledScales = [];\n  each(chart.scales, function(scaleItem) {\n    if (enabled[scaleItem.axis]) {\n      enabledScales.push(scaleItem);\n    }\n  });\n  return enabledScales;\n}\n\nconst chartStates = new WeakMap();\n\nfunction getState(chart) {\n  let state = chartStates.get(chart);\n  if (!state) {\n    state = {\n      originalScaleLimits: {},\n      updatedScaleLimits: {},\n      handlers: {},\n      panDelta: {}\n    };\n    chartStates.set(chart, state);\n  }\n  return state;\n}\n\nfunction removeState(chart) {\n  chartStates.delete(chart);\n}\n\nfunction zoomDelta(scale, zoom, center) {\n  const range = scale.max - scale.min;\n  const newRange = range * (zoom - 1);\n\n  const centerPoint = scale.isHorizontal() ? center.x : center.y;\n  // `scale.getValueForPixel()` can return a value less than the `scale.min` or\n  // greater than `scale.max` when `centerPoint` is outside chartArea.\n  const minPercent = Math.max(0, Math.min(1,\n    (scale.getValueForPixel(centerPoint) - scale.min) / range || 0\n  ));\n\n  const maxPercent = 1 - minPercent;\n\n  return {\n    min: newRange * minPercent,\n    max: newRange * maxPercent\n  };\n}\n\nfunction getLimit(state, scale, scaleLimits, prop, fallback) {\n  let limit = scaleLimits[prop];\n  if (limit === 'original') {\n    const original = state.originalScaleLimits[scale.id][prop];\n    limit = valueOrDefault(original.options, original.scale);\n  }\n  return valueOrDefault(limit, fallback);\n}\n\nfunction getRange(scale, pixel0, pixel1) {\n  const v0 = scale.getValueForPixel(pixel0);\n  const v1 = scale.getValueForPixel(pixel1);\n  return {\n    min: Math.min(v0, v1),\n    max: Math.max(v0, v1)\n  };\n}\n\nfunction updateRange(scale, {min, max}, limits, zoom = false) {\n  const state = getState(scale.chart);\n  const {id, axis, options: scaleOpts} = scale;\n\n  const scaleLimits = limits && (limits[id] || limits[axis]) || {};\n  const {minRange = 0} = scaleLimits;\n  const minLimit = getLimit(state, scale, scaleLimits, 'min', -Infinity);\n  const maxLimit = getLimit(state, scale, scaleLimits, 'max', Infinity);\n\n  const range = zoom ? Math.max(max - min, minRange) : scale.max - scale.min;\n  const offset = (range - max + min) / 2;\n  min -= offset;\n  max += offset;\n\n  if (min < minLimit) {\n    min = minLimit;\n    max = Math.min(minLimit + range, maxLimit);\n  } else if (max > maxLimit) {\n    max = maxLimit;\n    min = Math.max(maxLimit - range, minLimit);\n  }\n  scaleOpts.min = min;\n  scaleOpts.max = max;\n\n  state.updatedScaleLimits[scale.id] = {min, max};\n\n  // return true if the scale range is changed\n  return scale.parse(min) !== scale.min || scale.parse(max) !== scale.max;\n}\n\nfunction zoomNumericalScale(scale, zoom, center, limits) {\n  const delta = zoomDelta(scale, zoom, center);\n  const newRange = {min: scale.min + delta.min, max: scale.max - delta.max};\n  return updateRange(scale, newRange, limits, true);\n}\n\nfunction zoomRectNumericalScale(scale, from, to, limits) {\n  updateRange(scale, getRange(scale, from, to), limits, true);\n}\n\nconst integerChange = (v) => v === 0 || isNaN(v) ? 0 : v < 0 ? Math.min(Math.round(v), -1) : Math.max(Math.round(v), 1);\n\nfunction existCategoryFromMaxZoom(scale) {\n  const labels = scale.getLabels();\n  const maxIndex = labels.length - 1;\n\n  if (scale.min > 0) {\n    scale.min -= 1;\n  }\n  if (scale.max < maxIndex) {\n    scale.max += 1;\n  }\n}\n\nfunction zoomCategoryScale(scale, zoom, center, limits) {\n  const delta = zoomDelta(scale, zoom, center);\n  if (scale.min === scale.max && zoom < 1) {\n    existCategoryFromMaxZoom(scale);\n  }\n  const newRange = {min: scale.min + integerChange(delta.min), max: scale.max - integerChange(delta.max)};\n  return updateRange(scale, newRange, limits, true);\n}\n\nfunction scaleLength(scale) {\n  return scale.isHorizontal() ? scale.width : scale.height;\n}\n\nfunction panCategoryScale(scale, delta, limits) {\n  const labels = scale.getLabels();\n  const lastLabelIndex = labels.length - 1;\n  let {min, max} = scale;\n  // The visible range. Ticks can be skipped, and thus not reliable.\n  const range = Math.max(max - min, 1);\n  // How many pixels of delta is required before making a step. stepSize, but limited to max 1/10 of the scale length.\n  const stepDelta = Math.round(scaleLength(scale) / Math.max(range, 10));\n  const stepSize = Math.round(Math.abs(delta / stepDelta));\n  let applied;\n  if (delta < -stepDelta) {\n    max = Math.min(max + stepSize, lastLabelIndex);\n    min = range === 1 ? max : max - range;\n    applied = max === lastLabelIndex;\n  } else if (delta > stepDelta) {\n    min = Math.max(0, min - stepSize);\n    max = range === 1 ? min : min + range;\n    applied = min === 0;\n  }\n\n  return updateRange(scale, {min, max}, limits) || applied;\n}\n\nconst OFFSETS = {\n  second: 500, // 500 ms\n  minute: 30 * 1000, // 30 s\n  hour: 30 * 60 * 1000, // 30 m\n  day: 12 * 60 * 60 * 1000, // 12 h\n  week: 3.5 * 24 * 60 * 60 * 1000, // 3.5 d\n  month: 15 * 24 * 60 * 60 * 1000, // 15 d\n  quarter: 60 * 24 * 60 * 60 * 1000, // 60 d\n  year: 182 * 24 * 60 * 60 * 1000 // 182 d\n};\n\nfunction panNumericalScale(scale, delta, limits, canZoom = false) {\n  const {min: prevStart, max: prevEnd, options} = scale;\n  const round = options.time && options.time.round;\n  const offset = OFFSETS[round] || 0;\n  const newMin = scale.getValueForPixel(scale.getPixelForValue(prevStart + offset) - delta);\n  const newMax = scale.getValueForPixel(scale.getPixelForValue(prevEnd + offset) - delta);\n  const {min: minLimit = -Infinity, max: maxLimit = Infinity} = canZoom && limits && limits[scale.axis] || {};\n  if (isNaN(newMin) || isNaN(newMax) || newMin < minLimit || newMax > maxLimit) {\n    // At limit: No change but return true to indicate no need to store the delta.\n    // NaN can happen for 0-dimension scales (either because they were configured\n    // with min === max or because the chart has 0 plottable area).\n    return true;\n  }\n  return updateRange(scale, {min: newMin, max: newMax}, limits, canZoom);\n}\n\nfunction panNonLinearScale(scale, delta, limits) {\n  return panNumericalScale(scale, delta, limits, true);\n}\n\nconst zoomFunctions = {\n  category: zoomCategoryScale,\n  default: zoomNumericalScale,\n};\n\nconst zoomRectFunctions = {\n  default: zoomRectNumericalScale,\n};\n\nconst panFunctions = {\n  category: panCategoryScale,\n  default: panNumericalScale,\n  logarithmic: panNonLinearScale,\n  timeseries: panNonLinearScale,\n};\n\nfunction shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits) {\n  const {id, options: {min, max}} = scale;\n  if (!originalScaleLimits[id] || !updatedScaleLimits[id]) {\n    return true;\n  }\n  const previous = updatedScaleLimits[id];\n  return previous.min !== min || previous.max !== max;\n}\n\nfunction removeMissingScales(limits, scales) {\n  each(limits, (opt, key) => {\n    if (!scales[key]) {\n      delete limits[key];\n    }\n  });\n}\n\nfunction storeOriginalScaleLimits(chart, state) {\n  const {scales} = chart;\n  const {originalScaleLimits, updatedScaleLimits} = state;\n\n  each(scales, function(scale) {\n    if (shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits)) {\n      originalScaleLimits[scale.id] = {\n        min: {scale: scale.min, options: scale.options.min},\n        max: {scale: scale.max, options: scale.options.max},\n      };\n    }\n  });\n\n  removeMissingScales(originalScaleLimits, scales);\n  removeMissingScales(updatedScaleLimits, scales);\n  return originalScaleLimits;\n}\n\nfunction doZoom(scale, amount, center, limits) {\n  const fn = zoomFunctions[scale.type] || zoomFunctions.default;\n  callback(fn, [scale, amount, center, limits]);\n}\n\nfunction doZoomRect(scale, amount, from, to, limits) {\n  const fn = zoomRectFunctions[scale.type] || zoomRectFunctions.default;\n  callback(fn, [scale, amount, from, to, limits]);\n}\n\nfunction getCenter(chart) {\n  const ca = chart.chartArea;\n  return {\n    x: (ca.left + ca.right) / 2,\n    y: (ca.top + ca.bottom) / 2,\n  };\n}\n\n/**\n * @param chart The chart instance\n * @param {number | {x?: number, y?: number, focalPoint?: {x: number, y: number}}} amount The zoom percentage or percentages and focal point\n * @param {string} [transition] Which transition mode to use. Defaults to 'none'\n */\nfunction zoom(chart, amount, transition = 'none') {\n  const {x = 1, y = 1, focalPoint = getCenter(chart)} = typeof amount === 'number' ? {x: amount, y: amount} : amount;\n  const state = getState(chart);\n  const {options: {limits, zoom: zoomOptions}} = state;\n\n  storeOriginalScaleLimits(chart, state);\n\n  const xEnabled = x !== 1;\n  const yEnabled = y !== 1;\n  const enabledScales = getEnabledScalesByPoint(zoomOptions, focalPoint, chart);\n\n  each(enabledScales || chart.scales, function(scale) {\n    if (scale.isHorizontal() && xEnabled) {\n      doZoom(scale, x, focalPoint, limits);\n    } else if (!scale.isHorizontal() && yEnabled) {\n      doZoom(scale, y, focalPoint, limits);\n    }\n  });\n\n  chart.update(transition);\n\n  callback(zoomOptions.onZoom, [{chart}]);\n}\n\nfunction zoomRect(chart, p0, p1, transition = 'none') {\n  const state = getState(chart);\n  const {options: {limits, zoom: zoomOptions}} = state;\n  const {mode = 'xy'} = zoomOptions;\n\n  storeOriginalScaleLimits(chart, state);\n  const xEnabled = directionEnabled(mode, 'x', chart);\n  const yEnabled = directionEnabled(mode, 'y', chart);\n\n  each(chart.scales, function(scale) {\n    if (scale.isHorizontal() && xEnabled) {\n      doZoomRect(scale, p0.x, p1.x, limits);\n    } else if (!scale.isHorizontal() && yEnabled) {\n      doZoomRect(scale, p0.y, p1.y, limits);\n    }\n  });\n\n  chart.update(transition);\n\n  callback(zoomOptions.onZoom, [{chart}]);\n}\n\nfunction zoomScale(chart, scaleId, range, transition = 'none') {\n  storeOriginalScaleLimits(chart, getState(chart));\n  const scale = chart.scales[scaleId];\n  updateRange(scale, range, undefined, true);\n  chart.update(transition);\n}\n\nfunction resetZoom(chart, transition = 'default') {\n  const state = getState(chart);\n  const originalScaleLimits = storeOriginalScaleLimits(chart, state);\n\n  each(chart.scales, function(scale) {\n    const scaleOptions = scale.options;\n    if (originalScaleLimits[scale.id]) {\n      scaleOptions.min = originalScaleLimits[scale.id].min.options;\n      scaleOptions.max = originalScaleLimits[scale.id].max.options;\n    } else {\n      delete scaleOptions.min;\n      delete scaleOptions.max;\n    }\n  });\n  chart.update(transition);\n  callback(state.options.zoom.onZoomComplete, [{chart}]);\n}\n\nfunction getOriginalRange(state, scaleId) {\n  const original = state.originalScaleLimits[scaleId];\n  if (!original) {\n    return;\n  }\n  const {min, max} = original;\n  return valueOrDefault(max.options, max.scale) - valueOrDefault(min.options, min.scale);\n}\n\nfunction getZoomLevel(chart) {\n  const state = getState(chart);\n  let min = 1;\n  let max = 1;\n  each(chart.scales, function(scale) {\n    const origRange = getOriginalRange(state, scale.id);\n    if (origRange) {\n      const level = Math.round(origRange / (scale.max - scale.min) * 100) / 100;\n      min = Math.min(min, level);\n      max = Math.max(max, level);\n    }\n  });\n  return min < 1 ? min : max;\n}\n\nfunction panScale(scale, delta, limits, state) {\n  const {panDelta} = state;\n  // Add possible cumulative delta from previous pan attempts where scale did not change\n  const storedDelta = panDelta[scale.id] || 0;\n  if (sign(storedDelta) === sign(delta)) {\n    delta += storedDelta;\n  }\n  const fn = panFunctions[scale.type] || panFunctions.default;\n  if (callback(fn, [scale, delta, limits])) {\n    // The scale changed, reset cumulative delta\n    panDelta[scale.id] = 0;\n  } else {\n    // The scale did not change, store cumulative delta\n    panDelta[scale.id] = delta;\n  }\n}\n\nfunction pan(chart, delta, enabledScales, transition = 'none') {\n  const {x = 0, y = 0} = typeof delta === 'number' ? {x: delta, y: delta} : delta;\n  const state = getState(chart);\n  const {options: {pan: panOptions, limits}} = state;\n  const {onPan} = panOptions || {};\n\n  storeOriginalScaleLimits(chart, state);\n\n  const xEnabled = x !== 0;\n  const yEnabled = y !== 0;\n\n  each(enabledScales || chart.scales, function(scale) {\n    if (scale.isHorizontal() && xEnabled) {\n      panScale(scale, x, limits, state);\n    } else if (!scale.isHorizontal() && yEnabled) {\n      panScale(scale, y, limits, state);\n    }\n  });\n\n  chart.update(transition);\n\n  callback(onPan, [{chart}]);\n}\n\nfunction getInitialScaleBounds(chart) {\n  const state = getState(chart);\n  storeOriginalScaleLimits(chart, state);\n  const scaleBounds = {};\n  for (const scaleId of Object.keys(chart.scales)) {\n    const {min, max} = state.originalScaleLimits[scaleId] || {min: {}, max: {}};\n    scaleBounds[scaleId] = {min: min.scale, max: max.scale};\n  }\n\n  return scaleBounds;\n}\n\nfunction isZoomedOrPanned(chart) {\n  const scaleBounds = getInitialScaleBounds(chart);\n  for (const scaleId of Object.keys(chart.scales)) {\n    const {min: originalMin, max: originalMax} = scaleBounds[scaleId];\n\n    if (originalMin !== undefined && chart.scales[scaleId].min !== originalMin) {\n      return true;\n    }\n\n    if (originalMax !== undefined && chart.scales[scaleId].max !== originalMax) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction removeHandler(chart, type) {\n  const {handlers} = getState(chart);\n  const handler = handlers[type];\n  if (handler && handler.target) {\n    handler.target.removeEventListener(type, handler);\n    delete handlers[type];\n  }\n}\n\nfunction addHandler(chart, target, type, handler) {\n  const {handlers, options} = getState(chart);\n  const oldHandler = handlers[type];\n  if (oldHandler && oldHandler.target === target) {\n    // already attached\n    return;\n  }\n  removeHandler(chart, type);\n  handlers[type] = (event) => handler(chart, event, options);\n  handlers[type].target = target;\n  target.addEventListener(type, handlers[type]);\n}\n\nfunction mouseMove(chart, event) {\n  const state = getState(chart);\n  if (state.dragStart) {\n    state.dragging = true;\n    state.dragEnd = event;\n    chart.update('none');\n  }\n}\n\nfunction keyDown(chart, event) {\n  const state = getState(chart);\n  if (!state.dragStart || event.key !== 'Escape') {\n    return;\n  }\n\n  removeHandler(chart, 'keydown');\n  state.dragging = false;\n  state.dragStart = state.dragEnd = null;\n  chart.update('none');\n}\n\nfunction zoomStart(chart, event, zoomOptions) {\n  const {onZoomStart, onZoomRejected} = zoomOptions;\n  if (onZoomStart) {\n    const point = getRelativePosition(event, chart);\n    if (callback(onZoomStart, [{chart, event, point}]) === false) {\n      callback(onZoomRejected, [{chart, event}]);\n      return false;\n    }\n  }\n}\n\nfunction mouseDown(chart, event) {\n  const state = getState(chart);\n  const {pan: panOptions, zoom: zoomOptions = {}} = state.options;\n  if (\n    event.button !== 0 ||\n    keyPressed(getModifierKey(panOptions), event) ||\n    keyNotPressed(getModifierKey(zoomOptions.drag), event)\n  ) {\n    return callback(zoomOptions.onZoomRejected, [{chart, event}]);\n  }\n\n  if (zoomStart(chart, event, zoomOptions) === false) {\n    return;\n  }\n  state.dragStart = event;\n\n  addHandler(chart, chart.canvas, 'mousemove', mouseMove);\n  addHandler(chart, window.document, 'keydown', keyDown);\n}\n\nfunction computeDragRect(chart, mode, beginPointEvent, endPointEvent) {\n  const xEnabled = directionEnabled(mode, 'x', chart);\n  const yEnabled = directionEnabled(mode, 'y', chart);\n  let {top, left, right, bottom, width: chartWidth, height: chartHeight} = chart.chartArea;\n\n  const beginPoint = getRelativePosition(beginPointEvent, chart);\n  const endPoint = getRelativePosition(endPointEvent, chart);\n\n  if (xEnabled) {\n    left = Math.min(beginPoint.x, endPoint.x);\n    right = Math.max(beginPoint.x, endPoint.x);\n  }\n\n  if (yEnabled) {\n    top = Math.min(beginPoint.y, endPoint.y);\n    bottom = Math.max(beginPoint.y, endPoint.y);\n  }\n  const width = right - left;\n  const height = bottom - top;\n\n  return {\n    left,\n    top,\n    right,\n    bottom,\n    width,\n    height,\n    zoomX: xEnabled && width ? 1 + ((chartWidth - width) / chartWidth) : 1,\n    zoomY: yEnabled && height ? 1 + ((chartHeight - height) / chartHeight) : 1\n  };\n}\n\nfunction mouseUp(chart, event) {\n  const state = getState(chart);\n  if (!state.dragStart) {\n    return;\n  }\n\n  removeHandler(chart, 'mousemove');\n  const {mode, onZoomComplete, drag: {threshold = 0}} = state.options.zoom;\n  const rect = computeDragRect(chart, mode, state.dragStart, event);\n  const distanceX = directionEnabled(mode, 'x', chart) ? rect.width : 0;\n  const distanceY = directionEnabled(mode, 'y', chart) ? rect.height : 0;\n  const distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY);\n\n  // Remove drag start and end before chart update to stop drawing selected area\n  state.dragStart = state.dragEnd = null;\n\n  if (distance <= threshold) {\n    state.dragging = false;\n    chart.update('none');\n    return;\n  }\n\n  zoomRect(chart, {x: rect.left, y: rect.top}, {x: rect.right, y: rect.bottom}, 'zoom');\n\n  setTimeout(() => (state.dragging = false), 500);\n  callback(onZoomComplete, [{chart}]);\n}\n\nfunction wheelPreconditions(chart, event, zoomOptions) {\n  // Before preventDefault, check if the modifier key required and pressed\n  if (keyNotPressed(getModifierKey(zoomOptions.wheel), event)) {\n    callback(zoomOptions.onZoomRejected, [{chart, event}]);\n    return;\n  }\n\n  if (zoomStart(chart, event, zoomOptions) === false) {\n    return;\n  }\n\n  // Prevent the event from triggering the default behavior (e.g. content scrolling).\n  if (event.cancelable) {\n    event.preventDefault();\n  }\n\n  // Firefox always fires the wheel event twice:\n  // First without the delta and right after that once with the delta properties.\n  if (event.deltaY === undefined) {\n    return;\n  }\n  return true;\n}\n\nfunction wheel(chart, event) {\n  const {handlers: {onZoomComplete}, options: {zoom: zoomOptions}} = getState(chart);\n\n  if (!wheelPreconditions(chart, event, zoomOptions)) {\n    return;\n  }\n\n  const rect = event.target.getBoundingClientRect();\n  const speed = 1 + (event.deltaY >= 0 ? -zoomOptions.wheel.speed : zoomOptions.wheel.speed);\n  const amount = {\n    x: speed,\n    y: speed,\n    focalPoint: {\n      x: event.clientX - rect.left,\n      y: event.clientY - rect.top\n    }\n  };\n\n  zoom(chart, amount);\n\n  if (onZoomComplete) {\n    onZoomComplete();\n  }\n}\n\nfunction addDebouncedHandler(chart, name, handler, delay) {\n  if (handler) {\n    getState(chart).handlers[name] = debounce(() => callback(handler, [{chart}]), delay);\n  }\n}\n\nfunction addListeners(chart, options) {\n  const canvas = chart.canvas;\n  const {wheel: wheelOptions, drag: dragOptions, onZoomComplete} = options.zoom;\n\n  // Install listeners. Do this dynamically based on options so that we can turn zoom on and off\n  // We also want to make sure listeners aren't always on. E.g. if you're scrolling down a page\n  // and the mouse goes over a chart you don't want it intercepted unless the plugin is enabled\n  if (wheelOptions.enabled) {\n    addHandler(chart, canvas, 'wheel', wheel);\n    addDebouncedHandler(chart, 'onZoomComplete', onZoomComplete, 250);\n  } else {\n    removeHandler(chart, 'wheel');\n  }\n  if (dragOptions.enabled) {\n    addHandler(chart, canvas, 'mousedown', mouseDown);\n    addHandler(chart, canvas.ownerDocument, 'mouseup', mouseUp);\n  } else {\n    removeHandler(chart, 'mousedown');\n    removeHandler(chart, 'mousemove');\n    removeHandler(chart, 'mouseup');\n    removeHandler(chart, 'keydown');\n  }\n}\n\nfunction removeListeners(chart) {\n  removeHandler(chart, 'mousedown');\n  removeHandler(chart, 'mousemove');\n  removeHandler(chart, 'mouseup');\n  removeHandler(chart, 'wheel');\n  removeHandler(chart, 'click');\n  removeHandler(chart, 'keydown');\n}\n\nfunction createEnabler(chart, state) {\n  return function(recognizer, event) {\n    const {pan: panOptions, zoom: zoomOptions = {}} = state.options;\n    if (!panOptions || !panOptions.enabled) {\n      return false;\n    }\n    const srcEvent = event && event.srcEvent;\n    if (!srcEvent) { // Sometimes Hammer queries this with a null event.\n      return true;\n    }\n    if (!state.panning && event.pointerType === 'mouse' && (\n      keyNotPressed(getModifierKey(panOptions), srcEvent) || keyPressed(getModifierKey(zoomOptions.drag), srcEvent))\n    ) {\n      callback(panOptions.onPanRejected, [{chart, event}]);\n      return false;\n    }\n    return true;\n  };\n}\n\nfunction pinchAxes(p0, p1) {\n  // fingers position difference\n  const pinchX = Math.abs(p0.clientX - p1.clientX);\n  const pinchY = Math.abs(p0.clientY - p1.clientY);\n\n  // diagonal fingers will change both (xy) axes\n  const p = pinchX / pinchY;\n  let x, y;\n  if (p > 0.3 && p < 1.7) {\n    x = y = true;\n  } else if (pinchX > pinchY) {\n    x = true;\n  } else {\n    y = true;\n  }\n  return {x, y};\n}\n\nfunction handlePinch(chart, state, e) {\n  if (state.scale) {\n    const {center, pointers} = e;\n    // Hammer reports the total scaling. We need the incremental amount\n    const zoomPercent = 1 / state.scale * e.scale;\n    const rect = e.target.getBoundingClientRect();\n    const pinch = pinchAxes(pointers[0], pointers[1]);\n    const mode = state.options.zoom.mode;\n    const amount = {\n      x: pinch.x && directionEnabled(mode, 'x', chart) ? zoomPercent : 1,\n      y: pinch.y && directionEnabled(mode, 'y', chart) ? zoomPercent : 1,\n      focalPoint: {\n        x: center.x - rect.left,\n        y: center.y - rect.top\n      }\n    };\n\n    zoom(chart, amount);\n\n    // Keep track of overall scale\n    state.scale = e.scale;\n  }\n}\n\nfunction startPinch(chart, state) {\n  if (state.options.zoom.pinch.enabled) {\n    state.scale = 1;\n  }\n}\n\nfunction endPinch(chart, state, e) {\n  if (state.scale) {\n    handlePinch(chart, state, e);\n    state.scale = null; // reset\n    callback(state.options.zoom.onZoomComplete, [{chart}]);\n  }\n}\n\nfunction handlePan(chart, state, e) {\n  const delta = state.delta;\n  if (delta) {\n    state.panning = true;\n    pan(chart, {x: e.deltaX - delta.x, y: e.deltaY - delta.y}, state.panScales);\n    state.delta = {x: e.deltaX, y: e.deltaY};\n  }\n}\n\nfunction startPan(chart, state, event) {\n  const {enabled, onPanStart, onPanRejected} = state.options.pan;\n  if (!enabled) {\n    return;\n  }\n  const rect = event.target.getBoundingClientRect();\n  const point = {\n    x: event.center.x - rect.left,\n    y: event.center.y - rect.top\n  };\n\n  if (callback(onPanStart, [{chart, event, point}]) === false) {\n    return callback(onPanRejected, [{chart, event}]);\n  }\n\n  state.panScales = getEnabledScalesByPoint(state.options.pan, point, chart);\n  state.delta = {x: 0, y: 0};\n  clearTimeout(state.panEndTimeout);\n  handlePan(chart, state, event);\n}\n\nfunction endPan(chart, state) {\n  state.delta = null;\n  if (state.panning) {\n    state.panEndTimeout = setTimeout(() => (state.panning = false), 500);\n    callback(state.options.pan.onPanComplete, [{chart}]);\n  }\n}\n\nconst hammers = new WeakMap();\nfunction startHammer(chart, options) {\n  const state = getState(chart);\n  const canvas = chart.canvas;\n  const {pan: panOptions, zoom: zoomOptions} = options;\n\n  const mc = new Hammer.Manager(canvas);\n  if (zoomOptions && zoomOptions.pinch.enabled) {\n    mc.add(new Hammer.Pinch());\n    mc.on('pinchstart', () => startPinch(chart, state));\n    mc.on('pinch', (e) => handlePinch(chart, state, e));\n    mc.on('pinchend', (e) => endPinch(chart, state, e));\n  }\n\n  if (panOptions && panOptions.enabled) {\n    mc.add(new Hammer.Pan({\n      threshold: panOptions.threshold,\n      enable: createEnabler(chart, state)\n    }));\n    mc.on('panstart', (e) => startPan(chart, state, e));\n    mc.on('panmove', (e) => handlePan(chart, state, e));\n    mc.on('panend', () => endPan(chart, state));\n  }\n\n  hammers.set(chart, mc);\n}\n\nfunction stopHammer(chart) {\n  const mc = hammers.get(chart);\n  if (mc) {\n    mc.remove('pinchstart');\n    mc.remove('pinch');\n    mc.remove('pinchend');\n    mc.remove('panstart');\n    mc.remove('pan');\n    mc.remove('panend');\n    mc.destroy();\n    hammers.delete(chart);\n  }\n}\n\nvar version = \"2.0.1\";\n\nfunction draw(chart, caller, options) {\n  const dragOptions = options.zoom.drag;\n  const {dragStart, dragEnd} = getState(chart);\n\n  if (dragOptions.drawTime !== caller || !dragEnd) {\n    return;\n  }\n  const {left, top, width, height} = computeDragRect(chart, options.zoom.mode, dragStart, dragEnd);\n  const ctx = chart.ctx;\n\n  ctx.save();\n  ctx.beginPath();\n  ctx.fillStyle = dragOptions.backgroundColor || 'rgba(225,225,225,0.3)';\n  ctx.fillRect(left, top, width, height);\n\n  if (dragOptions.borderWidth > 0) {\n    ctx.lineWidth = dragOptions.borderWidth;\n    ctx.strokeStyle = dragOptions.borderColor || 'rgba(225,225,225)';\n    ctx.strokeRect(left, top, width, height);\n  }\n  ctx.restore();\n}\n\nvar plugin = {\n  id: 'zoom',\n\n  version,\n\n  defaults: {\n    pan: {\n      enabled: false,\n      mode: 'xy',\n      threshold: 10,\n      modifierKey: null,\n    },\n    zoom: {\n      wheel: {\n        enabled: false,\n        speed: 0.1,\n        modifierKey: null\n      },\n      drag: {\n        enabled: false,\n        drawTime: 'beforeDatasetsDraw',\n        modifierKey: null\n      },\n      pinch: {\n        enabled: false\n      },\n      mode: 'xy',\n    }\n  },\n\n  start: function(chart, _args, options) {\n    const state = getState(chart);\n    state.options = options;\n\n    if (Object.prototype.hasOwnProperty.call(options.zoom, 'enabled')) {\n      console.warn('The option `zoom.enabled` is no longer supported. Please use `zoom.wheel.enabled`, `zoom.drag.enabled`, or `zoom.pinch.enabled`.');\n    }\n    if (Object.prototype.hasOwnProperty.call(options.zoom, 'overScaleMode')\n      || Object.prototype.hasOwnProperty.call(options.pan, 'overScaleMode')) {\n      console.warn('The option `overScaleMode` is deprecated. Please use `scaleMode` instead (and update `mode` as desired).');\n    }\n\n    if (Hammer) {\n      startHammer(chart, options);\n    }\n\n    chart.pan = (delta, panScales, transition) => pan(chart, delta, panScales, transition);\n    chart.zoom = (args, transition) => zoom(chart, args, transition);\n    chart.zoomRect = (p0, p1, transition) => zoomRect(chart, p0, p1, transition);\n    chart.zoomScale = (id, range, transition) => zoomScale(chart, id, range, transition);\n    chart.resetZoom = (transition) => resetZoom(chart, transition);\n    chart.getZoomLevel = () => getZoomLevel(chart);\n    chart.getInitialScaleBounds = () => getInitialScaleBounds(chart);\n    chart.isZoomedOrPanned = () => isZoomedOrPanned(chart);\n  },\n\n  beforeEvent(chart) {\n    const state = getState(chart);\n    if (state.panning || state.dragging) {\n      // cancel any event handling while panning or dragging\n      return false;\n    }\n  },\n\n  beforeUpdate: function(chart, args, options) {\n    const state = getState(chart);\n    state.options = options;\n    addListeners(chart, options);\n  },\n\n  beforeDatasetsDraw(chart, _args, options) {\n    draw(chart, 'beforeDatasetsDraw', options);\n  },\n\n  afterDatasetsDraw(chart, _args, options) {\n    draw(chart, 'afterDatasetsDraw', options);\n  },\n\n  beforeDraw(chart, _args, options) {\n    draw(chart, 'beforeDraw', options);\n  },\n\n  afterDraw(chart, _args, options) {\n    draw(chart, 'afterDraw', options);\n  },\n\n  stop: function(chart) {\n    removeListeners(chart);\n\n    if (Hammer) {\n      stopHammer(chart);\n    }\n    removeState(chart);\n  },\n\n  panFunctions,\n  zoomFunctions,\n  zoomRectFunctions,\n};\n\nexport { plugin as default, pan, resetZoom, zoom, zoomRect, zoomScale };\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader-v16/dist/index.js??ref--1-1!./CamMaintenance.vue?vue&type=style&index=0&id=59a987bf&scoped=true&lang=css\"","/*! 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","import { defineComponent as _defineComponent } from 'vue'\nimport { unref as _unref, normalizeProps as _normalizeProps, guardReactiveProps as _guardReactiveProps, createVNode as _createVNode, createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createCommentVNode as _createCommentVNode, Fragment as _Fragment, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from \"vue\"\n\nconst _withScopeId = n => (_pushScopeId(\"data-v-551548aa\"),n=n(),_popScopeId(),n)\nconst _hoisted_1 = {\n  key: 0,\n  class: \"modal\"\n}\nconst _hoisted_2 = [\"src\"]\nconst _hoisted_3 = { class: \"center-button-container\" }\n\nimport { computed, PropType, ComputedRef, ref } from \"vue\";\nimport { Chart, registerables, ChartData, ScatterDataPoint } from \"chart.js\";\nimport { ScatterChart, useScatterChart } from \"vue-chart-3\";\nimport { ChartPointType } from \"@/types/chart_point\";\nimport { CamAcquisitionType } from \"@/types/cam_acquisition\";\nimport { BatchWeightType } from \"@/types/batch_weight\";\nimport { BatchWeightV2Type } from \"@/types/batch_weight_v2\";\nimport { trendlineType } from \"@/types/trendline\"\nimport { BatchType } from \"@/types/batch\";\nimport { MaybeRef } from \"@/types/maybe_ref\";\nimport { generateTrendline } from \"@/utils/helper\";\nimport zoomPlugin from 'chartjs-plugin-zoom';\nimport \"chartjs-adapter-moment\";\n\n// Props\n\nexport default /*#__PURE__*/_defineComponent({\n  props: {\n  acquisitions: {\n    type: Object as PropType<CamAcquisitionType[]>,\n    required: true,\n  },\n  weights: { type: Object as PropType<BatchWeightType[]>, required: true },\n  batch: { type: Object as PropType<BatchType>, required: true },\n  weights_v2: { type: Object as PropType<BatchWeightV2Type[]>, required: true },\n  model_name: { type: String, required: true },\n  showRefCurve: { type: Boolean, default: false },\n  showTrendline: { type: Boolean, default: false },\n  open: { type: Boolean, default: false },\n\n},\n  setup(__props) {\n\nconst props = __props\n\n\n\nconst isModalOpen = ref(false);\nconst modalData = ref<any>(null);  // Replace 'any' with the type of data you will be displaying\n\n// Methods\nconst getAge = ((first_date: any, second_date: any) => {\n  const acquisition_date = new Date(first_date).getTime()\n  const accommodation_date = new Date(second_date).getTime()\n  return Math.ceil((acquisition_date - accommodation_date) / (1000 * 60 * 60 * 24));\n})\nconst mapAcquisition = (\n  acquisitions: CamAcquisitionType[]\n): ChartPointType[] => {\n  return acquisitions.map((acquisition: any) => {\n    acquisition.x = new Date(acquisition.date_fetched).toISOString();\n    acquisition.y = acquisition.weight;\n    \n    return acquisition;\n  });\n};\nconst mapWeight = (weights: BatchWeightType[]): ChartPointType[] => {\n  return weights.map((weight: any) => {\n    weight.x = new Date(weight.datetime_fetched).toISOString();\n    weight.y = weight.weight;\n    \n    return weight;\n  });\n};\nconst mapWeightsV2 = (weightsV2: BatchWeightV2Type[] | null): ChartPointType[] => {\n  if (!weightsV2) {\n    console.warn(\"weightsV2 is empty\");\n    return [];\n  }\n\n  return weightsV2\n    .filter((weight) => weight && weight.model_name === props.model_name)\n    .map((weight: any) => {\n      if (!weight.start_datetime || !weight.average_weight) {\n        console.warn(`Missing properties in weight object: ${JSON.stringify(weight)}`);\n        return null;\n      }\n      weight.x = new Date(weight.start_datetime).toISOString();\n      weight.y = weight.average_weight;\n      return weight;\n    })\n    .filter((item) => item !== null);\n};\n\nconst mapRefCurve = (weightsV2: BatchWeightV2Type[] | null): ChartPointType[] => {\n  if (!weightsV2 || props.showRefCurve) {\n    console.warn(\"weightsV2 is empty\");\n    return [];\n  }\n\n  return weightsV2\n    .filter((weight) => weight && weight.model_name === \"RefCurve\")\n    .map((weight: any) => {\n      if (!weight.start_datetime || !weight.average_weight) {\n        console.warn(`Missing properties in weight object: ${JSON.stringify(weight)}`);\n        return null;\n      }\n      weight.x = new Date(weight.start_datetime).toISOString();\n      weight.y = weight.average_weight;\n      return weight;\n    })\n    .filter((item) => item !== null);\n};\n\nconst mapV1Trendline = (v1_weights: BatchWeightType[]): ChartPointType[] => {\n  if (!props.showTrendline || !props.open) {\n    return [];\n  }\n  let v1_trendline: trendlineType[] = []\n  if (v1_weights.length >= 3) {\n    const weights = v1_weights.map(w => w.weight);\n    const dates = v1_weights.map(w => new Date(w.datetime_fetched.split('T')[0]));\n    try {\n      v1_trendline = generateTrendline(weights, dates);\n    } catch (error) {\n      console.log('Error in trendline_v1: ',weights, dates)\n      console.log(error)\n    }\n  }\n  return v1_trendline.map((weight: any) => {\n      if (!weight.date || !weight.weight) {\n        console.warn(`Missing properties in weight object: ${JSON.stringify(weight)}`);\n        return null;\n      }\n      weight.x = weight.date.toISOString();\n      weight.y = weight.weight;\n      return weight;\n    })\n};\n\nconst mapV2Trendline = (v2_weights: BatchWeightV2Type[]): ChartPointType[] => {\n  if (!props.showTrendline || !props.open) {\n    return [];\n  }\n  let v2_trendline: trendlineType[] = []\n  if (v2_weights.length >= 3) {\n    const weights = v2_weights.map(w => w.average_weight);\n    const dates = v2_weights.map(w => new Date(w.start_datetime.split('T')[0]));\n    try {\n      v2_trendline = generateTrendline(weights, dates);\n    } catch (error) {\n      console.log('Error in trendline_v2: ',weights, dates)\n      console.log(error)\n    }\n  }\n  return v2_trendline.map((weight: any) => {\n      if (!weight.date || !weight.weight) {\n        console.warn(`Missing properties in weight object: ${JSON.stringify(weight)}`);\n        return null;\n      }\n      weight.x = weight.date.toISOString();\n      weight.y = weight.weight;\n      return weight;\n    })\n};\n\n\n\n// Computed\nconst acquisitions: ComputedRef<ChartPointType[]> = computed(() =>\n  mapAcquisition(props.acquisitions)\n);\nconst weights: ComputedRef<ChartPointType[]> = computed(() =>\n  mapWeight(props.weights)\n);\nconst refCurveData: ComputedRef<ChartPointType[]> = computed(() =>\n  mapRefCurve(props.weights_v2)\n);\nconst weightsV2: ComputedRef<ChartPointType[]> = computed(() =>\n  mapWeightsV2(props.weights_v2)\n);\nconst V1Trendline: ComputedRef<ChartPointType[]> = computed(() =>\n  mapV1Trendline(props.weights)\n);\nconst V2Trendline: ComputedRef<ChartPointType[]> = computed(() =>\n  mapV2Trendline(props.weights_v2.filter((weight) => weight && weight.model_name === props.model_name))\n);\n\nconst chartData: MaybeRef<\n  ChartData<\"scatter\", (number | ScatterDataPoint | null)[], unknown>\n> = computed(() => ({\n  datasets: [\n    {\n      label: \"Weights\",\n      data: weights.value,\n      backgroundColor: \"#78b843\",\n      borderColor: \"#78b843\",\n    },\n    {\n      label: \"Acquisitions\",\n      data: acquisitions.value,\n      backgroundColor: \"black\",\n      borderColor: \"black\",\n      pointRadius: 2,\n    },\n    {\n      label: \"Weights V2\",\n      data: weightsV2.value,\n      backgroundColor: \"blue\",\n      borderColor: \"blue\",\n    },\n    {\n      label: \"RefCurve\",\n      data: refCurveData.value,\n      backgroundColor: \"red\",\n      borderColor: \"red\",\n    },\n    {\n      label: \"BatchWeights Trendline\",\n      data: V1Trendline.value,\n      backgroundColor: \"transparent\",\n      borderColor: \"#78b843\",\n    },\n    {\n      label: \"BatchWeightsV2 Trendline\",\n      data: V2Trendline.value,\n      backgroundColor: \"transparent\",\n      borderColor: \"blue\",\n    },\n  ],\n}));\n\nChart.register(...registerables);\nChart.register(zoomPlugin);\nconst { scatterChartProps } = useScatterChart({\n  chartData,\n  options: {\n    responsive: true,\n    maintainAspectRatio: false,\n    interaction: {\n      intersect: false,\n      mode: \"nearest\",\n      axis: \"xy\",\n    },\n    scales: {\n      x: {\n        type: 'time',\n        time: {\n          parser: 'YYYY-MM-DDTHH:mm:ss.SSSZ',\n          tooltipFormat: 'll',\n          unit: 'day',\n          displayFormats: {\n            day: 'MMM D'\n          },\n        },\n      },\n    },\n    onClick: async function(evt: any, item: any[]) {\n      if (item.length > 0) {\n        const datasetIndex = item[0].datasetIndex;\n        const dataIndex = item[0].index;\n        const datasetLabel = chartData.value.datasets[datasetIndex].label;\n\n        if (datasetLabel === \"Weights V2\") {\n          const inputKeys = chartData.value.datasets[datasetIndex].data[dataIndex].additional_info.input_key;\n\n          const response = await fetch(`https://machinelearning.pecsmart.cloud/s3/get_s3_photos_grid?bucket_name=smartcam-v2&s3_file_paths=${inputKeys}`);\n          const blob = await response.blob();\n          const url = URL.createObjectURL(blob);\n\n          // Display the image in the modal\n          modalData.value = url\n          isModalOpen.value = true;\n        }\n      }\n    },\n    plugins: {\n      zoom: {\n        pan: {\n          enabled: true,\n          mode: 'xy',\n        },\n        zoom: {\n          wheel: {\n            enabled: true,\n          },\n          mode: 'xy',\n        }\n      },\n      tooltip: {\n        callbacks: {\n          label: function(context: any) {return context.dataset.label || ''},\n          afterLabel: function(context: any) {\n            const datasetIndex = context.datasetIndex;\n            const datasetLabel = chartData.value.datasets[datasetIndex].label;\n\n            if (datasetLabel === \"Weights V2\" || datasetLabel === \"RefCurve\") {\n              return [\n                `Age: ${getAge(context.raw.start_datetime.split('T')[0], props.batch.date_accomodation)}`,\n                `Batch: ${context.raw.batch}`,\n                `Pig Pen: ${context.raw.pig_pen}`,\n                `Model Name: ${context.raw.model_name}`,\n                `Average Weight: ${context.raw.average_weight}`,\n                `Standard Deviation: ${context.raw.standard_deviation}`,\n                `Min Weight: ${context.raw.min_weight}`,\n                `Max Weight: ${context.raw.max_weight}`,\n                `Total Reading Count: ${context.raw.total_reading_count}`,\n                `Valid Reading Count: ${context.raw.valid_reading_count}`,\n                `Movement Index: ${context.raw.movement_index}`,\n                `Start Date: ${context.raw.start_datetime.split('T')[0]}`,\n                `End Date: ${context.raw.end_datetime.split('T')[0]}`\n              ];\n            } else if (datasetLabel === \"Weights\") {\n              return [\n                `Age: ${getAge(context.raw.datetime_fetched.split('T')[0], props.batch.date_accomodation)}`,\n                `Batch: ${context.raw.batch}`,\n                `Weight: ${context.raw.weight}`,\n                `Uniformity: ${context.raw.uniformity}`,\n                `Standard Deviation: ${context.raw.standard_deviation}`,\n                `Date: ${context.raw.datetime_fetched.split('T')[0]}`,\n                `Acquisition: ${context.raw.acquisition}`\n              ];\n            } else if (datasetLabel === \"Acquisitions\") {\n              return [\n                `Age: ${getAge(context.raw.date_fetched, props.batch.date_accomodation)}`,\n                `Camera MAC: ${context.raw.camera_mac}`,\n                `Received Date: ${context.raw.datetime_received.split('T')[0]}`,\n                `Fetched Date: ${context.raw.date_fetched}`,\n                `Weight: ${context.raw.weight}`,\n                `Growth: ${context.raw.growth}`,\n                `Reading Count: ${context.raw.reading_count}`,\n                `Uniformity: ${context.raw.uniformity}`,\n                `Standard Deviation: ${context.raw.standard_deviation}`\n              ];\n            } else if (datasetLabel === \"BatchWeights Trendline\" || datasetLabel === \"BatchWeightsV2 Trendline\"){\n              return [\n                `Age: ${getAge(context.raw.date, props.batch.date_accomodation)}`,\n                `Weight: ${context.raw.weight}`,\n                `Date: ${context.raw.date}`\n              ];\n            }\n          },\n          beforeFooter: function(context: any) {\n            const datasetIndex = context[0].datasetIndex;\n            const dataIndex = context[0].dataIndex;\n            const datasetLabel = chartData.value.datasets[datasetIndex].label;\n            \n            if (datasetLabel === \"Weights V2\") {\n              const additionalInfo = chartData.value.datasets[datasetIndex].data[dataIndex].additional_info;\n              return [\n                `Batch Coverage: ${additionalInfo.batch_coverage}`,\n                `Movement Coverage: ${additionalInfo.movement_coverage}`,\n                `Number of Pigs: ${additionalInfo.num_pigs}`\n              ];\n            }\n          }\n        }\n      }\n    },\n  },\n});\n\nreturn (_ctx: any,_cache: any) => {\n  return (_openBlock(), _createElementBlock(_Fragment, null, [\n    _createVNode(_unref(ScatterChart), _normalizeProps(_guardReactiveProps(_unref(scatterChartProps))), null, 16),\n    (isModalOpen.value)\n      ? (_openBlock(), _createElementBlock(\"div\", _hoisted_1, [\n          _createElementVNode(\"img\", {\n            src: modalData.value,\n            alt: \"Grid Image\",\n            style: {\"width\":\"100%\",\"height\":\"100%\",\"display\":\"flex\",\"justify-content\":\"center\"}\n          }, null, 8, _hoisted_2),\n          _createElementVNode(\"div\", _hoisted_3, [\n            _createElementVNode(\"button\", {\n              onClick: _cache[0] || (_cache[0] = ($event: any) => (isModalOpen.value = false))\n            }, \"Close\")\n          ])\n        ]))\n      : _createCommentVNode(\"\", true)\n  ], 64))\n}\n}\n\n})","import script from \"./CamDetailsChart.vue?vue&type=script&lang=ts&setup=true\"\nexport * from \"./CamDetailsChart.vue?vue&type=script&lang=ts&setup=true\"\n\nimport \"./CamDetailsChart.vue?vue&type=style&index=0&id=551548aa&scoped=true&lang=css\"\n\nimport exportComponent from \"/home/runner/work/support-platform/support-platform/node_modules/vue-loader-v16/dist/exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['__scopeId',\"data-v-551548aa\"]])\n\nexport default __exports__","import { defineComponent as _defineComponent } from 'vue'\nimport { toDisplayString as _toDisplayString, createElementVNode as _createElementVNode, normalizeStyle as _normalizeStyle, createTextVNode as _createTextVNode, createVNode as _createVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from \"vue\"\n\nconst _withScopeId = n => (_pushScopeId(\"data-v-d0cfe9fc\"),n=n(),_popScopeId(),n)\nconst _hoisted_1 = { class: \"container\" }\nconst _hoisted_2 = { class: \"smartcam\" }\nconst _hoisted_3 = { id: \"sensor-name\" }\nconst _hoisted_4 = { class: \"batch-number\" }\nconst _hoisted_5 = /*#__PURE__*/ _withScopeId(() => /*#__PURE__*/_createElementVNode(\"br\", null, null, -1))\nconst _hoisted_6 = { class: \"chart-wrapper\" }\n\nimport CamDetailsChart from \"@/components/CamDetailsChart.vue\";\nimport { PropType, ref, watch } from \"vue\";\nimport { CamDataType } from \"@/types/cam_data\";\nimport { BatchInfoType } from \"@/types/cam_batch\";\n\n\nexport default /*#__PURE__*/_defineComponent({\n  props: {\n  cam: { type: Object as PropType<CamDataType>, required: true },\n  show_ref_curve_status: { required: true },\n  show_trendline_status: { required: true },\n  dynamic_model_name: { required: true },\n},\n  setup(__props) {\n\nconst props = __props\n\n\n\nconst currentBatchIndex = ref(0);\nconst currentBatchData = ref<BatchInfoType>(props.cam.batches[currentBatchIndex.value]);\nconst dynamicModelName = ref(\"no-model\");\nconst showRefCurveStatus = ref(true);\nconst showTrendlineStatus = ref(false);\n\nwatch(\n  () => props.dynamic_model_name,\n  (newVal, oldVal) => {\n    dynamicModelName.value = newVal;\n  }\n);\n\nwatch(\n  () => props.show_ref_curve_status,\n  (newVal, oldVal) => {\n    showRefCurveStatus.value = newVal;\n    console.log(\"Child detected change in show_ref_curve_status:\", newVal); // Add this line\n  }\n);\n\nwatch(\n  () => props.show_trendline_status,\n  (newVal, oldVal) => {\n    showTrendlineStatus.value = newVal;\n  }\n);\n\n// Methods\nconst showTrendline = () => {\n  showTrendlineStatus.value = !showTrendlineStatus.value;\n};\n\nconst showRefCurve = () => {\n  showRefCurveStatus.value = !showRefCurveStatus.value;\n};\n\nconst reportAnomaly = () => {\n  // Logic to report anomalies\n  console.log(\"Anomaly\");\n};\n\nconst prevBatch = () => {\n  if (currentBatchIndex.value > 0) {\n    currentBatchIndex.value--;\n    currentBatchData.value = props.cam.batches[currentBatchIndex.value];\n  } else {\n    currentBatchIndex.value = props.cam.batches.length - 1;\n    currentBatchData.value = props.cam.batches[currentBatchIndex.value];\n  }\n};\n\nconst nextBatch = () => {\n  if (currentBatchIndex.value < props.cam.batches.length - 1) {\n    currentBatchIndex.value++;\n    currentBatchData.value = props.cam.batches[currentBatchIndex.value];\n  } else {\n    currentBatchIndex.value = 0;\n    currentBatchData.value = props.cam.batches[currentBatchIndex.value];\n  }\n};\n\nreturn (_ctx: any,_cache: any) => {\n  return (_openBlock(), _createElementBlock(\"div\", _hoisted_1, [\n    _createElementVNode(\"div\", _hoisted_2, [\n      _createElementVNode(\"div\", _hoisted_3, _toDisplayString(__props.cam.sensor.name), 1),\n      _createElementVNode(\"div\", _hoisted_4, [\n        _createElementVNode(\"button\", {\n          onClick: nextBatch,\n          style: _normalizeStyle(`background: url(${require('@/assets/left_arrow.svg')}) no-repeat center center; background-size: contain;`)\n        }, null, 4),\n        _createTextVNode(\" Batch - \" + _toDisplayString(currentBatchData.value.batch.pk) + \" \", 1),\n        _hoisted_5,\n        _createTextVNode(\" Open: \" + _toDisplayString(currentBatchData.value.open) + \" \", 1),\n        _createElementVNode(\"button\", {\n          onClick: prevBatch,\n          style: _normalizeStyle(`background: url(${require('@/assets/right_arrow.svg')}) no-repeat center center; background-size: contain;`)\n        }, null, 4)\n      ]),\n      _createElementVNode(\"div\", { class: \"actions\" }, [\n        _createElementVNode(\"div\", { class: \"left-buttons\" }, [\n          _createElementVNode(\"button\", { onClick: showTrendline }, \"Show Trendline\"),\n          _createElementVNode(\"button\", { onClick: showRefCurve }, \"Show Ref Curve\")\n        ]),\n        _createElementVNode(\"div\", { class: \"right-button\" }, [\n          _createElementVNode(\"button\", { onClick: reportAnomaly }, \"Report Anomaly\")\n        ])\n      ]),\n      _createElementVNode(\"div\", _hoisted_6, [\n        _createVNode(CamDetailsChart, {\n          acquisitions: currentBatchData.value.batch_acquisitions,\n          weights: currentBatchData.value.batch_weights,\n          batch: currentBatchData.value.batch,\n          weights_v2: currentBatchData.value.batch_weights_v2,\n          model_name: dynamicModelName.value,\n          showRefCurve: showRefCurveStatus.value,\n          showTrendline: showTrendlineStatus.value,\n          open: currentBatchData.value.open\n        }, null, 8, [\"acquisitions\", \"weights\", \"batch\", \"weights_v2\", \"model_name\", \"showRefCurve\", \"showTrendline\", \"open\"])\n      ])\n    ])\n  ]))\n}\n}\n\n})","import script from \"./CamDetails.vue?vue&type=script&lang=ts&setup=true\"\nexport * from \"./CamDetails.vue?vue&type=script&lang=ts&setup=true\"\n\nimport \"./CamDetails.vue?vue&type=style&index=0&id=d0cfe9fc&scoped=true&lang=css\"\n\nimport exportComponent from \"/home/runner/work/support-platform/support-platform/node_modules/vue-loader-v16/dist/exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['__scopeId',\"data-v-d0cfe9fc\"]])\n\nexport default __exports__","import { defineComponent as _defineComponent } from 'vue'\nimport { createElementVNode as _createElementVNode, vModelText as _vModelText, withDirectives as _withDirectives, renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, toDisplayString as _toDisplayString, vModelSelect as _vModelSelect, createBlock as _createBlock, createCommentVNode as _createCommentVNode, unref as _unref, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from \"vue\"\n\nconst _withScopeId = n => (_pushScopeId(\"data-v-59a987bf\"),n=n(),_popScopeId(),n)\nconst _hoisted_1 = { class: \"installation-page-container\" }\nconst _hoisted_2 = { class: \"top-bar\" }\nconst _hoisted_3 = /*#__PURE__*/ _withScopeId(() => /*#__PURE__*/_createElementVNode(\"h1\", null, \"Current SmartCams\", -1))\nconst _hoisted_4 = { class: \"action-bar\" }\nconst _hoisted_5 = { class: \"left-actions\" }\nconst _hoisted_6 = { class: \"right-actions\" }\nconst _hoisted_7 = {\n  key: 1,\n  class: \"installation\"\n}\n\nimport { useMaintenanceStore } from '@/store/maintenance';\nimport { computed, ComputedRef, onMounted, ref } from \"vue\";\nimport Loading from '@/components/Loading.vue';\nimport CamDetails from '@/components/CamDetails.vue';\nimport { CamDataType } from \"@/types/cam_data\";\nimport { saveAs } from 'file-saver';\n\n\nexport default /*#__PURE__*/_defineComponent({\n  setup(__props) {\n\nconst maintenance_store = useMaintenanceStore()\n\nconst showTrendLine = () => {\n  showTrendLineStatus.value = !showTrendLineStatus.value\n};\n\nconst globalShowRefCurve = () => {\n  showRefCurveStatus.value = !showRefCurveStatus.value\n  console.log(\"Parent showRefCurveStatus:\", showRefCurveStatus.value);\n};\nconst loaded = ref(false)\nconst searchQuery = ref(\"\");\nconst modelNames = ref<string[]>([]);\nconst selectedModelName = ref('no-model');\nconst showTrendLineStatus = ref(false);\nconst showRefCurveStatus = ref(true);\nconst sortedCamsData = ref<CamDataType[]>([])\n\n// Computed\nconst getCamsData: ComputedRef<CamDataType[]> = computed(() => maintenance_store.getCamsData);\nconst filteredCamsData = computed(() => {\n  if (searchQuery.value) {\n    return sortedCamsData.value.filter(cam => \n      cam.sensor.name.toLowerCase().includes(searchQuery.value.toLowerCase())\n    );\n  }\n  return sortedCamsData.value;\n});\n\n// Methods\nconst initializeData = async () => {\n  if (getCamsData.value.length === 0) {\n    await maintenance_store.setCamInfo();\n\n    // Sort based on date_accomodation\n    const sortedByDate = [...getCamsData.value].sort((a, b) => {\n      const highestPkBatchA = a.batches.reduce((prev, current) => (prev.batch.pk > current.batch.pk) ? prev : current, {pk: 0, batch: {}});\n      const highestPkBatchB = b.batches.reduce((prev, current) => (prev.batch.pk > current.batch.pk) ? prev : current, {pk: 0, batch: {}});\n\n      const lastBatchADate = highestPkBatchA ? new Date(highestPkBatchA.batch.date_accomodation) : new Date(0);\n      const lastBatchBDate = highestPkBatchB ? new Date(highestPkBatchB.batch.date_accomodation) : new Date(0);\n      return lastBatchBDate.getTime() - lastBatchADate.getTime();\n    });\n\n    // Split the array into open and closed batches\n    const openBatches = [];\n    const closedBatches = [];\n    sortedByDate.forEach(cam => {\n      const highestPkBatch = cam.batches.reduce((prev, current) => (prev.batch.pk > current.batch.pk) ? prev : current, {pk: 0, batch: {}});\n      if (highestPkBatch && highestPkBatch.open) {\n        openBatches.push(cam);\n      } else {\n        closedBatches.push(cam);\n      }\n    });\n\n    // Join the two arrays, putting open batches first\n    sortedCamsData.value = [...openBatches, ...closedBatches];\n\n  }\n  const modelSet = new Set<string>();\n  getCamsData.value.forEach(cam => {\n    cam.batches.forEach(batch => {\n      batch.batch_weights_v2.forEach(weight => {\n        if (weight.model_name !== \"RefCurve\") {\n          modelSet.add(weight.model_name);\n        }\n      });\n    });\n  });\n  modelNames.value = Array.from(modelSet);\n  selectedModelName.value = modelNames.value[0]\n  loaded.value = true\n};\n\nfunction getFormattedDateTime() {\n    const now = new Date();\n    const year = now.getFullYear();\n    const month = String(now.getMonth() + 1).padStart(2, '0'); // +1 because months are 0-indexed\n    const day = String(now.getDate()).padStart(2, '0');\n    const hours = String(now.getHours()).padStart(2, '0');\n    const minutes = String(now.getMinutes()).padStart(2, '0');\n    const seconds = String(now.getSeconds()).padStart(2, '0');\n    \n    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;\n}\n\nfunction exportData() {\n  // Extract data from the store\n  const camsData = useMaintenanceStore().getCamsData;\n\n  // CSV header\n  let csvContent = \"Sensor ID,Barn ID,Batch ID,Origin,Model,Weight,Uniformity,Standard Deviation,Date Fetched\\n\";\n\n  // Iterate through the cams data\n  filteredCamsData.value.forEach(cam => {\n    cam.batches.forEach(batchInfo => {\n      batchInfo.batch_acquisitions.forEach(acquisition => {\n        csvContent += `${cam.sensor.id},${cam.barn.pk},${batchInfo.batch.pk},acquisitions,N/A,${acquisition.weight},${acquisition.uniformity},${acquisition.standard_deviation},${acquisition.date_fetched}\\n`;\n      });\n      batchInfo.batch_weights.forEach(weight => {\n        csvContent += `${cam.sensor.id},${cam.barn.pk},${batchInfo.batch.pk},batch_weights_v1,N/A,${weight.weight},${weight.uniformity},${weight.standard_deviation},${weight.datetime_fetched}\\n`;\n      });\n      batchInfo.batch_weights_v2.forEach(weightV2 => {\n        csvContent += `${cam.sensor.id},${cam.barn.pk},${batchInfo.batch.pk},batch_weights_v2,${weightV2.model_name},${weightV2.average_weight},${weightV2.standard_deviation},N/A,${weightV2.start_datetime}-${weightV2.end_datetime}\\n`;\n      });\n    });\n  });\n\n  // Create a blob from the CSV content\n  const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\n  const filename = `smartcam_maintenance_${getFormattedDateTime()}.csv`;\n  saveAs(blob, filename);\n}\n\nonMounted(() => {\n  initializeData();\n});\n\n\nreturn (_ctx: any,_cache: any) => {\n  return (_openBlock(), _createElementBlock(\"div\", _hoisted_1, [\n    _createElementVNode(\"div\", _hoisted_2, [\n      _hoisted_3,\n      _createElementVNode(\"div\", _hoisted_4, [\n        _createElementVNode(\"div\", _hoisted_5, [\n          _createElementVNode(\"button\", {\n            class: \"action-btn\",\n            onClick: showTrendLine\n          }, \"Show Trendlines\"),\n          _createElementVNode(\"button\", {\n            class: \"action-btn\",\n            onClick: globalShowRefCurve\n          }, \"Show Reference Curve\"),\n          _createElementVNode(\"button\", {\n            class: \"action-btn\",\n            style: {\"background-color\":\"grey\",\"color\":\"black\"},\n            onClick: exportData\n          }, \"Export CSV\"),\n          _withDirectives(_createElementVNode(\"input\", {\n            \"onUpdate:modelValue\": _cache[0] || (_cache[0] = ($event: any) => ((searchQuery).value = $event)),\n            placeholder: \"Search for SmartCam...\"\n          }, null, 512), [\n            [_vModelText, searchQuery.value]\n          ])\n        ]),\n        _createElementVNode(\"div\", _hoisted_6, [\n          _withDirectives(_createElementVNode(\"select\", {\n            class: \"model-select\",\n            \"onUpdate:modelValue\": _cache[1] || (_cache[1] = ($event: any) => ((selectedModelName).value = $event))\n          }, [\n            (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(modelNames.value, (model) => {\n              return (_openBlock(), _createElementBlock(\"option\", { key: model }, _toDisplayString(model), 1))\n            }), 128))\n          ], 512), [\n            [_vModelSelect, selectedModelName.value]\n          ])\n        ])\n      ])\n    ]),\n    (!loaded.value)\n      ? (_openBlock(), _createBlock(Loading, {\n          key: 0,\n          class: \"loading\"\n        }))\n      : (_openBlock(), _createElementBlock(\"div\", _hoisted_7, [\n          (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(_unref(filteredCamsData), (cam) => {\n            return (_openBlock(), _createBlock(CamDetails, {\n              cam: cam,\n              show_ref_curve_status: showRefCurveStatus.value,\n              show_trendline_status: showTrendLineStatus.value,\n              dynamic_model_name: selectedModelName.value,\n              key: cam.sensor.id\n            }, null, 8, [\"cam\", \"show_ref_curve_status\", \"show_trendline_status\", \"dynamic_model_name\"]))\n          }), 128))\n        ]))\n  ]))\n}\n}\n\n})","import script from \"./CamMaintenance.vue?vue&type=script&lang=ts&setup=true\"\nexport * from \"./CamMaintenance.vue?vue&type=script&lang=ts&setup=true\"\n\nimport \"./CamMaintenance.vue?vue&type=style&index=0&id=59a987bf&scoped=true&lang=css\"\n\nimport exportComponent from \"/home/runner/work/support-platform/support-platform/node_modules/vue-loader-v16/dist/exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['__scopeId',\"data-v-59a987bf\"]])\n\nexport default __exports__","module.exports = __webpack_public_path__ + \"img/left_arrow.89764f72.svg\";","// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n  if (typeof ArrayBuffer == 'function') {\n    var buffer = new ArrayBuffer(8);\n    // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n    if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n  }\n});\n","module.exports = __webpack_public_path__ + \"img/right_arrow.82fed644.svg\";","var $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + id++, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar enable = function () {\n  meta.enable = function () { /* empty */ };\n  REQUIRED = true;\n  var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n  var splice = uncurryThis([].splice);\n  var test = {};\n  test[METADATA] = 1;\n\n  // prevent exposing of metadata key\n  if (getOwnPropertyNames(test).length) {\n    getOwnPropertyNamesModule.f = function (it) {\n      var result = getOwnPropertyNames(it);\n      for (var i = 0, length = result.length; i < length; i++) {\n        if (result[i] === METADATA) {\n          splice(result, i, 1);\n          break;\n        }\n      } return result;\n    };\n\n    $({ target: 'Object', stat: true, forced: true }, {\n      getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n    });\n  }\n};\n\nvar meta = module.exports = {\n  enable: enable,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader-v16/dist/index.js??ref--1-1!./CamDetailsChart.vue?vue&type=style&index=0&id=551548aa&scoped=true&lang=css\""],"sourceRoot":""}