{"version":3,"sources":["webpack:///infobolsa.js","webpack:///webpack/bootstrap 15642e58fa5fd4eb705d","webpack:///./src/index.js","webpack:///./package.json","webpack:///./~/hammerjs/hammer.js","webpack:///./src/constants.js","webpack:///./~/crypto-js/md5.js","webpack:///./~/crypto-js/core.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","id","loaded","call","m","c","p","_interopRequireDefault","obj","__esModule","default","_load","setTimeout","RSVP","resolve","then","app","load","INFOBOLSA_URL","DDSLICK_URL","_loadCSS","_init","on","event","context$","_constants","INIT_DELAY","_cssP","Promise","reject","link","document","createElement","rel","href","CSS_URL","onload","onerror","head","appendChild","$","each","language","window","IFB","Utils","Helper","getQueryStringParam","el$","this","OPTIONS","culture","widgets","config","data","view","el","service","param","VOCENTO","Broker","Launcher","enter","_getEnvPrefix","_env","Object","defineProperty","value","VERSION","undefined","_package","_package2","_Voonto","Voonto","getInstance","lookup","env","version","length","name","description","main","scripts","test","start","build","author","license","devDependencies","babel-core","babel-eslint","babel-loader","babel-polyfill","babel-preset-es2015","case","chai","chalk","css-loader","eslint","eslint-config-airbnb-base","eslint-plugin-import","file-loader","html-webpack-plugin","json-loader","mocha","mocha-loader","mocha-phantomjs","style-loader","url-loader","webpack","webpack-shell-plugin","dependencies","crypto-js","hammer","hammerjs","__WEBPACK_AMD_DEFINE_RESULT__","exportName","setTimeoutContext","fn","timeout","context","bindFn","invokeArrayArg","arg","Array","isArray","iterator","i","forEach","hasOwnProperty","deprecate","method","message","deprecationMessage","e","Error","stack","replace","log","console","warn","apply","arguments","inherit","child","base","properties","childP","baseP","prototype","create","constructor","_super","assign","boolOrFn","val","args","TYPE_FUNCTION","ifUndefined","val1","val2","addEventListeners","target","types","handler","splitStr","type","addEventListener","removeEventListeners","removeEventListener","hasParent","node","parent","parentNode","inStr","str","find","indexOf","trim","split","inArray","src","findByKey","toArray","slice","uniqueArray","key","sort","results","values","push","a","b","prefixed","property","prefix","prop","camelProp","toUpperCase","VENDOR_PREFIXES","uniqueId","_uniqueId","getWindowForElement","element","doc","ownerDocument","defaultView","parentWindow","Input","manager","callback","self","options","inputTarget","domHandler","ev","enable","init","createInputInstance","Type","inputClass","SUPPORT_POINTER_EVENTS","PointerEventInput","SUPPORT_ONLY_TOUCH","TouchInput","SUPPORT_TOUCH","TouchMouseInput","MouseInput","inputHandler","eventType","input","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","INPUT_START","isFinal","INPUT_END","INPUT_CANCEL","session","computeInputData","emit","recognize","prevInput","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","now","deltaTime","angle","getAngle","distance","getDistance","computeDeltaXY","offsetDirection","getDirection","deltaX","deltaY","overallVelocity","getVelocity","overallVelocityX","x","overallVelocityY","y","abs","scale","getScale","rotation","getRotation","maxPointers","computeIntervalInputData","srcEvent","offset","offsetDelta","prevDelta","velocity","velocityX","velocityY","direction","last","lastInterval","COMPUTE_INTERVAL","v","clientX","round","clientY","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","p1","p2","props","PROPS_XY","Math","sqrt","atan2","PI","end","PROPS_CLIENT_XY","evEl","MOUSE_ELEMENT_EVENTS","evWin","MOUSE_WINDOW_EVENTS","pressed","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","store","pointerEvents","SingleTouchInput","evTarget","SINGLE_TOUCH_TARGET_EVENTS","SINGLE_TOUCH_WINDOW_EVENTS","started","normalizeSingleTouches","all","touches","changed","changedTouches","concat","TOUCH_TARGET_EVENTS","targetIds","getTouches","allTouches","INPUT_MOVE","identifier","targetTouches","changedTargetTouches","filter","touch","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","removeLastTouch","splice","DEDUP_TIMEOUT","isSyntheticEvent","t","dx","dy","DEDUP_DISTANCE","TouchAction","set","cleanTouchActions","actions","TOUCH_ACTION_NONE","hasPanX","TOUCH_ACTION_PAN_X","hasPanY","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_AUTO","getTouchActionProps","NATIVE_TOUCH_ACTION","touchMap","cssSupports","CSS","supports","Recognizer","defaults","state","STATE_POSSIBLE","simultaneous","requireFail","stateStr","STATE_CANCELLED","STATE_ENDED","STATE_CHANGED","STATE_BEGAN","directionStr","getRecognizerByNameIfManager","otherRecognizer","recognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","count","Hammer","recognizers","preset","Manager","handlers","oldCssProps","touchAction","toggleCssProps","item","add","recognizeWith","requireFailure","style","cssProps","triggerDomEvent","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","TEST_ELEMENT","Date","TypeError","output","index","source","nextKey","extend","dest","merge","keys","MOBILE_REGEX","navigator","userAgent","INPUT_TYPE_TOUCH","INPUT_TYPE_PEN","INPUT_TYPE_MOUSE","INPUT_TYPE_KINECT","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","destroy","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","2","3","4","5","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","toLowerCase","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","TOUCH_INPUT_MAP","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_MAP","compute","update","getTouchAction","join","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_RECOGNIZED","STATE_FAILED","dropRecognizeWith","dropRequireFailure","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","process","reset","attrTest","optionPointers","isRecognized","isValid","threshold","directionTest","hasMoved","inOut","time","validPointers","validMovement","validTime","clearTimeout","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","domEvents","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","STOP","FORCED_STOP","stop","force","stopped","curRecognizer","existing","remove","events","off","Tap","Pan","Swipe","Pinch","Rotate","Press","freeGlobal","_getSessionKey","timestamp","floor","provider","hash","passhash","_md2","toString","PRODUCTION","_md","domain","server","interactiveChart","login","freeze","servidor","idSesion","debug","root","factory","CryptoJS","FF","d","s","n","GG","HH","II","C","C_lib","lib","WordArray","Hasher","C_algo","algo","T","sin","MD5","_doReset","_hash","_doProcessBlock","M","offset_i","M_offset_i","H","words","M_offset_0","M_offset_1","M_offset_2","M_offset_3","M_offset_4","M_offset_5","M_offset_6","M_offset_7","M_offset_8","M_offset_9","M_offset_10","M_offset_11","M_offset_12","M_offset_13","M_offset_14","M_offset_15","_doFinalize","_data","dataWords","nBitsTotal","_nDataBytes","nBitsLeft","sigBytes","nBitsTotalH","nBitsTotalL","_process","H_i","clone","_createHelper","HmacMD5","_createHmacHelper","F","subtype","Base","overrides","mixIn","$super","instance","propertyName","encoder","Hex","stringify","wordArray","thisWords","thatWords","thisSigBytes","thatSigBytes","clamp","thatByte","ceil","random","nBytes","rcache","r","m_w","m_z","mask","result","_r","C_enc","enc","hexChars","bite","parse","hexStr","hexStrLength","parseInt","substr","Latin1","latin1Chars","String","fromCharCode","latin1Str","latin1StrLength","charCodeAt","Utf8","decodeURIComponent","escape","utf8Str","unescape","encodeURIComponent","BufferedBlockAlgorithm","_append","doFlush","dataSigBytes","blockSize","blockSizeBytes","nBlocksReady","max","_minBufferSize","nWordsReady","nBytesReady","min","processedWords","cfg","messageUpdate","finalize","hasher","HMAC"],"mappings":"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","file":"infobolsa.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(1);\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.VERSION = undefined;\n\t\n\tvar _package = __webpack_require__(2);\n\t\n\tvar _package2 = _interopRequireDefault(_package);\n\t\n\t__webpack_require__(3);\n\t\n\tvar _constants = __webpack_require__(4);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tvar _Voonto = Voonto,\n\t    $ = _Voonto.$,\n\t    RSVP = _Voonto.RSVP,\n\t    app = Voonto.getInstance(),\n\t    _env = app.lookup('vocento.site').env,\n\t    INFOBOLSA_URL = !_env ? './assets/infobolsa-min.js' : '//' + _getEnvPrefix() + 'static.vocento.com/infobolsa/' + _package2.default.version + '/assets/infobolsa-min.js',\n\t    DDSLICK_URL = !_env ? './assets/jquery-ddslick-min.js' : '//' + _getEnvPrefix() + 'static.vocento.com/infobolsa/' + _package2.default.version + '/assets/jquery-ddslick-min.js',\n\t    CSS_URL = !_env ? './assets/css/styles.css' : '//' + _getEnvPrefix() + 'static.vocento.com/infobolsa/' + _package2.default.version + '/assets/css/styles.css';\n\t\n\t\n\tvar _cssP;\n\t\n\tif ($('[data-voc-infobolsa]').length) {\n\t  window.onload = _load;\n\t}\n\t\n\tvar VERSION = exports.VERSION = _package2.default.version;\n\t\n\t/* Private */\n\t\n\tfunction _load() {\n\t  setTimeout(function () {\n\t    RSVP.resolve().then(function () {\n\t      return app.load(INFOBOLSA_URL);\n\t    }).then(function () {\n\t      return app.load(DDSLICK_URL);\n\t    }).then(function () {\n\t      return _loadCSS();\n\t    }).then(function () {\n\t      _init();\n\t      app.on('voonto:reload', function (event, context$) {\n\t        return _init(context$);\n\t      });\n\t    });\n\t  }, _constants.INIT_DELAY);\n\t}\n\t\n\tfunction _loadCSS() {\n\t  if (_cssP) {\n\t    return _cssP;\n\t  }\n\t\n\t  _cssP = new RSVP.Promise(function (resolve, reject) {\n\t    var link = document.createElement('link');\n\t    link.rel = 'stylesheet';\n\t    link.href = CSS_URL;\n\t    link.onload = resolve;\n\t    link.onerror = reject;\n\t    document.head.appendChild(link);\n\t  });\n\t\n\t  return _cssP;\n\t}\n\t\n\tfunction _init(context$) {\n\t  $('[data-voc-infobolsa]', context$).each(function () {\n\t    var language = window.IFB.Utils.Helper.getQueryStringParam('culture') || 'es';\n\t    var el$ = $(this);\n\t\n\t    _constants.OPTIONS.culture = { language: language };\n\t    _constants.OPTIONS.widgets = [{\n\t      config: el$.data('voc-infobolsa'),\n\t      view: { el: el$ }\n\t    }];\n\t\n\t    if (_constants.OPTIONS.widgets[0].config === 'risk_premium') {\n\t      _constants.OPTIONS.widgets[0].service = { param: 'RBPLES' };\n\t    }\n\t\n\t    new window.IFB.VOCENTO.Broker.Launcher(_constants.OPTIONS).enter();\n\t  });\n\t}\n\t\n\tfunction _getEnvPrefix() {\n\t  return _env === _constants.PRODUCTION ? '' : _env + '-'; // FIXME: solve with process.env.SOME_VAR\n\t}\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\n\tmodule.exports = {\"name\":\"infobolsa\",\"version\":\"1.0.14\",\"description\":\"\",\"main\":\"src/index.js\",\"scripts\":{\"test\":\"./node_modules/.bin/webpack && ./node_modules/.bin/mocha-phantomjs dist/spec/index.html --reporter xunit --file test-results.xml\",\"start\":\"webpack-dev-server --content-base dist/\",\"build\":\"./node_modules/webpack/bin/webpack.js\"},\"author\":\"Iván Pérez <ivanperez@vocento.com>\",\"license\":\"SEE LICENSE IN LICENSE.md\",\"devDependencies\":{\"babel-core\":\"^6.17.0\",\"babel-eslint\":\"^8.0.1\",\"babel-loader\":\"^6.2.5\",\"babel-polyfill\":\"^6.16.0\",\"babel-preset-es2015\":\"^6.16.0\",\"case\":\"^1.5.3\",\"chai\":\"^3.5.0\",\"chalk\":\"^1.1.3\",\"css-loader\":\"^0.28.7\",\"eslint\":\"^4.7.2\",\"eslint-config-airbnb-base\":\"^12.0.1\",\"eslint-plugin-import\":\"^2.7.0\",\"file-loader\":\"^1.1.5\",\"html-webpack-plugin\":\"^2.24.1\",\"json-loader\":\"^0.5.4\",\"mocha\":\"^3.1.0\",\"mocha-loader\":\"^1.0.0\",\"mocha-phantomjs\":\"^4.1.0\",\"style-loader\":\"^0.19.0\",\"url-loader\":\"^0.6.2\",\"webpack\":\"^1.13.3\",\"webpack-shell-plugin\":\"^0.4.3\"},\"dependencies\":{\"crypto-js\":\"^3.1.9-1\",\"hammer\":\"0.0.5\",\"hammerjs\":\"^2.0.8\"}}\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;/*! Hammer.JS - v2.0.7 - 2016-04-22\n\t * http://hammerjs.github.io/\n\t *\n\t * Copyright (c) 2016 Jorik Tangelder;\n\t * Licensed under the MIT license */\n\t(function(window, document, exportName, undefined) {\n\t  'use strict';\n\t\n\tvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\n\tvar TEST_ELEMENT = document.createElement('div');\n\t\n\tvar TYPE_FUNCTION = 'function';\n\t\n\tvar round = Math.round;\n\tvar abs = Math.abs;\n\tvar now = Date.now;\n\t\n\t/**\n\t * set a timeout with a given scope\n\t * @param {Function} fn\n\t * @param {Number} timeout\n\t * @param {Object} context\n\t * @returns {number}\n\t */\n\tfunction setTimeoutContext(fn, timeout, context) {\n\t    return setTimeout(bindFn(fn, context), timeout);\n\t}\n\t\n\t/**\n\t * if the argument is an array, we want to execute the fn on each entry\n\t * if it aint an array we don't want to do a thing.\n\t * this is used by all the methods that accept a single and array argument.\n\t * @param {*|Array} arg\n\t * @param {String} fn\n\t * @param {Object} [context]\n\t * @returns {Boolean}\n\t */\n\tfunction invokeArrayArg(arg, fn, context) {\n\t    if (Array.isArray(arg)) {\n\t        each(arg, context[fn], context);\n\t        return true;\n\t    }\n\t    return false;\n\t}\n\t\n\t/**\n\t * walk objects and arrays\n\t * @param {Object} obj\n\t * @param {Function} iterator\n\t * @param {Object} context\n\t */\n\tfunction each(obj, iterator, context) {\n\t    var i;\n\t\n\t    if (!obj) {\n\t        return;\n\t    }\n\t\n\t    if (obj.forEach) {\n\t        obj.forEach(iterator, context);\n\t    } else if (obj.length !== undefined) {\n\t        i = 0;\n\t        while (i < obj.length) {\n\t            iterator.call(context, obj[i], i, obj);\n\t            i++;\n\t        }\n\t    } else {\n\t        for (i in obj) {\n\t            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n\t        }\n\t    }\n\t}\n\t\n\t/**\n\t * wrap a method with a deprecation warning and stack trace\n\t * @param {Function} method\n\t * @param {String} name\n\t * @param {String} message\n\t * @returns {Function} A new function wrapping the supplied method.\n\t */\n\tfunction deprecate(method, name, message) {\n\t    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n\t    return function() {\n\t        var e = new Error('get-stack-trace');\n\t        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n\t            .replace(/^\\s+at\\s+/gm, '')\n\t            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\t\n\t        var log = window.console && (window.console.warn || window.console.log);\n\t        if (log) {\n\t            log.call(window.console, deprecationMessage, stack);\n\t        }\n\t        return method.apply(this, arguments);\n\t    };\n\t}\n\t\n\t/**\n\t * extend object.\n\t * means that properties in dest will be overwritten by the ones in src.\n\t * @param {Object} target\n\t * @param {...Object} objects_to_assign\n\t * @returns {Object} target\n\t */\n\tvar assign;\n\tif (typeof Object.assign !== 'function') {\n\t    assign = function assign(target) {\n\t        if (target === undefined || target === null) {\n\t            throw new TypeError('Cannot convert undefined or null to object');\n\t        }\n\t\n\t        var output = Object(target);\n\t        for (var index = 1; index < arguments.length; index++) {\n\t            var source = arguments[index];\n\t            if (source !== undefined && source !== null) {\n\t                for (var nextKey in source) {\n\t                    if (source.hasOwnProperty(nextKey)) {\n\t                        output[nextKey] = source[nextKey];\n\t                    }\n\t                }\n\t            }\n\t        }\n\t        return output;\n\t    };\n\t} else {\n\t    assign = Object.assign;\n\t}\n\t\n\t/**\n\t * extend object.\n\t * means that properties in dest will be overwritten by the ones in src.\n\t * @param {Object} dest\n\t * @param {Object} src\n\t * @param {Boolean} [merge=false]\n\t * @returns {Object} dest\n\t */\n\tvar extend = deprecate(function extend(dest, src, merge) {\n\t    var keys = Object.keys(src);\n\t    var i = 0;\n\t    while (i < keys.length) {\n\t        if (!merge || (merge && dest[keys[i]] === undefined)) {\n\t            dest[keys[i]] = src[keys[i]];\n\t        }\n\t        i++;\n\t    }\n\t    return dest;\n\t}, 'extend', 'Use `assign`.');\n\t\n\t/**\n\t * merge the values from src in the dest.\n\t * means that properties that exist in dest will not be overwritten by src\n\t * @param {Object} dest\n\t * @param {Object} src\n\t * @returns {Object} dest\n\t */\n\tvar merge = deprecate(function merge(dest, src) {\n\t    return extend(dest, src, true);\n\t}, 'merge', 'Use `assign`.');\n\t\n\t/**\n\t * simple class inheritance\n\t * @param {Function} child\n\t * @param {Function} base\n\t * @param {Object} [properties]\n\t */\n\tfunction inherit(child, base, properties) {\n\t    var baseP = base.prototype,\n\t        childP;\n\t\n\t    childP = child.prototype = Object.create(baseP);\n\t    childP.constructor = child;\n\t    childP._super = baseP;\n\t\n\t    if (properties) {\n\t        assign(childP, properties);\n\t    }\n\t}\n\t\n\t/**\n\t * simple function bind\n\t * @param {Function} fn\n\t * @param {Object} context\n\t * @returns {Function}\n\t */\n\tfunction bindFn(fn, context) {\n\t    return function boundFn() {\n\t        return fn.apply(context, arguments);\n\t    };\n\t}\n\t\n\t/**\n\t * let a boolean value also be a function that must return a boolean\n\t * this first item in args will be used as the context\n\t * @param {Boolean|Function} val\n\t * @param {Array} [args]\n\t * @returns {Boolean}\n\t */\n\tfunction boolOrFn(val, args) {\n\t    if (typeof val == TYPE_FUNCTION) {\n\t        return val.apply(args ? args[0] || undefined : undefined, args);\n\t    }\n\t    return val;\n\t}\n\t\n\t/**\n\t * use the val2 when val1 is undefined\n\t * @param {*} val1\n\t * @param {*} val2\n\t * @returns {*}\n\t */\n\tfunction ifUndefined(val1, val2) {\n\t    return (val1 === undefined) ? val2 : val1;\n\t}\n\t\n\t/**\n\t * addEventListener with multiple events at once\n\t * @param {EventTarget} target\n\t * @param {String} types\n\t * @param {Function} handler\n\t */\n\tfunction addEventListeners(target, types, handler) {\n\t    each(splitStr(types), function(type) {\n\t        target.addEventListener(type, handler, false);\n\t    });\n\t}\n\t\n\t/**\n\t * removeEventListener with multiple events at once\n\t * @param {EventTarget} target\n\t * @param {String} types\n\t * @param {Function} handler\n\t */\n\tfunction removeEventListeners(target, types, handler) {\n\t    each(splitStr(types), function(type) {\n\t        target.removeEventListener(type, handler, false);\n\t    });\n\t}\n\t\n\t/**\n\t * find if a node is in the given parent\n\t * @method hasParent\n\t * @param {HTMLElement} node\n\t * @param {HTMLElement} parent\n\t * @return {Boolean} found\n\t */\n\tfunction hasParent(node, parent) {\n\t    while (node) {\n\t        if (node == parent) {\n\t            return true;\n\t        }\n\t        node = node.parentNode;\n\t    }\n\t    return false;\n\t}\n\t\n\t/**\n\t * small indexOf wrapper\n\t * @param {String} str\n\t * @param {String} find\n\t * @returns {Boolean} found\n\t */\n\tfunction inStr(str, find) {\n\t    return str.indexOf(find) > -1;\n\t}\n\t\n\t/**\n\t * split string on whitespace\n\t * @param {String} str\n\t * @returns {Array} words\n\t */\n\tfunction splitStr(str) {\n\t    return str.trim().split(/\\s+/g);\n\t}\n\t\n\t/**\n\t * find if a array contains the object using indexOf or a simple polyFill\n\t * @param {Array} src\n\t * @param {String} find\n\t * @param {String} [findByKey]\n\t * @return {Boolean|Number} false when not found, or the index\n\t */\n\tfunction inArray(src, find, findByKey) {\n\t    if (src.indexOf && !findByKey) {\n\t        return src.indexOf(find);\n\t    } else {\n\t        var i = 0;\n\t        while (i < src.length) {\n\t            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n\t                return i;\n\t            }\n\t            i++;\n\t        }\n\t        return -1;\n\t    }\n\t}\n\t\n\t/**\n\t * convert array-like objects to real arrays\n\t * @param {Object} obj\n\t * @returns {Array}\n\t */\n\tfunction toArray(obj) {\n\t    return Array.prototype.slice.call(obj, 0);\n\t}\n\t\n\t/**\n\t * unique array with objects based on a key (like 'id') or just by the array's value\n\t * @param {Array} src [{id:1},{id:2},{id:1}]\n\t * @param {String} [key]\n\t * @param {Boolean} [sort=False]\n\t * @returns {Array} [{id:1},{id:2}]\n\t */\n\tfunction uniqueArray(src, key, sort) {\n\t    var results = [];\n\t    var values = [];\n\t    var i = 0;\n\t\n\t    while (i < src.length) {\n\t        var val = key ? src[i][key] : src[i];\n\t        if (inArray(values, val) < 0) {\n\t            results.push(src[i]);\n\t        }\n\t        values[i] = val;\n\t        i++;\n\t    }\n\t\n\t    if (sort) {\n\t        if (!key) {\n\t            results = results.sort();\n\t        } else {\n\t            results = results.sort(function sortUniqueArray(a, b) {\n\t                return a[key] > b[key];\n\t            });\n\t        }\n\t    }\n\t\n\t    return results;\n\t}\n\t\n\t/**\n\t * get the prefixed property\n\t * @param {Object} obj\n\t * @param {String} property\n\t * @returns {String|Undefined} prefixed\n\t */\n\tfunction prefixed(obj, property) {\n\t    var prefix, prop;\n\t    var camelProp = property[0].toUpperCase() + property.slice(1);\n\t\n\t    var i = 0;\n\t    while (i < VENDOR_PREFIXES.length) {\n\t        prefix = VENDOR_PREFIXES[i];\n\t        prop = (prefix) ? prefix + camelProp : property;\n\t\n\t        if (prop in obj) {\n\t            return prop;\n\t        }\n\t        i++;\n\t    }\n\t    return undefined;\n\t}\n\t\n\t/**\n\t * get a unique id\n\t * @returns {number} uniqueId\n\t */\n\tvar _uniqueId = 1;\n\tfunction uniqueId() {\n\t    return _uniqueId++;\n\t}\n\t\n\t/**\n\t * get the window object of an element\n\t * @param {HTMLElement} element\n\t * @returns {DocumentView|Window}\n\t */\n\tfunction getWindowForElement(element) {\n\t    var doc = element.ownerDocument || element;\n\t    return (doc.defaultView || doc.parentWindow || window);\n\t}\n\t\n\tvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\t\n\tvar SUPPORT_TOUCH = ('ontouchstart' in window);\n\tvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\n\tvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\t\n\tvar INPUT_TYPE_TOUCH = 'touch';\n\tvar INPUT_TYPE_PEN = 'pen';\n\tvar INPUT_TYPE_MOUSE = 'mouse';\n\tvar INPUT_TYPE_KINECT = 'kinect';\n\t\n\tvar COMPUTE_INTERVAL = 25;\n\t\n\tvar INPUT_START = 1;\n\tvar INPUT_MOVE = 2;\n\tvar INPUT_END = 4;\n\tvar INPUT_CANCEL = 8;\n\t\n\tvar DIRECTION_NONE = 1;\n\tvar DIRECTION_LEFT = 2;\n\tvar DIRECTION_RIGHT = 4;\n\tvar DIRECTION_UP = 8;\n\tvar DIRECTION_DOWN = 16;\n\t\n\tvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\n\tvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\n\tvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\t\n\tvar PROPS_XY = ['x', 'y'];\n\tvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\t\n\t/**\n\t * create new input type manager\n\t * @param {Manager} manager\n\t * @param {Function} callback\n\t * @returns {Input}\n\t * @constructor\n\t */\n\tfunction Input(manager, callback) {\n\t    var self = this;\n\t    this.manager = manager;\n\t    this.callback = callback;\n\t    this.element = manager.element;\n\t    this.target = manager.options.inputTarget;\n\t\n\t    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n\t    // so when disabled the input events are completely bypassed.\n\t    this.domHandler = function(ev) {\n\t        if (boolOrFn(manager.options.enable, [manager])) {\n\t            self.handler(ev);\n\t        }\n\t    };\n\t\n\t    this.init();\n\t\n\t}\n\t\n\tInput.prototype = {\n\t    /**\n\t     * should handle the inputEvent data and trigger the callback\n\t     * @virtual\n\t     */\n\t    handler: function() { },\n\t\n\t    /**\n\t     * bind the events\n\t     */\n\t    init: function() {\n\t        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n\t        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n\t        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n\t    },\n\t\n\t    /**\n\t     * unbind the events\n\t     */\n\t    destroy: function() {\n\t        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n\t        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n\t        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n\t    }\n\t};\n\t\n\t/**\n\t * create new input type manager\n\t * called by the Manager constructor\n\t * @param {Hammer} manager\n\t * @returns {Input}\n\t */\n\tfunction createInputInstance(manager) {\n\t    var Type;\n\t    var inputClass = manager.options.inputClass;\n\t\n\t    if (inputClass) {\n\t        Type = inputClass;\n\t    } else if (SUPPORT_POINTER_EVENTS) {\n\t        Type = PointerEventInput;\n\t    } else if (SUPPORT_ONLY_TOUCH) {\n\t        Type = TouchInput;\n\t    } else if (!SUPPORT_TOUCH) {\n\t        Type = MouseInput;\n\t    } else {\n\t        Type = TouchMouseInput;\n\t    }\n\t    return new (Type)(manager, inputHandler);\n\t}\n\t\n\t/**\n\t * handle input events\n\t * @param {Manager} manager\n\t * @param {String} eventType\n\t * @param {Object} input\n\t */\n\tfunction inputHandler(manager, eventType, input) {\n\t    var pointersLen = input.pointers.length;\n\t    var changedPointersLen = input.changedPointers.length;\n\t    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n\t    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\t\n\t    input.isFirst = !!isFirst;\n\t    input.isFinal = !!isFinal;\n\t\n\t    if (isFirst) {\n\t        manager.session = {};\n\t    }\n\t\n\t    // source event is the normalized value of the domEvents\n\t    // like 'touchstart, mouseup, pointerdown'\n\t    input.eventType = eventType;\n\t\n\t    // compute scale, rotation etc\n\t    computeInputData(manager, input);\n\t\n\t    // emit secret event\n\t    manager.emit('hammer.input', input);\n\t\n\t    manager.recognize(input);\n\t    manager.session.prevInput = input;\n\t}\n\t\n\t/**\n\t * extend the data with some usable properties like scale, rotate, velocity etc\n\t * @param {Object} manager\n\t * @param {Object} input\n\t */\n\tfunction computeInputData(manager, input) {\n\t    var session = manager.session;\n\t    var pointers = input.pointers;\n\t    var pointersLength = pointers.length;\n\t\n\t    // store the first input to calculate the distance and direction\n\t    if (!session.firstInput) {\n\t        session.firstInput = simpleCloneInputData(input);\n\t    }\n\t\n\t    // to compute scale and rotation we need to store the multiple touches\n\t    if (pointersLength > 1 && !session.firstMultiple) {\n\t        session.firstMultiple = simpleCloneInputData(input);\n\t    } else if (pointersLength === 1) {\n\t        session.firstMultiple = false;\n\t    }\n\t\n\t    var firstInput = session.firstInput;\n\t    var firstMultiple = session.firstMultiple;\n\t    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\t\n\t    var center = input.center = getCenter(pointers);\n\t    input.timeStamp = now();\n\t    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\t\n\t    input.angle = getAngle(offsetCenter, center);\n\t    input.distance = getDistance(offsetCenter, center);\n\t\n\t    computeDeltaXY(session, input);\n\t    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\t\n\t    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n\t    input.overallVelocityX = overallVelocity.x;\n\t    input.overallVelocityY = overallVelocity.y;\n\t    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\t\n\t    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n\t    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\t\n\t    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n\t        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\t\n\t    computeIntervalInputData(session, input);\n\t\n\t    // find the correct target\n\t    var target = manager.element;\n\t    if (hasParent(input.srcEvent.target, target)) {\n\t        target = input.srcEvent.target;\n\t    }\n\t    input.target = target;\n\t}\n\t\n\tfunction computeDeltaXY(session, input) {\n\t    var center = input.center;\n\t    var offset = session.offsetDelta || {};\n\t    var prevDelta = session.prevDelta || {};\n\t    var prevInput = session.prevInput || {};\n\t\n\t    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n\t        prevDelta = session.prevDelta = {\n\t            x: prevInput.deltaX || 0,\n\t            y: prevInput.deltaY || 0\n\t        };\n\t\n\t        offset = session.offsetDelta = {\n\t            x: center.x,\n\t            y: center.y\n\t        };\n\t    }\n\t\n\t    input.deltaX = prevDelta.x + (center.x - offset.x);\n\t    input.deltaY = prevDelta.y + (center.y - offset.y);\n\t}\n\t\n\t/**\n\t * velocity is calculated every x ms\n\t * @param {Object} session\n\t * @param {Object} input\n\t */\n\tfunction computeIntervalInputData(session, input) {\n\t    var last = session.lastInterval || input,\n\t        deltaTime = input.timeStamp - last.timeStamp,\n\t        velocity, velocityX, velocityY, direction;\n\t\n\t    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n\t        var deltaX = input.deltaX - last.deltaX;\n\t        var deltaY = input.deltaY - last.deltaY;\n\t\n\t        var v = getVelocity(deltaTime, deltaX, deltaY);\n\t        velocityX = v.x;\n\t        velocityY = v.y;\n\t        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n\t        direction = getDirection(deltaX, deltaY);\n\t\n\t        session.lastInterval = input;\n\t    } else {\n\t        // use latest velocity info if it doesn't overtake a minimum period\n\t        velocity = last.velocity;\n\t        velocityX = last.velocityX;\n\t        velocityY = last.velocityY;\n\t        direction = last.direction;\n\t    }\n\t\n\t    input.velocity = velocity;\n\t    input.velocityX = velocityX;\n\t    input.velocityY = velocityY;\n\t    input.direction = direction;\n\t}\n\t\n\t/**\n\t * create a simple clone from the input used for storage of firstInput and firstMultiple\n\t * @param {Object} input\n\t * @returns {Object} clonedInputData\n\t */\n\tfunction simpleCloneInputData(input) {\n\t    // make a simple copy of the pointers because we will get a reference if we don't\n\t    // we only need clientXY for the calculations\n\t    var pointers = [];\n\t    var i = 0;\n\t    while (i < input.pointers.length) {\n\t        pointers[i] = {\n\t            clientX: round(input.pointers[i].clientX),\n\t            clientY: round(input.pointers[i].clientY)\n\t        };\n\t        i++;\n\t    }\n\t\n\t    return {\n\t        timeStamp: now(),\n\t        pointers: pointers,\n\t        center: getCenter(pointers),\n\t        deltaX: input.deltaX,\n\t        deltaY: input.deltaY\n\t    };\n\t}\n\t\n\t/**\n\t * get the center of all the pointers\n\t * @param {Array} pointers\n\t * @return {Object} center contains `x` and `y` properties\n\t */\n\tfunction getCenter(pointers) {\n\t    var pointersLength = pointers.length;\n\t\n\t    // no need to loop when only one touch\n\t    if (pointersLength === 1) {\n\t        return {\n\t            x: round(pointers[0].clientX),\n\t            y: round(pointers[0].clientY)\n\t        };\n\t    }\n\t\n\t    var x = 0, y = 0, i = 0;\n\t    while (i < pointersLength) {\n\t        x += pointers[i].clientX;\n\t        y += pointers[i].clientY;\n\t        i++;\n\t    }\n\t\n\t    return {\n\t        x: round(x / pointersLength),\n\t        y: round(y / pointersLength)\n\t    };\n\t}\n\t\n\t/**\n\t * calculate the velocity between two points. unit is in px per ms.\n\t * @param {Number} deltaTime\n\t * @param {Number} x\n\t * @param {Number} y\n\t * @return {Object} velocity `x` and `y`\n\t */\n\tfunction getVelocity(deltaTime, x, y) {\n\t    return {\n\t        x: x / deltaTime || 0,\n\t        y: y / deltaTime || 0\n\t    };\n\t}\n\t\n\t/**\n\t * get the direction between two points\n\t * @param {Number} x\n\t * @param {Number} y\n\t * @return {Number} direction\n\t */\n\tfunction getDirection(x, y) {\n\t    if (x === y) {\n\t        return DIRECTION_NONE;\n\t    }\n\t\n\t    if (abs(x) >= abs(y)) {\n\t        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n\t    }\n\t    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n\t}\n\t\n\t/**\n\t * calculate the absolute distance between two points\n\t * @param {Object} p1 {x, y}\n\t * @param {Object} p2 {x, y}\n\t * @param {Array} [props] containing x and y keys\n\t * @return {Number} distance\n\t */\n\tfunction getDistance(p1, p2, props) {\n\t    if (!props) {\n\t        props = PROPS_XY;\n\t    }\n\t    var x = p2[props[0]] - p1[props[0]],\n\t        y = p2[props[1]] - p1[props[1]];\n\t\n\t    return Math.sqrt((x * x) + (y * y));\n\t}\n\t\n\t/**\n\t * calculate the angle between two coordinates\n\t * @param {Object} p1\n\t * @param {Object} p2\n\t * @param {Array} [props] containing x and y keys\n\t * @return {Number} angle\n\t */\n\tfunction getAngle(p1, p2, props) {\n\t    if (!props) {\n\t        props = PROPS_XY;\n\t    }\n\t    var x = p2[props[0]] - p1[props[0]],\n\t        y = p2[props[1]] - p1[props[1]];\n\t    return Math.atan2(y, x) * 180 / Math.PI;\n\t}\n\t\n\t/**\n\t * calculate the rotation degrees between two pointersets\n\t * @param {Array} start array of pointers\n\t * @param {Array} end array of pointers\n\t * @return {Number} rotation\n\t */\n\tfunction getRotation(start, end) {\n\t    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n\t}\n\t\n\t/**\n\t * calculate the scale factor between two pointersets\n\t * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n\t * @param {Array} start array of pointers\n\t * @param {Array} end array of pointers\n\t * @return {Number} scale\n\t */\n\tfunction getScale(start, end) {\n\t    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n\t}\n\t\n\tvar MOUSE_INPUT_MAP = {\n\t    mousedown: INPUT_START,\n\t    mousemove: INPUT_MOVE,\n\t    mouseup: INPUT_END\n\t};\n\t\n\tvar MOUSE_ELEMENT_EVENTS = 'mousedown';\n\tvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\t\n\t/**\n\t * Mouse events input\n\t * @constructor\n\t * @extends Input\n\t */\n\tfunction MouseInput() {\n\t    this.evEl = MOUSE_ELEMENT_EVENTS;\n\t    this.evWin = MOUSE_WINDOW_EVENTS;\n\t\n\t    this.pressed = false; // mousedown state\n\t\n\t    Input.apply(this, arguments);\n\t}\n\t\n\tinherit(MouseInput, Input, {\n\t    /**\n\t     * handle mouse events\n\t     * @param {Object} ev\n\t     */\n\t    handler: function MEhandler(ev) {\n\t        var eventType = MOUSE_INPUT_MAP[ev.type];\n\t\n\t        // on start we want to have the left mouse button down\n\t        if (eventType & INPUT_START && ev.button === 0) {\n\t            this.pressed = true;\n\t        }\n\t\n\t        if (eventType & INPUT_MOVE && ev.which !== 1) {\n\t            eventType = INPUT_END;\n\t        }\n\t\n\t        // mouse must be down\n\t        if (!this.pressed) {\n\t            return;\n\t        }\n\t\n\t        if (eventType & INPUT_END) {\n\t            this.pressed = false;\n\t        }\n\t\n\t        this.callback(this.manager, eventType, {\n\t            pointers: [ev],\n\t            changedPointers: [ev],\n\t            pointerType: INPUT_TYPE_MOUSE,\n\t            srcEvent: ev\n\t        });\n\t    }\n\t});\n\t\n\tvar POINTER_INPUT_MAP = {\n\t    pointerdown: INPUT_START,\n\t    pointermove: INPUT_MOVE,\n\t    pointerup: INPUT_END,\n\t    pointercancel: INPUT_CANCEL,\n\t    pointerout: INPUT_CANCEL\n\t};\n\t\n\t// in IE10 the pointer types is defined as an enum\n\tvar IE10_POINTER_TYPE_ENUM = {\n\t    2: INPUT_TYPE_TOUCH,\n\t    3: INPUT_TYPE_PEN,\n\t    4: INPUT_TYPE_MOUSE,\n\t    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n\t};\n\t\n\tvar POINTER_ELEMENT_EVENTS = 'pointerdown';\n\tvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\t\n\t// IE10 has prefixed support, and case-sensitive\n\tif (window.MSPointerEvent && !window.PointerEvent) {\n\t    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n\t    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n\t}\n\t\n\t/**\n\t * Pointer events input\n\t * @constructor\n\t * @extends Input\n\t */\n\tfunction PointerEventInput() {\n\t    this.evEl = POINTER_ELEMENT_EVENTS;\n\t    this.evWin = POINTER_WINDOW_EVENTS;\n\t\n\t    Input.apply(this, arguments);\n\t\n\t    this.store = (this.manager.session.pointerEvents = []);\n\t}\n\t\n\tinherit(PointerEventInput, Input, {\n\t    /**\n\t     * handle mouse events\n\t     * @param {Object} ev\n\t     */\n\t    handler: function PEhandler(ev) {\n\t        var store = this.store;\n\t        var removePointer = false;\n\t\n\t        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n\t        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n\t        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\t\n\t        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\t\n\t        // get index of the event in the store\n\t        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\t\n\t        // start and mouse must be down\n\t        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n\t            if (storeIndex < 0) {\n\t                store.push(ev);\n\t                storeIndex = store.length - 1;\n\t            }\n\t        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n\t            removePointer = true;\n\t        }\n\t\n\t        // it not found, so the pointer hasn't been down (so it's probably a hover)\n\t        if (storeIndex < 0) {\n\t            return;\n\t        }\n\t\n\t        // update the event in the store\n\t        store[storeIndex] = ev;\n\t\n\t        this.callback(this.manager, eventType, {\n\t            pointers: store,\n\t            changedPointers: [ev],\n\t            pointerType: pointerType,\n\t            srcEvent: ev\n\t        });\n\t\n\t        if (removePointer) {\n\t            // remove from the store\n\t            store.splice(storeIndex, 1);\n\t        }\n\t    }\n\t});\n\t\n\tvar SINGLE_TOUCH_INPUT_MAP = {\n\t    touchstart: INPUT_START,\n\t    touchmove: INPUT_MOVE,\n\t    touchend: INPUT_END,\n\t    touchcancel: INPUT_CANCEL\n\t};\n\t\n\tvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\n\tvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\t\n\t/**\n\t * Touch events input\n\t * @constructor\n\t * @extends Input\n\t */\n\tfunction SingleTouchInput() {\n\t    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n\t    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n\t    this.started = false;\n\t\n\t    Input.apply(this, arguments);\n\t}\n\t\n\tinherit(SingleTouchInput, Input, {\n\t    handler: function TEhandler(ev) {\n\t        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\t\n\t        // should we handle the touch events?\n\t        if (type === INPUT_START) {\n\t            this.started = true;\n\t        }\n\t\n\t        if (!this.started) {\n\t            return;\n\t        }\n\t\n\t        var touches = normalizeSingleTouches.call(this, ev, type);\n\t\n\t        // when done, reset the started state\n\t        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n\t            this.started = false;\n\t        }\n\t\n\t        this.callback(this.manager, type, {\n\t            pointers: touches[0],\n\t            changedPointers: touches[1],\n\t            pointerType: INPUT_TYPE_TOUCH,\n\t            srcEvent: ev\n\t        });\n\t    }\n\t});\n\t\n\t/**\n\t * @this {TouchInput}\n\t * @param {Object} ev\n\t * @param {Number} type flag\n\t * @returns {undefined|Array} [all, changed]\n\t */\n\tfunction normalizeSingleTouches(ev, type) {\n\t    var all = toArray(ev.touches);\n\t    var changed = toArray(ev.changedTouches);\n\t\n\t    if (type & (INPUT_END | INPUT_CANCEL)) {\n\t        all = uniqueArray(all.concat(changed), 'identifier', true);\n\t    }\n\t\n\t    return [all, changed];\n\t}\n\t\n\tvar TOUCH_INPUT_MAP = {\n\t    touchstart: INPUT_START,\n\t    touchmove: INPUT_MOVE,\n\t    touchend: INPUT_END,\n\t    touchcancel: INPUT_CANCEL\n\t};\n\t\n\tvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\t\n\t/**\n\t * Multi-user touch events input\n\t * @constructor\n\t * @extends Input\n\t */\n\tfunction TouchInput() {\n\t    this.evTarget = TOUCH_TARGET_EVENTS;\n\t    this.targetIds = {};\n\t\n\t    Input.apply(this, arguments);\n\t}\n\t\n\tinherit(TouchInput, Input, {\n\t    handler: function MTEhandler(ev) {\n\t        var type = TOUCH_INPUT_MAP[ev.type];\n\t        var touches = getTouches.call(this, ev, type);\n\t        if (!touches) {\n\t            return;\n\t        }\n\t\n\t        this.callback(this.manager, type, {\n\t            pointers: touches[0],\n\t            changedPointers: touches[1],\n\t            pointerType: INPUT_TYPE_TOUCH,\n\t            srcEvent: ev\n\t        });\n\t    }\n\t});\n\t\n\t/**\n\t * @this {TouchInput}\n\t * @param {Object} ev\n\t * @param {Number} type flag\n\t * @returns {undefined|Array} [all, changed]\n\t */\n\tfunction getTouches(ev, type) {\n\t    var allTouches = toArray(ev.touches);\n\t    var targetIds = this.targetIds;\n\t\n\t    // when there is only one touch, the process can be simplified\n\t    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n\t        targetIds[allTouches[0].identifier] = true;\n\t        return [allTouches, allTouches];\n\t    }\n\t\n\t    var i,\n\t        targetTouches,\n\t        changedTouches = toArray(ev.changedTouches),\n\t        changedTargetTouches = [],\n\t        target = this.target;\n\t\n\t    // get target touches from touches\n\t    targetTouches = allTouches.filter(function(touch) {\n\t        return hasParent(touch.target, target);\n\t    });\n\t\n\t    // collect touches\n\t    if (type === INPUT_START) {\n\t        i = 0;\n\t        while (i < targetTouches.length) {\n\t            targetIds[targetTouches[i].identifier] = true;\n\t            i++;\n\t        }\n\t    }\n\t\n\t    // filter changed touches to only contain touches that exist in the collected target ids\n\t    i = 0;\n\t    while (i < changedTouches.length) {\n\t        if (targetIds[changedTouches[i].identifier]) {\n\t            changedTargetTouches.push(changedTouches[i]);\n\t        }\n\t\n\t        // cleanup removed touches\n\t        if (type & (INPUT_END | INPUT_CANCEL)) {\n\t            delete targetIds[changedTouches[i].identifier];\n\t        }\n\t        i++;\n\t    }\n\t\n\t    if (!changedTargetTouches.length) {\n\t        return;\n\t    }\n\t\n\t    return [\n\t        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n\t        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n\t        changedTargetTouches\n\t    ];\n\t}\n\t\n\t/**\n\t * Combined touch and mouse input\n\t *\n\t * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n\t * This because touch devices also emit mouse events while doing a touch.\n\t *\n\t * @constructor\n\t * @extends Input\n\t */\n\t\n\tvar DEDUP_TIMEOUT = 2500;\n\tvar DEDUP_DISTANCE = 25;\n\t\n\tfunction TouchMouseInput() {\n\t    Input.apply(this, arguments);\n\t\n\t    var handler = bindFn(this.handler, this);\n\t    this.touch = new TouchInput(this.manager, handler);\n\t    this.mouse = new MouseInput(this.manager, handler);\n\t\n\t    this.primaryTouch = null;\n\t    this.lastTouches = [];\n\t}\n\t\n\tinherit(TouchMouseInput, Input, {\n\t    /**\n\t     * handle mouse and touch events\n\t     * @param {Hammer} manager\n\t     * @param {String} inputEvent\n\t     * @param {Object} inputData\n\t     */\n\t    handler: function TMEhandler(manager, inputEvent, inputData) {\n\t        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n\t            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\t\n\t        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n\t            return;\n\t        }\n\t\n\t        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n\t        if (isTouch) {\n\t            recordTouches.call(this, inputEvent, inputData);\n\t        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n\t            return;\n\t        }\n\t\n\t        this.callback(manager, inputEvent, inputData);\n\t    },\n\t\n\t    /**\n\t     * remove the event listeners\n\t     */\n\t    destroy: function destroy() {\n\t        this.touch.destroy();\n\t        this.mouse.destroy();\n\t    }\n\t});\n\t\n\tfunction recordTouches(eventType, eventData) {\n\t    if (eventType & INPUT_START) {\n\t        this.primaryTouch = eventData.changedPointers[0].identifier;\n\t        setLastTouch.call(this, eventData);\n\t    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n\t        setLastTouch.call(this, eventData);\n\t    }\n\t}\n\t\n\tfunction setLastTouch(eventData) {\n\t    var touch = eventData.changedPointers[0];\n\t\n\t    if (touch.identifier === this.primaryTouch) {\n\t        var lastTouch = {x: touch.clientX, y: touch.clientY};\n\t        this.lastTouches.push(lastTouch);\n\t        var lts = this.lastTouches;\n\t        var removeLastTouch = function() {\n\t            var i = lts.indexOf(lastTouch);\n\t            if (i > -1) {\n\t                lts.splice(i, 1);\n\t            }\n\t        };\n\t        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n\t    }\n\t}\n\t\n\tfunction isSyntheticEvent(eventData) {\n\t    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n\t    for (var i = 0; i < this.lastTouches.length; i++) {\n\t        var t = this.lastTouches[i];\n\t        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n\t        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n\t            return true;\n\t        }\n\t    }\n\t    return false;\n\t}\n\t\n\tvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\n\tvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\t\n\t// magical touchAction value\n\tvar TOUCH_ACTION_COMPUTE = 'compute';\n\tvar TOUCH_ACTION_AUTO = 'auto';\n\tvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\n\tvar TOUCH_ACTION_NONE = 'none';\n\tvar TOUCH_ACTION_PAN_X = 'pan-x';\n\tvar TOUCH_ACTION_PAN_Y = 'pan-y';\n\tvar TOUCH_ACTION_MAP = getTouchActionProps();\n\t\n\t/**\n\t * Touch Action\n\t * sets the touchAction property or uses the js alternative\n\t * @param {Manager} manager\n\t * @param {String} value\n\t * @constructor\n\t */\n\tfunction TouchAction(manager, value) {\n\t    this.manager = manager;\n\t    this.set(value);\n\t}\n\t\n\tTouchAction.prototype = {\n\t    /**\n\t     * set the touchAction value on the element or enable the polyfill\n\t     * @param {String} value\n\t     */\n\t    set: function(value) {\n\t        // find out the touch-action by the event handlers\n\t        if (value == TOUCH_ACTION_COMPUTE) {\n\t            value = this.compute();\n\t        }\n\t\n\t        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n\t            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n\t        }\n\t        this.actions = value.toLowerCase().trim();\n\t    },\n\t\n\t    /**\n\t     * just re-set the touchAction value\n\t     */\n\t    update: function() {\n\t        this.set(this.manager.options.touchAction);\n\t    },\n\t\n\t    /**\n\t     * compute the value for the touchAction property based on the recognizer's settings\n\t     * @returns {String} value\n\t     */\n\t    compute: function() {\n\t        var actions = [];\n\t        each(this.manager.recognizers, function(recognizer) {\n\t            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n\t                actions = actions.concat(recognizer.getTouchAction());\n\t            }\n\t        });\n\t        return cleanTouchActions(actions.join(' '));\n\t    },\n\t\n\t    /**\n\t     * this method is called on each input cycle and provides the preventing of the browser behavior\n\t     * @param {Object} input\n\t     */\n\t    preventDefaults: function(input) {\n\t        var srcEvent = input.srcEvent;\n\t        var direction = input.offsetDirection;\n\t\n\t        // if the touch action did prevented once this session\n\t        if (this.manager.session.prevented) {\n\t            srcEvent.preventDefault();\n\t            return;\n\t        }\n\t\n\t        var actions = this.actions;\n\t        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n\t        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n\t        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\t\n\t        if (hasNone) {\n\t            //do not prevent defaults if this is a tap gesture\n\t\n\t            var isTapPointer = input.pointers.length === 1;\n\t            var isTapMovement = input.distance < 2;\n\t            var isTapTouchTime = input.deltaTime < 250;\n\t\n\t            if (isTapPointer && isTapMovement && isTapTouchTime) {\n\t                return;\n\t            }\n\t        }\n\t\n\t        if (hasPanX && hasPanY) {\n\t            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n\t            return;\n\t        }\n\t\n\t        if (hasNone ||\n\t            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n\t            (hasPanX && direction & DIRECTION_VERTICAL)) {\n\t            return this.preventSrc(srcEvent);\n\t        }\n\t    },\n\t\n\t    /**\n\t     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n\t     * @param {Object} srcEvent\n\t     */\n\t    preventSrc: function(srcEvent) {\n\t        this.manager.session.prevented = true;\n\t        srcEvent.preventDefault();\n\t    }\n\t};\n\t\n\t/**\n\t * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n\t * @param {String} actions\n\t * @returns {*}\n\t */\n\tfunction cleanTouchActions(actions) {\n\t    // none\n\t    if (inStr(actions, TOUCH_ACTION_NONE)) {\n\t        return TOUCH_ACTION_NONE;\n\t    }\n\t\n\t    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n\t    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\t\n\t    // if both pan-x and pan-y are set (different recognizers\n\t    // for different directions, e.g. horizontal pan but vertical swipe?)\n\t    // we need none (as otherwise with pan-x pan-y combined none of these\n\t    // recognizers will work, since the browser would handle all panning\n\t    if (hasPanX && hasPanY) {\n\t        return TOUCH_ACTION_NONE;\n\t    }\n\t\n\t    // pan-x OR pan-y\n\t    if (hasPanX || hasPanY) {\n\t        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n\t    }\n\t\n\t    // manipulation\n\t    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n\t        return TOUCH_ACTION_MANIPULATION;\n\t    }\n\t\n\t    return TOUCH_ACTION_AUTO;\n\t}\n\t\n\tfunction getTouchActionProps() {\n\t    if (!NATIVE_TOUCH_ACTION) {\n\t        return false;\n\t    }\n\t    var touchMap = {};\n\t    var cssSupports = window.CSS && window.CSS.supports;\n\t    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\t\n\t        // If css.supports is not supported but there is native touch-action assume it supports\n\t        // all values. This is the case for IE 10 and 11.\n\t        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n\t    });\n\t    return touchMap;\n\t}\n\t\n\t/**\n\t * Recognizer flow explained; *\n\t * All recognizers have the initial state of POSSIBLE when a input session starts.\n\t * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n\t * Example session for mouse-input: mousedown -> mousemove -> mouseup\n\t *\n\t * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n\t * which determines with state it should be.\n\t *\n\t * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n\t * POSSIBLE to give it another change on the next cycle.\n\t *\n\t *               Possible\n\t *                  |\n\t *            +-----+---------------+\n\t *            |                     |\n\t *      +-----+-----+               |\n\t *      |           |               |\n\t *   Failed      Cancelled          |\n\t *                          +-------+------+\n\t *                          |              |\n\t *                      Recognized       Began\n\t *                                         |\n\t *                                      Changed\n\t *                                         |\n\t *                                  Ended/Recognized\n\t */\n\tvar STATE_POSSIBLE = 1;\n\tvar STATE_BEGAN = 2;\n\tvar STATE_CHANGED = 4;\n\tvar STATE_ENDED = 8;\n\tvar STATE_RECOGNIZED = STATE_ENDED;\n\tvar STATE_CANCELLED = 16;\n\tvar STATE_FAILED = 32;\n\t\n\t/**\n\t * Recognizer\n\t * Every recognizer needs to extend from this class.\n\t * @constructor\n\t * @param {Object} options\n\t */\n\tfunction Recognizer(options) {\n\t    this.options = assign({}, this.defaults, options || {});\n\t\n\t    this.id = uniqueId();\n\t\n\t    this.manager = null;\n\t\n\t    // default is enable true\n\t    this.options.enable = ifUndefined(this.options.enable, true);\n\t\n\t    this.state = STATE_POSSIBLE;\n\t\n\t    this.simultaneous = {};\n\t    this.requireFail = [];\n\t}\n\t\n\tRecognizer.prototype = {\n\t    /**\n\t     * @virtual\n\t     * @type {Object}\n\t     */\n\t    defaults: {},\n\t\n\t    /**\n\t     * set options\n\t     * @param {Object} options\n\t     * @return {Recognizer}\n\t     */\n\t    set: function(options) {\n\t        assign(this.options, options);\n\t\n\t        // also update the touchAction, in case something changed about the directions/enabled state\n\t        this.manager && this.manager.touchAction.update();\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * recognize simultaneous with an other recognizer.\n\t     * @param {Recognizer} otherRecognizer\n\t     * @returns {Recognizer} this\n\t     */\n\t    recognizeWith: function(otherRecognizer) {\n\t        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n\t            return this;\n\t        }\n\t\n\t        var simultaneous = this.simultaneous;\n\t        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n\t        if (!simultaneous[otherRecognizer.id]) {\n\t            simultaneous[otherRecognizer.id] = otherRecognizer;\n\t            otherRecognizer.recognizeWith(this);\n\t        }\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n\t     * @param {Recognizer} otherRecognizer\n\t     * @returns {Recognizer} this\n\t     */\n\t    dropRecognizeWith: function(otherRecognizer) {\n\t        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n\t            return this;\n\t        }\n\t\n\t        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n\t        delete this.simultaneous[otherRecognizer.id];\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * recognizer can only run when an other is failing\n\t     * @param {Recognizer} otherRecognizer\n\t     * @returns {Recognizer} this\n\t     */\n\t    requireFailure: function(otherRecognizer) {\n\t        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n\t            return this;\n\t        }\n\t\n\t        var requireFail = this.requireFail;\n\t        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n\t        if (inArray(requireFail, otherRecognizer) === -1) {\n\t            requireFail.push(otherRecognizer);\n\t            otherRecognizer.requireFailure(this);\n\t        }\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * drop the requireFailure link. it does not remove the link on the other recognizer.\n\t     * @param {Recognizer} otherRecognizer\n\t     * @returns {Recognizer} this\n\t     */\n\t    dropRequireFailure: function(otherRecognizer) {\n\t        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n\t            return this;\n\t        }\n\t\n\t        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n\t        var index = inArray(this.requireFail, otherRecognizer);\n\t        if (index > -1) {\n\t            this.requireFail.splice(index, 1);\n\t        }\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * has require failures boolean\n\t     * @returns {boolean}\n\t     */\n\t    hasRequireFailures: function() {\n\t        return this.requireFail.length > 0;\n\t    },\n\t\n\t    /**\n\t     * if the recognizer can recognize simultaneous with an other recognizer\n\t     * @param {Recognizer} otherRecognizer\n\t     * @returns {Boolean}\n\t     */\n\t    canRecognizeWith: function(otherRecognizer) {\n\t        return !!this.simultaneous[otherRecognizer.id];\n\t    },\n\t\n\t    /**\n\t     * You should use `tryEmit` instead of `emit` directly to check\n\t     * that all the needed recognizers has failed before emitting.\n\t     * @param {Object} input\n\t     */\n\t    emit: function(input) {\n\t        var self = this;\n\t        var state = this.state;\n\t\n\t        function emit(event) {\n\t            self.manager.emit(event, input);\n\t        }\n\t\n\t        // 'panstart' and 'panmove'\n\t        if (state < STATE_ENDED) {\n\t            emit(self.options.event + stateStr(state));\n\t        }\n\t\n\t        emit(self.options.event); // simple 'eventName' events\n\t\n\t        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n\t            emit(input.additionalEvent);\n\t        }\n\t\n\t        // panend and pancancel\n\t        if (state >= STATE_ENDED) {\n\t            emit(self.options.event + stateStr(state));\n\t        }\n\t    },\n\t\n\t    /**\n\t     * Check that all the require failure recognizers has failed,\n\t     * if true, it emits a gesture event,\n\t     * otherwise, setup the state to FAILED.\n\t     * @param {Object} input\n\t     */\n\t    tryEmit: function(input) {\n\t        if (this.canEmit()) {\n\t            return this.emit(input);\n\t        }\n\t        // it's failing anyway\n\t        this.state = STATE_FAILED;\n\t    },\n\t\n\t    /**\n\t     * can we emit?\n\t     * @returns {boolean}\n\t     */\n\t    canEmit: function() {\n\t        var i = 0;\n\t        while (i < this.requireFail.length) {\n\t            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n\t                return false;\n\t            }\n\t            i++;\n\t        }\n\t        return true;\n\t    },\n\t\n\t    /**\n\t     * update the recognizer\n\t     * @param {Object} inputData\n\t     */\n\t    recognize: function(inputData) {\n\t        // make a new copy of the inputData\n\t        // so we can change the inputData without messing up the other recognizers\n\t        var inputDataClone = assign({}, inputData);\n\t\n\t        // is is enabled and allow recognizing?\n\t        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n\t            this.reset();\n\t            this.state = STATE_FAILED;\n\t            return;\n\t        }\n\t\n\t        // reset when we've reached the end\n\t        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n\t            this.state = STATE_POSSIBLE;\n\t        }\n\t\n\t        this.state = this.process(inputDataClone);\n\t\n\t        // the recognizer has recognized a gesture\n\t        // so trigger an event\n\t        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n\t            this.tryEmit(inputDataClone);\n\t        }\n\t    },\n\t\n\t    /**\n\t     * return the state of the recognizer\n\t     * the actual recognizing happens in this method\n\t     * @virtual\n\t     * @param {Object} inputData\n\t     * @returns {Const} STATE\n\t     */\n\t    process: function(inputData) { }, // jshint ignore:line\n\t\n\t    /**\n\t     * return the preferred touch-action\n\t     * @virtual\n\t     * @returns {Array}\n\t     */\n\t    getTouchAction: function() { },\n\t\n\t    /**\n\t     * called when the gesture isn't allowed to recognize\n\t     * like when another is being recognized or it is disabled\n\t     * @virtual\n\t     */\n\t    reset: function() { }\n\t};\n\t\n\t/**\n\t * get a usable string, used as event postfix\n\t * @param {Const} state\n\t * @returns {String} state\n\t */\n\tfunction stateStr(state) {\n\t    if (state & STATE_CANCELLED) {\n\t        return 'cancel';\n\t    } else if (state & STATE_ENDED) {\n\t        return 'end';\n\t    } else if (state & STATE_CHANGED) {\n\t        return 'move';\n\t    } else if (state & STATE_BEGAN) {\n\t        return 'start';\n\t    }\n\t    return '';\n\t}\n\t\n\t/**\n\t * direction cons to string\n\t * @param {Const} direction\n\t * @returns {String}\n\t */\n\tfunction directionStr(direction) {\n\t    if (direction == DIRECTION_DOWN) {\n\t        return 'down';\n\t    } else if (direction == DIRECTION_UP) {\n\t        return 'up';\n\t    } else if (direction == DIRECTION_LEFT) {\n\t        return 'left';\n\t    } else if (direction == DIRECTION_RIGHT) {\n\t        return 'right';\n\t    }\n\t    return '';\n\t}\n\t\n\t/**\n\t * get a recognizer by name if it is bound to a manager\n\t * @param {Recognizer|String} otherRecognizer\n\t * @param {Recognizer} recognizer\n\t * @returns {Recognizer}\n\t */\n\tfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n\t    var manager = recognizer.manager;\n\t    if (manager) {\n\t        return manager.get(otherRecognizer);\n\t    }\n\t    return otherRecognizer;\n\t}\n\t\n\t/**\n\t * This recognizer is just used as a base for the simple attribute recognizers.\n\t * @constructor\n\t * @extends Recognizer\n\t */\n\tfunction AttrRecognizer() {\n\t    Recognizer.apply(this, arguments);\n\t}\n\t\n\tinherit(AttrRecognizer, Recognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof AttrRecognizer\n\t     */\n\t    defaults: {\n\t        /**\n\t         * @type {Number}\n\t         * @default 1\n\t         */\n\t        pointers: 1\n\t    },\n\t\n\t    /**\n\t     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n\t     * @memberof AttrRecognizer\n\t     * @param {Object} input\n\t     * @returns {Boolean} recognized\n\t     */\n\t    attrTest: function(input) {\n\t        var optionPointers = this.options.pointers;\n\t        return optionPointers === 0 || input.pointers.length === optionPointers;\n\t    },\n\t\n\t    /**\n\t     * Process the input and return the state for the recognizer\n\t     * @memberof AttrRecognizer\n\t     * @param {Object} input\n\t     * @returns {*} State\n\t     */\n\t    process: function(input) {\n\t        var state = this.state;\n\t        var eventType = input.eventType;\n\t\n\t        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n\t        var isValid = this.attrTest(input);\n\t\n\t        // on cancel input and we've recognized before, return STATE_CANCELLED\n\t        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n\t            return state | STATE_CANCELLED;\n\t        } else if (isRecognized || isValid) {\n\t            if (eventType & INPUT_END) {\n\t                return state | STATE_ENDED;\n\t            } else if (!(state & STATE_BEGAN)) {\n\t                return STATE_BEGAN;\n\t            }\n\t            return state | STATE_CHANGED;\n\t        }\n\t        return STATE_FAILED;\n\t    }\n\t});\n\t\n\t/**\n\t * Pan\n\t * Recognized when the pointer is down and moved in the allowed direction.\n\t * @constructor\n\t * @extends AttrRecognizer\n\t */\n\tfunction PanRecognizer() {\n\t    AttrRecognizer.apply(this, arguments);\n\t\n\t    this.pX = null;\n\t    this.pY = null;\n\t}\n\t\n\tinherit(PanRecognizer, AttrRecognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof PanRecognizer\n\t     */\n\t    defaults: {\n\t        event: 'pan',\n\t        threshold: 10,\n\t        pointers: 1,\n\t        direction: DIRECTION_ALL\n\t    },\n\t\n\t    getTouchAction: function() {\n\t        var direction = this.options.direction;\n\t        var actions = [];\n\t        if (direction & DIRECTION_HORIZONTAL) {\n\t            actions.push(TOUCH_ACTION_PAN_Y);\n\t        }\n\t        if (direction & DIRECTION_VERTICAL) {\n\t            actions.push(TOUCH_ACTION_PAN_X);\n\t        }\n\t        return actions;\n\t    },\n\t\n\t    directionTest: function(input) {\n\t        var options = this.options;\n\t        var hasMoved = true;\n\t        var distance = input.distance;\n\t        var direction = input.direction;\n\t        var x = input.deltaX;\n\t        var y = input.deltaY;\n\t\n\t        // lock to axis?\n\t        if (!(direction & options.direction)) {\n\t            if (options.direction & DIRECTION_HORIZONTAL) {\n\t                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n\t                hasMoved = x != this.pX;\n\t                distance = Math.abs(input.deltaX);\n\t            } else {\n\t                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n\t                hasMoved = y != this.pY;\n\t                distance = Math.abs(input.deltaY);\n\t            }\n\t        }\n\t        input.direction = direction;\n\t        return hasMoved && distance > options.threshold && direction & options.direction;\n\t    },\n\t\n\t    attrTest: function(input) {\n\t        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n\t            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n\t    },\n\t\n\t    emit: function(input) {\n\t\n\t        this.pX = input.deltaX;\n\t        this.pY = input.deltaY;\n\t\n\t        var direction = directionStr(input.direction);\n\t\n\t        if (direction) {\n\t            input.additionalEvent = this.options.event + direction;\n\t        }\n\t        this._super.emit.call(this, input);\n\t    }\n\t});\n\t\n\t/**\n\t * Pinch\n\t * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n\t * @constructor\n\t * @extends AttrRecognizer\n\t */\n\tfunction PinchRecognizer() {\n\t    AttrRecognizer.apply(this, arguments);\n\t}\n\t\n\tinherit(PinchRecognizer, AttrRecognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof PinchRecognizer\n\t     */\n\t    defaults: {\n\t        event: 'pinch',\n\t        threshold: 0,\n\t        pointers: 2\n\t    },\n\t\n\t    getTouchAction: function() {\n\t        return [TOUCH_ACTION_NONE];\n\t    },\n\t\n\t    attrTest: function(input) {\n\t        return this._super.attrTest.call(this, input) &&\n\t            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n\t    },\n\t\n\t    emit: function(input) {\n\t        if (input.scale !== 1) {\n\t            var inOut = input.scale < 1 ? 'in' : 'out';\n\t            input.additionalEvent = this.options.event + inOut;\n\t        }\n\t        this._super.emit.call(this, input);\n\t    }\n\t});\n\t\n\t/**\n\t * Press\n\t * Recognized when the pointer is down for x ms without any movement.\n\t * @constructor\n\t * @extends Recognizer\n\t */\n\tfunction PressRecognizer() {\n\t    Recognizer.apply(this, arguments);\n\t\n\t    this._timer = null;\n\t    this._input = null;\n\t}\n\t\n\tinherit(PressRecognizer, Recognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof PressRecognizer\n\t     */\n\t    defaults: {\n\t        event: 'press',\n\t        pointers: 1,\n\t        time: 251, // minimal time of the pointer to be pressed\n\t        threshold: 9 // a minimal movement is ok, but keep it low\n\t    },\n\t\n\t    getTouchAction: function() {\n\t        return [TOUCH_ACTION_AUTO];\n\t    },\n\t\n\t    process: function(input) {\n\t        var options = this.options;\n\t        var validPointers = input.pointers.length === options.pointers;\n\t        var validMovement = input.distance < options.threshold;\n\t        var validTime = input.deltaTime > options.time;\n\t\n\t        this._input = input;\n\t\n\t        // we only allow little movement\n\t        // and we've reached an end event, so a tap is possible\n\t        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n\t            this.reset();\n\t        } else if (input.eventType & INPUT_START) {\n\t            this.reset();\n\t            this._timer = setTimeoutContext(function() {\n\t                this.state = STATE_RECOGNIZED;\n\t                this.tryEmit();\n\t            }, options.time, this);\n\t        } else if (input.eventType & INPUT_END) {\n\t            return STATE_RECOGNIZED;\n\t        }\n\t        return STATE_FAILED;\n\t    },\n\t\n\t    reset: function() {\n\t        clearTimeout(this._timer);\n\t    },\n\t\n\t    emit: function(input) {\n\t        if (this.state !== STATE_RECOGNIZED) {\n\t            return;\n\t        }\n\t\n\t        if (input && (input.eventType & INPUT_END)) {\n\t            this.manager.emit(this.options.event + 'up', input);\n\t        } else {\n\t            this._input.timeStamp = now();\n\t            this.manager.emit(this.options.event, this._input);\n\t        }\n\t    }\n\t});\n\t\n\t/**\n\t * Rotate\n\t * Recognized when two or more pointer are moving in a circular motion.\n\t * @constructor\n\t * @extends AttrRecognizer\n\t */\n\tfunction RotateRecognizer() {\n\t    AttrRecognizer.apply(this, arguments);\n\t}\n\t\n\tinherit(RotateRecognizer, AttrRecognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof RotateRecognizer\n\t     */\n\t    defaults: {\n\t        event: 'rotate',\n\t        threshold: 0,\n\t        pointers: 2\n\t    },\n\t\n\t    getTouchAction: function() {\n\t        return [TOUCH_ACTION_NONE];\n\t    },\n\t\n\t    attrTest: function(input) {\n\t        return this._super.attrTest.call(this, input) &&\n\t            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n\t    }\n\t});\n\t\n\t/**\n\t * Swipe\n\t * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n\t * @constructor\n\t * @extends AttrRecognizer\n\t */\n\tfunction SwipeRecognizer() {\n\t    AttrRecognizer.apply(this, arguments);\n\t}\n\t\n\tinherit(SwipeRecognizer, AttrRecognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof SwipeRecognizer\n\t     */\n\t    defaults: {\n\t        event: 'swipe',\n\t        threshold: 10,\n\t        velocity: 0.3,\n\t        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n\t        pointers: 1\n\t    },\n\t\n\t    getTouchAction: function() {\n\t        return PanRecognizer.prototype.getTouchAction.call(this);\n\t    },\n\t\n\t    attrTest: function(input) {\n\t        var direction = this.options.direction;\n\t        var velocity;\n\t\n\t        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n\t            velocity = input.overallVelocity;\n\t        } else if (direction & DIRECTION_HORIZONTAL) {\n\t            velocity = input.overallVelocityX;\n\t        } else if (direction & DIRECTION_VERTICAL) {\n\t            velocity = input.overallVelocityY;\n\t        }\n\t\n\t        return this._super.attrTest.call(this, input) &&\n\t            direction & input.offsetDirection &&\n\t            input.distance > this.options.threshold &&\n\t            input.maxPointers == this.options.pointers &&\n\t            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n\t    },\n\t\n\t    emit: function(input) {\n\t        var direction = directionStr(input.offsetDirection);\n\t        if (direction) {\n\t            this.manager.emit(this.options.event + direction, input);\n\t        }\n\t\n\t        this.manager.emit(this.options.event, input);\n\t    }\n\t});\n\t\n\t/**\n\t * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n\t * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n\t * a single tap.\n\t *\n\t * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n\t * multi-taps being recognized.\n\t * @constructor\n\t * @extends Recognizer\n\t */\n\tfunction TapRecognizer() {\n\t    Recognizer.apply(this, arguments);\n\t\n\t    // previous time and center,\n\t    // used for tap counting\n\t    this.pTime = false;\n\t    this.pCenter = false;\n\t\n\t    this._timer = null;\n\t    this._input = null;\n\t    this.count = 0;\n\t}\n\t\n\tinherit(TapRecognizer, Recognizer, {\n\t    /**\n\t     * @namespace\n\t     * @memberof PinchRecognizer\n\t     */\n\t    defaults: {\n\t        event: 'tap',\n\t        pointers: 1,\n\t        taps: 1,\n\t        interval: 300, // max time between the multi-tap taps\n\t        time: 250, // max time of the pointer to be down (like finger on the screen)\n\t        threshold: 9, // a minimal movement is ok, but keep it low\n\t        posThreshold: 10 // a multi-tap can be a bit off the initial position\n\t    },\n\t\n\t    getTouchAction: function() {\n\t        return [TOUCH_ACTION_MANIPULATION];\n\t    },\n\t\n\t    process: function(input) {\n\t        var options = this.options;\n\t\n\t        var validPointers = input.pointers.length === options.pointers;\n\t        var validMovement = input.distance < options.threshold;\n\t        var validTouchTime = input.deltaTime < options.time;\n\t\n\t        this.reset();\n\t\n\t        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n\t            return this.failTimeout();\n\t        }\n\t\n\t        // we only allow little movement\n\t        // and we've reached an end event, so a tap is possible\n\t        if (validMovement && validTouchTime && validPointers) {\n\t            if (input.eventType != INPUT_END) {\n\t                return this.failTimeout();\n\t            }\n\t\n\t            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n\t            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\t\n\t            this.pTime = input.timeStamp;\n\t            this.pCenter = input.center;\n\t\n\t            if (!validMultiTap || !validInterval) {\n\t                this.count = 1;\n\t            } else {\n\t                this.count += 1;\n\t            }\n\t\n\t            this._input = input;\n\t\n\t            // if tap count matches we have recognized it,\n\t            // else it has began recognizing...\n\t            var tapCount = this.count % options.taps;\n\t            if (tapCount === 0) {\n\t                // no failing requirements, immediately trigger the tap event\n\t                // or wait as long as the multitap interval to trigger\n\t                if (!this.hasRequireFailures()) {\n\t                    return STATE_RECOGNIZED;\n\t                } else {\n\t                    this._timer = setTimeoutContext(function() {\n\t                        this.state = STATE_RECOGNIZED;\n\t                        this.tryEmit();\n\t                    }, options.interval, this);\n\t                    return STATE_BEGAN;\n\t                }\n\t            }\n\t        }\n\t        return STATE_FAILED;\n\t    },\n\t\n\t    failTimeout: function() {\n\t        this._timer = setTimeoutContext(function() {\n\t            this.state = STATE_FAILED;\n\t        }, this.options.interval, this);\n\t        return STATE_FAILED;\n\t    },\n\t\n\t    reset: function() {\n\t        clearTimeout(this._timer);\n\t    },\n\t\n\t    emit: function() {\n\t        if (this.state == STATE_RECOGNIZED) {\n\t            this._input.tapCount = this.count;\n\t            this.manager.emit(this.options.event, this._input);\n\t        }\n\t    }\n\t});\n\t\n\t/**\n\t * Simple way to create a manager with a default set of recognizers.\n\t * @param {HTMLElement} element\n\t * @param {Object} [options]\n\t * @constructor\n\t */\n\tfunction Hammer(element, options) {\n\t    options = options || {};\n\t    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n\t    return new Manager(element, options);\n\t}\n\t\n\t/**\n\t * @const {string}\n\t */\n\tHammer.VERSION = '2.0.7';\n\t\n\t/**\n\t * default settings\n\t * @namespace\n\t */\n\tHammer.defaults = {\n\t    /**\n\t     * set if DOM events are being triggered.\n\t     * But this is slower and unused by simple implementations, so disabled by default.\n\t     * @type {Boolean}\n\t     * @default false\n\t     */\n\t    domEvents: false,\n\t\n\t    /**\n\t     * The value for the touchAction property/fallback.\n\t     * When set to `compute` it will magically set the correct value based on the added recognizers.\n\t     * @type {String}\n\t     * @default compute\n\t     */\n\t    touchAction: TOUCH_ACTION_COMPUTE,\n\t\n\t    /**\n\t     * @type {Boolean}\n\t     * @default true\n\t     */\n\t    enable: true,\n\t\n\t    /**\n\t     * EXPERIMENTAL FEATURE -- can be removed/changed\n\t     * Change the parent input target element.\n\t     * If Null, then it is being set the to main element.\n\t     * @type {Null|EventTarget}\n\t     * @default null\n\t     */\n\t    inputTarget: null,\n\t\n\t    /**\n\t     * force an input class\n\t     * @type {Null|Function}\n\t     * @default null\n\t     */\n\t    inputClass: null,\n\t\n\t    /**\n\t     * Default recognizer setup when calling `Hammer()`\n\t     * When creating a new Manager these will be skipped.\n\t     * @type {Array}\n\t     */\n\t    preset: [\n\t        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n\t        [RotateRecognizer, {enable: false}],\n\t        [PinchRecognizer, {enable: false}, ['rotate']],\n\t        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n\t        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n\t        [TapRecognizer],\n\t        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n\t        [PressRecognizer]\n\t    ],\n\t\n\t    /**\n\t     * Some CSS properties can be used to improve the working of Hammer.\n\t     * Add them to this method and they will be set when creating a new Manager.\n\t     * @namespace\n\t     */\n\t    cssProps: {\n\t        /**\n\t         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n\t         * @type {String}\n\t         * @default 'none'\n\t         */\n\t        userSelect: 'none',\n\t\n\t        /**\n\t         * Disable the Windows Phone grippers when pressing an element.\n\t         * @type {String}\n\t         * @default 'none'\n\t         */\n\t        touchSelect: 'none',\n\t\n\t        /**\n\t         * Disables the default callout shown when you touch and hold a touch target.\n\t         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n\t         * a callout containing information about the link. This property allows you to disable that callout.\n\t         * @type {String}\n\t         * @default 'none'\n\t         */\n\t        touchCallout: 'none',\n\t\n\t        /**\n\t         * Specifies whether zooming is enabled. Used by IE10>\n\t         * @type {String}\n\t         * @default 'none'\n\t         */\n\t        contentZooming: 'none',\n\t\n\t        /**\n\t         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n\t         * @type {String}\n\t         * @default 'none'\n\t         */\n\t        userDrag: 'none',\n\t\n\t        /**\n\t         * Overrides the highlight color shown when the user taps a link or a JavaScript\n\t         * clickable element in iOS. This property obeys the alpha value, if specified.\n\t         * @type {String}\n\t         * @default 'rgba(0,0,0,0)'\n\t         */\n\t        tapHighlightColor: 'rgba(0,0,0,0)'\n\t    }\n\t};\n\t\n\tvar STOP = 1;\n\tvar FORCED_STOP = 2;\n\t\n\t/**\n\t * Manager\n\t * @param {HTMLElement} element\n\t * @param {Object} [options]\n\t * @constructor\n\t */\n\tfunction Manager(element, options) {\n\t    this.options = assign({}, Hammer.defaults, options || {});\n\t\n\t    this.options.inputTarget = this.options.inputTarget || element;\n\t\n\t    this.handlers = {};\n\t    this.session = {};\n\t    this.recognizers = [];\n\t    this.oldCssProps = {};\n\t\n\t    this.element = element;\n\t    this.input = createInputInstance(this);\n\t    this.touchAction = new TouchAction(this, this.options.touchAction);\n\t\n\t    toggleCssProps(this, true);\n\t\n\t    each(this.options.recognizers, function(item) {\n\t        var recognizer = this.add(new (item[0])(item[1]));\n\t        item[2] && recognizer.recognizeWith(item[2]);\n\t        item[3] && recognizer.requireFailure(item[3]);\n\t    }, this);\n\t}\n\t\n\tManager.prototype = {\n\t    /**\n\t     * set options\n\t     * @param {Object} options\n\t     * @returns {Manager}\n\t     */\n\t    set: function(options) {\n\t        assign(this.options, options);\n\t\n\t        // Options that need a little more setup\n\t        if (options.touchAction) {\n\t            this.touchAction.update();\n\t        }\n\t        if (options.inputTarget) {\n\t            // Clean up existing event listeners and reinitialize\n\t            this.input.destroy();\n\t            this.input.target = options.inputTarget;\n\t            this.input.init();\n\t        }\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * stop recognizing for this session.\n\t     * This session will be discarded, when a new [input]start event is fired.\n\t     * When forced, the recognizer cycle is stopped immediately.\n\t     * @param {Boolean} [force]\n\t     */\n\t    stop: function(force) {\n\t        this.session.stopped = force ? FORCED_STOP : STOP;\n\t    },\n\t\n\t    /**\n\t     * run the recognizers!\n\t     * called by the inputHandler function on every movement of the pointers (touches)\n\t     * it walks through all the recognizers and tries to detect the gesture that is being made\n\t     * @param {Object} inputData\n\t     */\n\t    recognize: function(inputData) {\n\t        var session = this.session;\n\t        if (session.stopped) {\n\t            return;\n\t        }\n\t\n\t        // run the touch-action polyfill\n\t        this.touchAction.preventDefaults(inputData);\n\t\n\t        var recognizer;\n\t        var recognizers = this.recognizers;\n\t\n\t        // this holds the recognizer that is being recognized.\n\t        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n\t        // if no recognizer is detecting a thing, it is set to `null`\n\t        var curRecognizer = session.curRecognizer;\n\t\n\t        // reset when the last recognizer is recognized\n\t        // or when we're in a new session\n\t        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n\t            curRecognizer = session.curRecognizer = null;\n\t        }\n\t\n\t        var i = 0;\n\t        while (i < recognizers.length) {\n\t            recognizer = recognizers[i];\n\t\n\t            // find out if we are allowed try to recognize the input for this one.\n\t            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n\t            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n\t            //      that is being recognized.\n\t            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n\t            //      this can be setup with the `recognizeWith()` method on the recognizer.\n\t            if (session.stopped !== FORCED_STOP && ( // 1\n\t                    !curRecognizer || recognizer == curRecognizer || // 2\n\t                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n\t                recognizer.recognize(inputData);\n\t            } else {\n\t                recognizer.reset();\n\t            }\n\t\n\t            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n\t            // current active recognizer. but only if we don't already have an active recognizer\n\t            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n\t                curRecognizer = session.curRecognizer = recognizer;\n\t            }\n\t            i++;\n\t        }\n\t    },\n\t\n\t    /**\n\t     * get a recognizer by its event name.\n\t     * @param {Recognizer|String} recognizer\n\t     * @returns {Recognizer|Null}\n\t     */\n\t    get: function(recognizer) {\n\t        if (recognizer instanceof Recognizer) {\n\t            return recognizer;\n\t        }\n\t\n\t        var recognizers = this.recognizers;\n\t        for (var i = 0; i < recognizers.length; i++) {\n\t            if (recognizers[i].options.event == recognizer) {\n\t                return recognizers[i];\n\t            }\n\t        }\n\t        return null;\n\t    },\n\t\n\t    /**\n\t     * add a recognizer to the manager\n\t     * existing recognizers with the same event name will be removed\n\t     * @param {Recognizer} recognizer\n\t     * @returns {Recognizer|Manager}\n\t     */\n\t    add: function(recognizer) {\n\t        if (invokeArrayArg(recognizer, 'add', this)) {\n\t            return this;\n\t        }\n\t\n\t        // remove existing\n\t        var existing = this.get(recognizer.options.event);\n\t        if (existing) {\n\t            this.remove(existing);\n\t        }\n\t\n\t        this.recognizers.push(recognizer);\n\t        recognizer.manager = this;\n\t\n\t        this.touchAction.update();\n\t        return recognizer;\n\t    },\n\t\n\t    /**\n\t     * remove a recognizer by name or instance\n\t     * @param {Recognizer|String} recognizer\n\t     * @returns {Manager}\n\t     */\n\t    remove: function(recognizer) {\n\t        if (invokeArrayArg(recognizer, 'remove', this)) {\n\t            return this;\n\t        }\n\t\n\t        recognizer = this.get(recognizer);\n\t\n\t        // let's make sure this recognizer exists\n\t        if (recognizer) {\n\t            var recognizers = this.recognizers;\n\t            var index = inArray(recognizers, recognizer);\n\t\n\t            if (index !== -1) {\n\t                recognizers.splice(index, 1);\n\t                this.touchAction.update();\n\t            }\n\t        }\n\t\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * bind event\n\t     * @param {String} events\n\t     * @param {Function} handler\n\t     * @returns {EventEmitter} this\n\t     */\n\t    on: function(events, handler) {\n\t        if (events === undefined) {\n\t            return;\n\t        }\n\t        if (handler === undefined) {\n\t            return;\n\t        }\n\t\n\t        var handlers = this.handlers;\n\t        each(splitStr(events), function(event) {\n\t            handlers[event] = handlers[event] || [];\n\t            handlers[event].push(handler);\n\t        });\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * unbind event, leave emit blank to remove all handlers\n\t     * @param {String} events\n\t     * @param {Function} [handler]\n\t     * @returns {EventEmitter} this\n\t     */\n\t    off: function(events, handler) {\n\t        if (events === undefined) {\n\t            return;\n\t        }\n\t\n\t        var handlers = this.handlers;\n\t        each(splitStr(events), function(event) {\n\t            if (!handler) {\n\t                delete handlers[event];\n\t            } else {\n\t                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n\t            }\n\t        });\n\t        return this;\n\t    },\n\t\n\t    /**\n\t     * emit event to the listeners\n\t     * @param {String} event\n\t     * @param {Object} data\n\t     */\n\t    emit: function(event, data) {\n\t        // we also want to trigger dom events\n\t        if (this.options.domEvents) {\n\t            triggerDomEvent(event, data);\n\t        }\n\t\n\t        // no handlers, so skip it all\n\t        var handlers = this.handlers[event] && this.handlers[event].slice();\n\t        if (!handlers || !handlers.length) {\n\t            return;\n\t        }\n\t\n\t        data.type = event;\n\t        data.preventDefault = function() {\n\t            data.srcEvent.preventDefault();\n\t        };\n\t\n\t        var i = 0;\n\t        while (i < handlers.length) {\n\t            handlers[i](data);\n\t            i++;\n\t        }\n\t    },\n\t\n\t    /**\n\t     * destroy the manager and unbinds all events\n\t     * it doesn't unbind dom events, that is the user own responsibility\n\t     */\n\t    destroy: function() {\n\t        this.element && toggleCssProps(this, false);\n\t\n\t        this.handlers = {};\n\t        this.session = {};\n\t        this.input.destroy();\n\t        this.element = null;\n\t    }\n\t};\n\t\n\t/**\n\t * add/remove the css properties as defined in manager.options.cssProps\n\t * @param {Manager} manager\n\t * @param {Boolean} add\n\t */\n\tfunction toggleCssProps(manager, add) {\n\t    var element = manager.element;\n\t    if (!element.style) {\n\t        return;\n\t    }\n\t    var prop;\n\t    each(manager.options.cssProps, function(value, name) {\n\t        prop = prefixed(element.style, name);\n\t        if (add) {\n\t            manager.oldCssProps[prop] = element.style[prop];\n\t            element.style[prop] = value;\n\t        } else {\n\t            element.style[prop] = manager.oldCssProps[prop] || '';\n\t        }\n\t    });\n\t    if (!add) {\n\t        manager.oldCssProps = {};\n\t    }\n\t}\n\t\n\t/**\n\t * trigger dom event\n\t * @param {String} event\n\t * @param {Object} data\n\t */\n\tfunction triggerDomEvent(event, data) {\n\t    var gestureEvent = document.createEvent('Event');\n\t    gestureEvent.initEvent(event, true, true);\n\t    gestureEvent.gesture = data;\n\t    data.target.dispatchEvent(gestureEvent);\n\t}\n\t\n\tassign(Hammer, {\n\t    INPUT_START: INPUT_START,\n\t    INPUT_MOVE: INPUT_MOVE,\n\t    INPUT_END: INPUT_END,\n\t    INPUT_CANCEL: INPUT_CANCEL,\n\t\n\t    STATE_POSSIBLE: STATE_POSSIBLE,\n\t    STATE_BEGAN: STATE_BEGAN,\n\t    STATE_CHANGED: STATE_CHANGED,\n\t    STATE_ENDED: STATE_ENDED,\n\t    STATE_RECOGNIZED: STATE_RECOGNIZED,\n\t    STATE_CANCELLED: STATE_CANCELLED,\n\t    STATE_FAILED: STATE_FAILED,\n\t\n\t    DIRECTION_NONE: DIRECTION_NONE,\n\t    DIRECTION_LEFT: DIRECTION_LEFT,\n\t    DIRECTION_RIGHT: DIRECTION_RIGHT,\n\t    DIRECTION_UP: DIRECTION_UP,\n\t    DIRECTION_DOWN: DIRECTION_DOWN,\n\t    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n\t    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n\t    DIRECTION_ALL: DIRECTION_ALL,\n\t\n\t    Manager: Manager,\n\t    Input: Input,\n\t    TouchAction: TouchAction,\n\t\n\t    TouchInput: TouchInput,\n\t    MouseInput: MouseInput,\n\t    PointerEventInput: PointerEventInput,\n\t    TouchMouseInput: TouchMouseInput,\n\t    SingleTouchInput: SingleTouchInput,\n\t\n\t    Recognizer: Recognizer,\n\t    AttrRecognizer: AttrRecognizer,\n\t    Tap: TapRecognizer,\n\t    Pan: PanRecognizer,\n\t    Swipe: SwipeRecognizer,\n\t    Pinch: PinchRecognizer,\n\t    Rotate: RotateRecognizer,\n\t    Press: PressRecognizer,\n\t\n\t    on: addEventListeners,\n\t    off: removeEventListeners,\n\t    each: each,\n\t    merge: merge,\n\t    extend: extend,\n\t    assign: assign,\n\t    inherit: inherit,\n\t    bindFn: bindFn,\n\t    prefixed: prefixed\n\t});\n\t\n\t// this prevents errors when Hammer is loaded in the presence of an AMD\n\t//  style loader but by script tag, not by the loader.\n\tvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\n\tfreeGlobal.Hammer = Hammer;\n\t\n\tif (true) {\n\t    !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {\n\t        return Hammer;\n\t    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else if (typeof module != 'undefined' && module.exports) {\n\t    module.exports = Hammer;\n\t} else {\n\t    window[exportName] = Hammer;\n\t}\n\t\n\t})(window, document, 'Hammer');\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.PRODUCTION = exports.INIT_DELAY = exports.OPTIONS = undefined;\n\t\n\tvar _md = __webpack_require__(5);\n\t\n\tvar _md2 = _interopRequireDefault(_md);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tvar domain = 'infobolsa.es';\n\tvar server = 'wtst.infobolsa.es';\n\tvar session = 'COLPISAMOD';\n\tvar hash = 'NM6H52DKy2FrWtsqralz2jq5TZ8LVsFU';\n\tvar provider = 'BANKIA';\n\tvar interactiveChart = 'https://ifbwtsptest.infobolsa.es';\n\t\n\tvar login = Object.freeze({\n\t  servidor: server,\n\t  idSesion: _getSessionKey()\n\t});\n\t\n\tvar OPTIONS = exports.OPTIONS = {\n\t  debug: 0,\n\t  login: login,\n\t  config: {\n\t    domain: domain,\n\t    interactiveChart: interactiveChart\n\t  },\n\t  widgets: []\n\t};\n\t\n\tvar INIT_DELAY = exports.INIT_DELAY = 4000;\n\tvar PRODUCTION = exports.PRODUCTION = 'pro';\n\t\n\t/* Private */\n\t\n\tfunction _getSessionKey() {\n\t  var timestamp = Math.floor(Date.now());\n\t  var key = provider + '~' + timestamp + '~' + session + '~' + hash;\n\t  var passhash = (0, _md2.default)(key).toString();\n\t  return provider + '_' + timestamp + '_' + session + '_' + passhash.toUpperCase();\n\t}\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t;(function (root, factory) {\n\t\tif (true) {\n\t\t\t// CommonJS\n\t\t\tmodule.exports = exports = factory(__webpack_require__(6));\n\t\t}\n\t\telse if (typeof define === \"function\" && define.amd) {\n\t\t\t// AMD\n\t\t\tdefine([\"./core\"], factory);\n\t\t}\n\t\telse {\n\t\t\t// Global (browser)\n\t\t\tfactory(root.CryptoJS);\n\t\t}\n\t}(this, function (CryptoJS) {\n\t\n\t\t(function (Math) {\n\t\t    // Shortcuts\n\t\t    var C = CryptoJS;\n\t\t    var C_lib = C.lib;\n\t\t    var WordArray = C_lib.WordArray;\n\t\t    var Hasher = C_lib.Hasher;\n\t\t    var C_algo = C.algo;\n\t\n\t\t    // Constants table\n\t\t    var T = [];\n\t\n\t\t    // Compute constants\n\t\t    (function () {\n\t\t        for (var i = 0; i < 64; i++) {\n\t\t            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n\t\t        }\n\t\t    }());\n\t\n\t\t    /**\n\t\t     * MD5 hash algorithm.\n\t\t     */\n\t\t    var MD5 = C_algo.MD5 = Hasher.extend({\n\t\t        _doReset: function () {\n\t\t            this._hash = new WordArray.init([\n\t\t                0x67452301, 0xefcdab89,\n\t\t                0x98badcfe, 0x10325476\n\t\t            ]);\n\t\t        },\n\t\n\t\t        _doProcessBlock: function (M, offset) {\n\t\t            // Swap endian\n\t\t            for (var i = 0; i < 16; i++) {\n\t\t                // Shortcuts\n\t\t                var offset_i = offset + i;\n\t\t                var M_offset_i = M[offset_i];\n\t\n\t\t                M[offset_i] = (\n\t\t                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |\n\t\t                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)\n\t\t                );\n\t\t            }\n\t\n\t\t            // Shortcuts\n\t\t            var H = this._hash.words;\n\t\n\t\t            var M_offset_0  = M[offset + 0];\n\t\t            var M_offset_1  = M[offset + 1];\n\t\t            var M_offset_2  = M[offset + 2];\n\t\t            var M_offset_3  = M[offset + 3];\n\t\t            var M_offset_4  = M[offset + 4];\n\t\t            var M_offset_5  = M[offset + 5];\n\t\t            var M_offset_6  = M[offset + 6];\n\t\t            var M_offset_7  = M[offset + 7];\n\t\t            var M_offset_8  = M[offset + 8];\n\t\t            var M_offset_9  = M[offset + 9];\n\t\t            var M_offset_10 = M[offset + 10];\n\t\t            var M_offset_11 = M[offset + 11];\n\t\t            var M_offset_12 = M[offset + 12];\n\t\t            var M_offset_13 = M[offset + 13];\n\t\t            var M_offset_14 = M[offset + 14];\n\t\t            var M_offset_15 = M[offset + 15];\n\t\n\t\t            // Working varialbes\n\t\t            var a = H[0];\n\t\t            var b = H[1];\n\t\t            var c = H[2];\n\t\t            var d = H[3];\n\t\n\t\t            // Computation\n\t\t            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);\n\t\t            d = FF(d, a, b, c, M_offset_1,  12, T[1]);\n\t\t            c = FF(c, d, a, b, M_offset_2,  17, T[2]);\n\t\t            b = FF(b, c, d, a, M_offset_3,  22, T[3]);\n\t\t            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);\n\t\t            d = FF(d, a, b, c, M_offset_5,  12, T[5]);\n\t\t            c = FF(c, d, a, b, M_offset_6,  17, T[6]);\n\t\t            b = FF(b, c, d, a, M_offset_7,  22, T[7]);\n\t\t            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);\n\t\t            d = FF(d, a, b, c, M_offset_9,  12, T[9]);\n\t\t            c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n\t\t            b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n\t\t            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);\n\t\t            d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n\t\t            c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n\t\t            b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\t\n\t\t            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);\n\t\t            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);\n\t\t            c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n\t\t            b = GG(b, c, d, a, M_offset_0,  20, T[19]);\n\t\t            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);\n\t\t            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);\n\t\t            c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n\t\t            b = GG(b, c, d, a, M_offset_4,  20, T[23]);\n\t\t            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);\n\t\t            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);\n\t\t            c = GG(c, d, a, b, M_offset_3,  14, T[26]);\n\t\t            b = GG(b, c, d, a, M_offset_8,  20, T[27]);\n\t\t            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);\n\t\t            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);\n\t\t            c = GG(c, d, a, b, M_offset_7,  14, T[30]);\n\t\t            b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\t\n\t\t            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);\n\t\t            d = HH(d, a, b, c, M_offset_8,  11, T[33]);\n\t\t            c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n\t\t            b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n\t\t            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);\n\t\t            d = HH(d, a, b, c, M_offset_4,  11, T[37]);\n\t\t            c = HH(c, d, a, b, M_offset_7,  16, T[38]);\n\t\t            b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n\t\t            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);\n\t\t            d = HH(d, a, b, c, M_offset_0,  11, T[41]);\n\t\t            c = HH(c, d, a, b, M_offset_3,  16, T[42]);\n\t\t            b = HH(b, c, d, a, M_offset_6,  23, T[43]);\n\t\t            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);\n\t\t            d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n\t\t            c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n\t\t            b = HH(b, c, d, a, M_offset_2,  23, T[47]);\n\t\n\t\t            a = II(a, b, c, d, M_offset_0,  6,  T[48]);\n\t\t            d = II(d, a, b, c, M_offset_7,  10, T[49]);\n\t\t            c = II(c, d, a, b, M_offset_14, 15, T[50]);\n\t\t            b = II(b, c, d, a, M_offset_5,  21, T[51]);\n\t\t            a = II(a, b, c, d, M_offset_12, 6,  T[52]);\n\t\t            d = II(d, a, b, c, M_offset_3,  10, T[53]);\n\t\t            c = II(c, d, a, b, M_offset_10, 15, T[54]);\n\t\t            b = II(b, c, d, a, M_offset_1,  21, T[55]);\n\t\t            a = II(a, b, c, d, M_offset_8,  6,  T[56]);\n\t\t            d = II(d, a, b, c, M_offset_15, 10, T[57]);\n\t\t            c = II(c, d, a, b, M_offset_6,  15, T[58]);\n\t\t            b = II(b, c, d, a, M_offset_13, 21, T[59]);\n\t\t            a = II(a, b, c, d, M_offset_4,  6,  T[60]);\n\t\t            d = II(d, a, b, c, M_offset_11, 10, T[61]);\n\t\t            c = II(c, d, a, b, M_offset_2,  15, T[62]);\n\t\t            b = II(b, c, d, a, M_offset_9,  21, T[63]);\n\t\n\t\t            // Intermediate hash value\n\t\t            H[0] = (H[0] + a) | 0;\n\t\t            H[1] = (H[1] + b) | 0;\n\t\t            H[2] = (H[2] + c) | 0;\n\t\t            H[3] = (H[3] + d) | 0;\n\t\t        },\n\t\n\t\t        _doFinalize: function () {\n\t\t            // Shortcuts\n\t\t            var data = this._data;\n\t\t            var dataWords = data.words;\n\t\n\t\t            var nBitsTotal = this._nDataBytes * 8;\n\t\t            var nBitsLeft = data.sigBytes * 8;\n\t\n\t\t            // Add padding\n\t\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\t\n\t\t            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n\t\t            var nBitsTotalL = nBitsTotal;\n\t\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n\t\t                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\n\t\t                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)\n\t\t            );\n\t\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n\t\t                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\n\t\t                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)\n\t\t            );\n\t\n\t\t            data.sigBytes = (dataWords.length + 1) * 4;\n\t\n\t\t            // Hash final blocks\n\t\t            this._process();\n\t\n\t\t            // Shortcuts\n\t\t            var hash = this._hash;\n\t\t            var H = hash.words;\n\t\n\t\t            // Swap endian\n\t\t            for (var i = 0; i < 4; i++) {\n\t\t                // Shortcut\n\t\t                var H_i = H[i];\n\t\n\t\t                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |\n\t\t                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);\n\t\t            }\n\t\n\t\t            // Return final computed hash\n\t\t            return hash;\n\t\t        },\n\t\n\t\t        clone: function () {\n\t\t            var clone = Hasher.clone.call(this);\n\t\t            clone._hash = this._hash.clone();\n\t\n\t\t            return clone;\n\t\t        }\n\t\t    });\n\t\n\t\t    function FF(a, b, c, d, x, s, t) {\n\t\t        var n = a + ((b & c) | (~b & d)) + x + t;\n\t\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t\t    }\n\t\n\t\t    function GG(a, b, c, d, x, s, t) {\n\t\t        var n = a + ((b & d) | (c & ~d)) + x + t;\n\t\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t\t    }\n\t\n\t\t    function HH(a, b, c, d, x, s, t) {\n\t\t        var n = a + (b ^ c ^ d) + x + t;\n\t\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t\t    }\n\t\n\t\t    function II(a, b, c, d, x, s, t) {\n\t\t        var n = a + (c ^ (b | ~d)) + x + t;\n\t\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t\t    }\n\t\n\t\t    /**\n\t\t     * Shortcut function to the hasher's object interface.\n\t\t     *\n\t\t     * @param {WordArray|string} message The message to hash.\n\t\t     *\n\t\t     * @return {WordArray} The hash.\n\t\t     *\n\t\t     * @static\n\t\t     *\n\t\t     * @example\n\t\t     *\n\t\t     *     var hash = CryptoJS.MD5('message');\n\t\t     *     var hash = CryptoJS.MD5(wordArray);\n\t\t     */\n\t\t    C.MD5 = Hasher._createHelper(MD5);\n\t\n\t\t    /**\n\t\t     * Shortcut function to the HMAC's object interface.\n\t\t     *\n\t\t     * @param {WordArray|string} message The message to hash.\n\t\t     * @param {WordArray|string} key The secret key.\n\t\t     *\n\t\t     * @return {WordArray} The HMAC.\n\t\t     *\n\t\t     * @static\n\t\t     *\n\t\t     * @example\n\t\t     *\n\t\t     *     var hmac = CryptoJS.HmacMD5(message, key);\n\t\t     */\n\t\t    C.HmacMD5 = Hasher._createHmacHelper(MD5);\n\t\t}(Math));\n\t\n\t\n\t\treturn CryptoJS.MD5;\n\t\n\t}));\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t;(function (root, factory) {\n\t\tif (true) {\n\t\t\t// CommonJS\n\t\t\tmodule.exports = exports = factory();\n\t\t}\n\t\telse if (typeof define === \"function\" && define.amd) {\n\t\t\t// AMD\n\t\t\tdefine([], factory);\n\t\t}\n\t\telse {\n\t\t\t// Global (browser)\n\t\t\troot.CryptoJS = factory();\n\t\t}\n\t}(this, function () {\n\t\n\t\t/**\n\t\t * CryptoJS core components.\n\t\t */\n\t\tvar CryptoJS = CryptoJS || (function (Math, undefined) {\n\t\t    /*\n\t\t     * Local polyfil of Object.create\n\t\t     */\n\t\t    var create = Object.create || (function () {\n\t\t        function F() {};\n\t\n\t\t        return function (obj) {\n\t\t            var subtype;\n\t\n\t\t            F.prototype = obj;\n\t\n\t\t            subtype = new F();\n\t\n\t\t            F.prototype = null;\n\t\n\t\t            return subtype;\n\t\t        };\n\t\t    }())\n\t\n\t\t    /**\n\t\t     * CryptoJS namespace.\n\t\t     */\n\t\t    var C = {};\n\t\n\t\t    /**\n\t\t     * Library namespace.\n\t\t     */\n\t\t    var C_lib = C.lib = {};\n\t\n\t\t    /**\n\t\t     * Base object for prototypal inheritance.\n\t\t     */\n\t\t    var Base = C_lib.Base = (function () {\n\t\n\t\n\t\t        return {\n\t\t            /**\n\t\t             * Creates a new object that inherits from this object.\n\t\t             *\n\t\t             * @param {Object} overrides Properties to copy into the new object.\n\t\t             *\n\t\t             * @return {Object} The new object.\n\t\t             *\n\t\t             * @static\n\t\t             *\n\t\t             * @example\n\t\t             *\n\t\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t\t             *         field: 'value',\n\t\t             *\n\t\t             *         method: function () {\n\t\t             *         }\n\t\t             *     });\n\t\t             */\n\t\t            extend: function (overrides) {\n\t\t                // Spawn\n\t\t                var subtype = create(this);\n\t\n\t\t                // Augment\n\t\t                if (overrides) {\n\t\t                    subtype.mixIn(overrides);\n\t\t                }\n\t\n\t\t                // Create default initializer\n\t\t                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n\t\t                    subtype.init = function () {\n\t\t                        subtype.$super.init.apply(this, arguments);\n\t\t                    };\n\t\t                }\n\t\n\t\t                // Initializer's prototype is the subtype object\n\t\t                subtype.init.prototype = subtype;\n\t\n\t\t                // Reference supertype\n\t\t                subtype.$super = this;\n\t\n\t\t                return subtype;\n\t\t            },\n\t\n\t\t            /**\n\t\t             * Extends this object and runs the init method.\n\t\t             * Arguments to create() will be passed to init().\n\t\t             *\n\t\t             * @return {Object} The new object.\n\t\t             *\n\t\t             * @static\n\t\t             *\n\t\t             * @example\n\t\t             *\n\t\t             *     var instance = MyType.create();\n\t\t             */\n\t\t            create: function () {\n\t\t                var instance = this.extend();\n\t\t                instance.init.apply(instance, arguments);\n\t\n\t\t                return instance;\n\t\t            },\n\t\n\t\t            /**\n\t\t             * Initializes a newly created object.\n\t\t             * Override this method to add some logic when your objects are created.\n\t\t             *\n\t\t             * @example\n\t\t             *\n\t\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t\t             *         init: function () {\n\t\t             *             // ...\n\t\t             *         }\n\t\t             *     });\n\t\t             */\n\t\t            init: function () {\n\t\t            },\n\t\n\t\t            /**\n\t\t             * Copies properties into this object.\n\t\t             *\n\t\t             * @param {Object} properties The properties to mix in.\n\t\t             *\n\t\t             * @example\n\t\t             *\n\t\t             *     MyType.mixIn({\n\t\t             *         field: 'value'\n\t\t             *     });\n\t\t             */\n\t\t            mixIn: function (properties) {\n\t\t                for (var propertyName in properties) {\n\t\t                    if (properties.hasOwnProperty(propertyName)) {\n\t\t                        this[propertyName] = properties[propertyName];\n\t\t                    }\n\t\t                }\n\t\n\t\t                // IE won't copy toString using the loop above\n\t\t                if (properties.hasOwnProperty('toString')) {\n\t\t                    this.toString = properties.toString;\n\t\t                }\n\t\t            },\n\t\n\t\t            /**\n\t\t             * Creates a copy of this object.\n\t\t             *\n\t\t             * @return {Object} The clone.\n\t\t             *\n\t\t             * @example\n\t\t             *\n\t\t             *     var clone = instance.clone();\n\t\t             */\n\t\t            clone: function () {\n\t\t                return this.init.prototype.extend(this);\n\t\t            }\n\t\t        };\n\t\t    }());\n\t\n\t\t    /**\n\t\t     * An array of 32-bit words.\n\t\t     *\n\t\t     * @property {Array} words The array of 32-bit words.\n\t\t     * @property {number} sigBytes The number of significant bytes in this word array.\n\t\t     */\n\t\t    var WordArray = C_lib.WordArray = Base.extend({\n\t\t        /**\n\t\t         * Initializes a newly created word array.\n\t\t         *\n\t\t         * @param {Array} words (Optional) An array of 32-bit words.\n\t\t         * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var wordArray = CryptoJS.lib.WordArray.create();\n\t\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n\t\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n\t\t         */\n\t\t        init: function (words, sigBytes) {\n\t\t            words = this.words = words || [];\n\t\n\t\t            if (sigBytes != undefined) {\n\t\t                this.sigBytes = sigBytes;\n\t\t            } else {\n\t\t                this.sigBytes = words.length * 4;\n\t\t            }\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Converts this word array to a string.\n\t\t         *\n\t\t         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n\t\t         *\n\t\t         * @return {string} The stringified word array.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var string = wordArray + '';\n\t\t         *     var string = wordArray.toString();\n\t\t         *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n\t\t         */\n\t\t        toString: function (encoder) {\n\t\t            return (encoder || Hex).stringify(this);\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Concatenates a word array to this word array.\n\t\t         *\n\t\t         * @param {WordArray} wordArray The word array to append.\n\t\t         *\n\t\t         * @return {WordArray} This word array.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     wordArray1.concat(wordArray2);\n\t\t         */\n\t\t        concat: function (wordArray) {\n\t\t            // Shortcuts\n\t\t            var thisWords = this.words;\n\t\t            var thatWords = wordArray.words;\n\t\t            var thisSigBytes = this.sigBytes;\n\t\t            var thatSigBytes = wordArray.sigBytes;\n\t\n\t\t            // Clamp excess bits\n\t\t            this.clamp();\n\t\n\t\t            // Concat\n\t\t            if (thisSigBytes % 4) {\n\t\t                // Copy one byte at a time\n\t\t                for (var i = 0; i < thatSigBytes; i++) {\n\t\t                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t\t                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n\t\t                }\n\t\t            } else {\n\t\t                // Copy one word at a time\n\t\t                for (var i = 0; i < thatSigBytes; i += 4) {\n\t\t                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n\t\t                }\n\t\t            }\n\t\t            this.sigBytes += thatSigBytes;\n\t\n\t\t            // Chainable\n\t\t            return this;\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Removes insignificant bits.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     wordArray.clamp();\n\t\t         */\n\t\t        clamp: function () {\n\t\t            // Shortcuts\n\t\t            var words = this.words;\n\t\t            var sigBytes = this.sigBytes;\n\t\n\t\t            // Clamp\n\t\t            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n\t\t            words.length = Math.ceil(sigBytes / 4);\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Creates a copy of this word array.\n\t\t         *\n\t\t         * @return {WordArray} The clone.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var clone = wordArray.clone();\n\t\t         */\n\t\t        clone: function () {\n\t\t            var clone = Base.clone.call(this);\n\t\t            clone.words = this.words.slice(0);\n\t\n\t\t            return clone;\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Creates a word array filled with random bytes.\n\t\t         *\n\t\t         * @param {number} nBytes The number of random bytes to generate.\n\t\t         *\n\t\t         * @return {WordArray} The random word array.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var wordArray = CryptoJS.lib.WordArray.random(16);\n\t\t         */\n\t\t        random: function (nBytes) {\n\t\t            var words = [];\n\t\n\t\t            var r = (function (m_w) {\n\t\t                var m_w = m_w;\n\t\t                var m_z = 0x3ade68b1;\n\t\t                var mask = 0xffffffff;\n\t\n\t\t                return function () {\n\t\t                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;\n\t\t                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;\n\t\t                    var result = ((m_z << 0x10) + m_w) & mask;\n\t\t                    result /= 0x100000000;\n\t\t                    result += 0.5;\n\t\t                    return result * (Math.random() > .5 ? 1 : -1);\n\t\t                }\n\t\t            });\n\t\n\t\t            for (var i = 0, rcache; i < nBytes; i += 4) {\n\t\t                var _r = r((rcache || Math.random()) * 0x100000000);\n\t\n\t\t                rcache = _r() * 0x3ade67b7;\n\t\t                words.push((_r() * 0x100000000) | 0);\n\t\t            }\n\t\n\t\t            return new WordArray.init(words, nBytes);\n\t\t        }\n\t\t    });\n\t\n\t\t    /**\n\t\t     * Encoder namespace.\n\t\t     */\n\t\t    var C_enc = C.enc = {};\n\t\n\t\t    /**\n\t\t     * Hex encoding strategy.\n\t\t     */\n\t\t    var Hex = C_enc.Hex = {\n\t\t        /**\n\t\t         * Converts a word array to a hex string.\n\t\t         *\n\t\t         * @param {WordArray} wordArray The word array.\n\t\t         *\n\t\t         * @return {string} The hex string.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n\t\t         */\n\t\t        stringify: function (wordArray) {\n\t\t            // Shortcuts\n\t\t            var words = wordArray.words;\n\t\t            var sigBytes = wordArray.sigBytes;\n\t\n\t\t            // Convert\n\t\t            var hexChars = [];\n\t\t            for (var i = 0; i < sigBytes; i++) {\n\t\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t\t                hexChars.push((bite >>> 4).toString(16));\n\t\t                hexChars.push((bite & 0x0f).toString(16));\n\t\t            }\n\t\n\t\t            return hexChars.join('');\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Converts a hex string to a word array.\n\t\t         *\n\t\t         * @param {string} hexStr The hex string.\n\t\t         *\n\t\t         * @return {WordArray} The word array.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n\t\t         */\n\t\t        parse: function (hexStr) {\n\t\t            // Shortcut\n\t\t            var hexStrLength = hexStr.length;\n\t\n\t\t            // Convert\n\t\t            var words = [];\n\t\t            for (var i = 0; i < hexStrLength; i += 2) {\n\t\t                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n\t\t            }\n\t\n\t\t            return new WordArray.init(words, hexStrLength / 2);\n\t\t        }\n\t\t    };\n\t\n\t\t    /**\n\t\t     * Latin1 encoding strategy.\n\t\t     */\n\t\t    var Latin1 = C_enc.Latin1 = {\n\t\t        /**\n\t\t         * Converts a word array to a Latin1 string.\n\t\t         *\n\t\t         * @param {WordArray} wordArray The word array.\n\t\t         *\n\t\t         * @return {string} The Latin1 string.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n\t\t         */\n\t\t        stringify: function (wordArray) {\n\t\t            // Shortcuts\n\t\t            var words = wordArray.words;\n\t\t            var sigBytes = wordArray.sigBytes;\n\t\n\t\t            // Convert\n\t\t            var latin1Chars = [];\n\t\t            for (var i = 0; i < sigBytes; i++) {\n\t\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t\t                latin1Chars.push(String.fromCharCode(bite));\n\t\t            }\n\t\n\t\t            return latin1Chars.join('');\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Converts a Latin1 string to a word array.\n\t\t         *\n\t\t         * @param {string} latin1Str The Latin1 string.\n\t\t         *\n\t\t         * @return {WordArray} The word array.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n\t\t         */\n\t\t        parse: function (latin1Str) {\n\t\t            // Shortcut\n\t\t            var latin1StrLength = latin1Str.length;\n\t\n\t\t            // Convert\n\t\t            var words = [];\n\t\t            for (var i = 0; i < latin1StrLength; i++) {\n\t\t                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n\t\t            }\n\t\n\t\t            return new WordArray.init(words, latin1StrLength);\n\t\t        }\n\t\t    };\n\t\n\t\t    /**\n\t\t     * UTF-8 encoding strategy.\n\t\t     */\n\t\t    var Utf8 = C_enc.Utf8 = {\n\t\t        /**\n\t\t         * Converts a word array to a UTF-8 string.\n\t\t         *\n\t\t         * @param {WordArray} wordArray The word array.\n\t\t         *\n\t\t         * @return {string} The UTF-8 string.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n\t\t         */\n\t\t        stringify: function (wordArray) {\n\t\t            try {\n\t\t                return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n\t\t            } catch (e) {\n\t\t                throw new Error('Malformed UTF-8 data');\n\t\t            }\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Converts a UTF-8 string to a word array.\n\t\t         *\n\t\t         * @param {string} utf8Str The UTF-8 string.\n\t\t         *\n\t\t         * @return {WordArray} The word array.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n\t\t         */\n\t\t        parse: function (utf8Str) {\n\t\t            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n\t\t        }\n\t\t    };\n\t\n\t\t    /**\n\t\t     * Abstract buffered block algorithm template.\n\t\t     *\n\t\t     * The property blockSize must be implemented in a concrete subtype.\n\t\t     *\n\t\t     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n\t\t     */\n\t\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\t\t        /**\n\t\t         * Resets this block algorithm's data buffer to its initial state.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     bufferedBlockAlgorithm.reset();\n\t\t         */\n\t\t        reset: function () {\n\t\t            // Initial values\n\t\t            this._data = new WordArray.init();\n\t\t            this._nDataBytes = 0;\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Adds new data to this block algorithm's buffer.\n\t\t         *\n\t\t         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     bufferedBlockAlgorithm._append('data');\n\t\t         *     bufferedBlockAlgorithm._append(wordArray);\n\t\t         */\n\t\t        _append: function (data) {\n\t\t            // Convert string to WordArray, else assume WordArray already\n\t\t            if (typeof data == 'string') {\n\t\t                data = Utf8.parse(data);\n\t\t            }\n\t\n\t\t            // Append\n\t\t            this._data.concat(data);\n\t\t            this._nDataBytes += data.sigBytes;\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Processes available data blocks.\n\t\t         *\n\t\t         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n\t\t         *\n\t\t         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n\t\t         *\n\t\t         * @return {WordArray} The processed data.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var processedData = bufferedBlockAlgorithm._process();\n\t\t         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n\t\t         */\n\t\t        _process: function (doFlush) {\n\t\t            // Shortcuts\n\t\t            var data = this._data;\n\t\t            var dataWords = data.words;\n\t\t            var dataSigBytes = data.sigBytes;\n\t\t            var blockSize = this.blockSize;\n\t\t            var blockSizeBytes = blockSize * 4;\n\t\n\t\t            // Count blocks ready\n\t\t            var nBlocksReady = dataSigBytes / blockSizeBytes;\n\t\t            if (doFlush) {\n\t\t                // Round up to include partial blocks\n\t\t                nBlocksReady = Math.ceil(nBlocksReady);\n\t\t            } else {\n\t\t                // Round down to include only full blocks,\n\t\t                // less the number of blocks that must remain in the buffer\n\t\t                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n\t\t            }\n\t\n\t\t            // Count words ready\n\t\t            var nWordsReady = nBlocksReady * blockSize;\n\t\n\t\t            // Count bytes ready\n\t\t            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\t\n\t\t            // Process blocks\n\t\t            if (nWordsReady) {\n\t\t                for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n\t\t                    // Perform concrete-algorithm logic\n\t\t                    this._doProcessBlock(dataWords, offset);\n\t\t                }\n\t\n\t\t                // Remove processed words\n\t\t                var processedWords = dataWords.splice(0, nWordsReady);\n\t\t                data.sigBytes -= nBytesReady;\n\t\t            }\n\t\n\t\t            // Return processed words\n\t\t            return new WordArray.init(processedWords, nBytesReady);\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Creates a copy of this object.\n\t\t         *\n\t\t         * @return {Object} The clone.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var clone = bufferedBlockAlgorithm.clone();\n\t\t         */\n\t\t        clone: function () {\n\t\t            var clone = Base.clone.call(this);\n\t\t            clone._data = this._data.clone();\n\t\n\t\t            return clone;\n\t\t        },\n\t\n\t\t        _minBufferSize: 0\n\t\t    });\n\t\n\t\t    /**\n\t\t     * Abstract hasher template.\n\t\t     *\n\t\t     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n\t\t     */\n\t\t    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n\t\t        /**\n\t\t         * Configuration options.\n\t\t         */\n\t\t        cfg: Base.extend(),\n\t\n\t\t        /**\n\t\t         * Initializes a newly created hasher.\n\t\t         *\n\t\t         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var hasher = CryptoJS.algo.SHA256.create();\n\t\t         */\n\t\t        init: function (cfg) {\n\t\t            // Apply config defaults\n\t\t            this.cfg = this.cfg.extend(cfg);\n\t\n\t\t            // Set initial values\n\t\t            this.reset();\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Resets this hasher to its initial state.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     hasher.reset();\n\t\t         */\n\t\t        reset: function () {\n\t\t            // Reset data buffer\n\t\t            BufferedBlockAlgorithm.reset.call(this);\n\t\n\t\t            // Perform concrete-hasher logic\n\t\t            this._doReset();\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Updates this hasher with a message.\n\t\t         *\n\t\t         * @param {WordArray|string} messageUpdate The message to append.\n\t\t         *\n\t\t         * @return {Hasher} This hasher.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     hasher.update('message');\n\t\t         *     hasher.update(wordArray);\n\t\t         */\n\t\t        update: function (messageUpdate) {\n\t\t            // Append\n\t\t            this._append(messageUpdate);\n\t\n\t\t            // Update the hash\n\t\t            this._process();\n\t\n\t\t            // Chainable\n\t\t            return this;\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Finalizes the hash computation.\n\t\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t\t         *\n\t\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t\t         *\n\t\t         * @return {WordArray} The hash.\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var hash = hasher.finalize();\n\t\t         *     var hash = hasher.finalize('message');\n\t\t         *     var hash = hasher.finalize(wordArray);\n\t\t         */\n\t\t        finalize: function (messageUpdate) {\n\t\t            // Final message update\n\t\t            if (messageUpdate) {\n\t\t                this._append(messageUpdate);\n\t\t            }\n\t\n\t\t            // Perform concrete-hasher logic\n\t\t            var hash = this._doFinalize();\n\t\n\t\t            return hash;\n\t\t        },\n\t\n\t\t        blockSize: 512/32,\n\t\n\t\t        /**\n\t\t         * Creates a shortcut function to a hasher's object interface.\n\t\t         *\n\t\t         * @param {Hasher} hasher The hasher to create a helper for.\n\t\t         *\n\t\t         * @return {Function} The shortcut function.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n\t\t         */\n\t\t        _createHelper: function (hasher) {\n\t\t            return function (message, cfg) {\n\t\t                return new hasher.init(cfg).finalize(message);\n\t\t            };\n\t\t        },\n\t\n\t\t        /**\n\t\t         * Creates a shortcut function to the HMAC's object interface.\n\t\t         *\n\t\t         * @param {Hasher} hasher The hasher to use in this HMAC helper.\n\t\t         *\n\t\t         * @return {Function} The shortcut function.\n\t\t         *\n\t\t         * @static\n\t\t         *\n\t\t         * @example\n\t\t         *\n\t\t         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n\t\t         */\n\t\t        _createHmacHelper: function (hasher) {\n\t\t            return function (message, key) {\n\t\t                return new C_algo.HMAC.init(hasher, key).finalize(message);\n\t\t            };\n\t\t        }\n\t\t    });\n\t\n\t\t    /**\n\t\t     * Algorithm namespace.\n\t\t     */\n\t\t    var C_algo = C.algo = {};\n\t\n\t\t    return C;\n\t\t}(Math));\n\t\n\t\n\t\treturn CryptoJS;\n\t\n\t}));\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// infobolsa.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 15642e58fa5fd4eb705d","import pkg from '../package.json';\nimport 'hammerjs';\nimport {\n  OPTIONS,\n  INIT_DELAY,\n  PRODUCTION\n} from './constants';\n\nconst\n  {$, RSVP}     = Voonto,\n  app           = Voonto.getInstance(),\n  _env          = app.lookup('vocento.site').env,\n  // FUTURE: Cambiar esto\n  INFOBOLSA_URL = !_env ? './assets/infobolsa-min.js'      : `//${_getEnvPrefix()}static.vocento.com/infobolsa/${pkg.version}/assets/infobolsa-min.js`,\n  DDSLICK_URL   = !_env ? './assets/jquery-ddslick-min.js' : `//${_getEnvPrefix()}static.vocento.com/infobolsa/${pkg.version}/assets/jquery-ddslick-min.js`,\n  CSS_URL       = !_env ? './assets/css/styles.css'        : `//${_getEnvPrefix()}static.vocento.com/infobolsa/${pkg.version}/assets/css/styles.css`\n;\n\nvar _cssP;\n\nif ($('[data-voc-infobolsa]').length) {window.onload = _load;}\n\nexport const VERSION = pkg.version;\n\n/* Private */\n\nfunction _load() {\n  setTimeout(function() {\n    RSVP.resolve()\n      .then(() => app.load(INFOBOLSA_URL))\n      .then(() => app.load(DDSLICK_URL))\n      .then(() => _loadCSS())\n      .then(() => {\n        _init();\n        app.on('voonto:reload', (event, context$) => _init(context$));\n      });\n  }, INIT_DELAY);\n}\n\nfunction _loadCSS() {\n  if (_cssP) { return _cssP; }\n\n  _cssP = new RSVP.Promise(function(resolve, reject) {\n    const link   = document.createElement('link');\n    link.rel     = 'stylesheet';\n    link.href    = CSS_URL;\n    link.onload  = resolve;\n    link.onerror = reject;\n    document.head.appendChild(link);\n  });\n\n  return _cssP;\n}\n\nfunction _init(context$) {\n  $('[data-voc-infobolsa]', context$).each(function () {\n    const language = window.IFB.Utils.Helper.getQueryStringParam('culture') || 'es';\n    const el$ = $(this);\n\n    OPTIONS.culture = { language };\n    OPTIONS.widgets = [{\n      config: el$.data('voc-infobolsa'),\n      view: { el: el$ }\n    }];\n\n    if (OPTIONS.widgets[0].config === 'risk_premium') {\n      OPTIONS.widgets[0].service = {param: 'RBPLES'};\n    }\n\n    new window.IFB.VOCENTO.Broker.Launcher(OPTIONS).enter();\n  });\n}\n\nfunction _getEnvPrefix() {\n  return _env === PRODUCTION ? '' : `${_env}-`; // FIXME: solve with process.env.SOME_VAR\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/index.js","module.exports = {\"name\":\"infobolsa\",\"version\":\"1.0.14\",\"description\":\"\",\"main\":\"src/index.js\",\"scripts\":{\"test\":\"./node_modules/.bin/webpack && ./node_modules/.bin/mocha-phantomjs dist/spec/index.html --reporter xunit --file test-results.xml\",\"start\":\"webpack-dev-server --content-base dist/\",\"build\":\"./node_modules/webpack/bin/webpack.js\"},\"author\":\"Iván Pérez <ivanperez@vocento.com>\",\"license\":\"SEE LICENSE IN LICENSE.md\",\"devDependencies\":{\"babel-core\":\"^6.17.0\",\"babel-eslint\":\"^8.0.1\",\"babel-loader\":\"^6.2.5\",\"babel-polyfill\":\"^6.16.0\",\"babel-preset-es2015\":\"^6.16.0\",\"case\":\"^1.5.3\",\"chai\":\"^3.5.0\",\"chalk\":\"^1.1.3\",\"css-loader\":\"^0.28.7\",\"eslint\":\"^4.7.2\",\"eslint-config-airbnb-base\":\"^12.0.1\",\"eslint-plugin-import\":\"^2.7.0\",\"file-loader\":\"^1.1.5\",\"html-webpack-plugin\":\"^2.24.1\",\"json-loader\":\"^0.5.4\",\"mocha\":\"^3.1.0\",\"mocha-loader\":\"^1.0.0\",\"mocha-phantomjs\":\"^4.1.0\",\"style-loader\":\"^0.19.0\",\"url-loader\":\"^0.6.2\",\"webpack\":\"^1.13.3\",\"webpack-shell-plugin\":\"^0.4.3\"},\"dependencies\":{\"crypto-js\":\"^3.1.9-1\",\"hammer\":\"0.0.5\",\"hammerjs\":\"^2.0.8\"}}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./package.json\n// module id = 2\n// module chunks = 0","/*! 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\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/hammerjs/hammer.js\n// module id = 3\n// module chunks = 0 1","import md5 from 'crypto-js/md5';\n\nconst domain           = 'infobolsa.es';\nconst server           = 'wtst.infobolsa.es';\nconst session          = 'COLPISAMOD';\nconst hash             = 'NM6H52DKy2FrWtsqralz2jq5TZ8LVsFU';\nconst provider         = 'BANKIA';\nconst interactiveChart = 'https://ifbwtsptest.infobolsa.es';\n\nconst login = Object.freeze({\n  servidor: server,\n  idSesion: _getSessionKey()\n});\n\nexport const OPTIONS = {\n  debug: 0,\n  login,\n  config: {\n    domain,\n    interactiveChart\n  },\n  widgets: []\n};\n\nexport const INIT_DELAY = 4000;\nexport const PRODUCTION = 'pro';\n\n/* Private */\n\nfunction _getSessionKey() {\n  var timestamp = Math.floor(Date.now());\n  var key = `${provider}~${timestamp}~${session}~${hash}`;\n  var passhash = md5(key).toString();\n  return `${provider}_${timestamp}_${session}_${passhash.toUpperCase()}`;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/constants.js",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function (Math) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Constants table\n\t    var T = [];\n\n\t    // Compute constants\n\t    (function () {\n\t        for (var i = 0; i < 64; i++) {\n\t            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n\t        }\n\t    }());\n\n\t    /**\n\t     * MD5 hash algorithm.\n\t     */\n\t    var MD5 = C_algo.MD5 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init([\n\t                0x67452301, 0xefcdab89,\n\t                0x98badcfe, 0x10325476\n\t            ]);\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Swap endian\n\t            for (var i = 0; i < 16; i++) {\n\t                // Shortcuts\n\t                var offset_i = offset + i;\n\t                var M_offset_i = M[offset_i];\n\n\t                M[offset_i] = (\n\t                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |\n\t                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)\n\t                );\n\t            }\n\n\t            // Shortcuts\n\t            var H = this._hash.words;\n\n\t            var M_offset_0  = M[offset + 0];\n\t            var M_offset_1  = M[offset + 1];\n\t            var M_offset_2  = M[offset + 2];\n\t            var M_offset_3  = M[offset + 3];\n\t            var M_offset_4  = M[offset + 4];\n\t            var M_offset_5  = M[offset + 5];\n\t            var M_offset_6  = M[offset + 6];\n\t            var M_offset_7  = M[offset + 7];\n\t            var M_offset_8  = M[offset + 8];\n\t            var M_offset_9  = M[offset + 9];\n\t            var M_offset_10 = M[offset + 10];\n\t            var M_offset_11 = M[offset + 11];\n\t            var M_offset_12 = M[offset + 12];\n\t            var M_offset_13 = M[offset + 13];\n\t            var M_offset_14 = M[offset + 14];\n\t            var M_offset_15 = M[offset + 15];\n\n\t            // Working varialbes\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\n\t            // Computation\n\t            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);\n\t            d = FF(d, a, b, c, M_offset_1,  12, T[1]);\n\t            c = FF(c, d, a, b, M_offset_2,  17, T[2]);\n\t            b = FF(b, c, d, a, M_offset_3,  22, T[3]);\n\t            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);\n\t            d = FF(d, a, b, c, M_offset_5,  12, T[5]);\n\t            c = FF(c, d, a, b, M_offset_6,  17, T[6]);\n\t            b = FF(b, c, d, a, M_offset_7,  22, T[7]);\n\t            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);\n\t            d = FF(d, a, b, c, M_offset_9,  12, T[9]);\n\t            c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n\t            b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n\t            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);\n\t            d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n\t            c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n\t            b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\n\t            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);\n\t            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);\n\t            c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n\t            b = GG(b, c, d, a, M_offset_0,  20, T[19]);\n\t            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);\n\t            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);\n\t            c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n\t            b = GG(b, c, d, a, M_offset_4,  20, T[23]);\n\t            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);\n\t            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);\n\t            c = GG(c, d, a, b, M_offset_3,  14, T[26]);\n\t            b = GG(b, c, d, a, M_offset_8,  20, T[27]);\n\t            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);\n\t            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);\n\t            c = GG(c, d, a, b, M_offset_7,  14, T[30]);\n\t            b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\n\t            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);\n\t            d = HH(d, a, b, c, M_offset_8,  11, T[33]);\n\t            c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n\t            b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n\t            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);\n\t            d = HH(d, a, b, c, M_offset_4,  11, T[37]);\n\t            c = HH(c, d, a, b, M_offset_7,  16, T[38]);\n\t            b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n\t            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);\n\t            d = HH(d, a, b, c, M_offset_0,  11, T[41]);\n\t            c = HH(c, d, a, b, M_offset_3,  16, T[42]);\n\t            b = HH(b, c, d, a, M_offset_6,  23, T[43]);\n\t            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);\n\t            d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n\t            c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n\t            b = HH(b, c, d, a, M_offset_2,  23, T[47]);\n\n\t            a = II(a, b, c, d, M_offset_0,  6,  T[48]);\n\t            d = II(d, a, b, c, M_offset_7,  10, T[49]);\n\t            c = II(c, d, a, b, M_offset_14, 15, T[50]);\n\t            b = II(b, c, d, a, M_offset_5,  21, T[51]);\n\t            a = II(a, b, c, d, M_offset_12, 6,  T[52]);\n\t            d = II(d, a, b, c, M_offset_3,  10, T[53]);\n\t            c = II(c, d, a, b, M_offset_10, 15, T[54]);\n\t            b = II(b, c, d, a, M_offset_1,  21, T[55]);\n\t            a = II(a, b, c, d, M_offset_8,  6,  T[56]);\n\t            d = II(d, a, b, c, M_offset_15, 10, T[57]);\n\t            c = II(c, d, a, b, M_offset_6,  15, T[58]);\n\t            b = II(b, c, d, a, M_offset_13, 21, T[59]);\n\t            a = II(a, b, c, d, M_offset_4,  6,  T[60]);\n\t            d = II(d, a, b, c, M_offset_11, 10, T[61]);\n\t            c = II(c, d, a, b, M_offset_2,  15, T[62]);\n\t            b = II(b, c, d, a, M_offset_9,  21, T[63]);\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\n\t            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n\t            var nBitsTotalL = nBitsTotal;\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n\t                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)\n\t            );\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n\t                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\n\t                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)\n\t            );\n\n\t            data.sigBytes = (dataWords.length + 1) * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Shortcuts\n\t            var hash = this._hash;\n\t            var H = hash.words;\n\n\t            // Swap endian\n\t            for (var i = 0; i < 4; i++) {\n\t                // Shortcut\n\t                var H_i = H[i];\n\n\t                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |\n\t                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);\n\t            }\n\n\t            // Return final computed hash\n\t            return hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    function FF(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & c) | (~b & d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function GG(a, b, c, d, x, s, t) {\n\t        var n = a + ((b & d) | (c & ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function HH(a, b, c, d, x, s, t) {\n\t        var n = a + (b ^ c ^ d) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    function II(a, b, c, d, x, s, t) {\n\t        var n = a + (c ^ (b | ~d)) + x + t;\n\t        return ((n << s) | (n >>> (32 - s))) + b;\n\t    }\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.MD5('message');\n\t     *     var hash = CryptoJS.MD5(wordArray);\n\t     */\n\t    C.MD5 = Hasher._createHelper(MD5);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacMD5(message, key);\n\t     */\n\t    C.HmacMD5 = Hasher._createHmacHelper(MD5);\n\t}(Math));\n\n\n\treturn CryptoJS.MD5;\n\n}));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-js/md5.js\n// module id = 5\n// module chunks = 0 1",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory();\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\troot.CryptoJS = factory();\n\t}\n}(this, function () {\n\n\t/**\n\t * CryptoJS core components.\n\t */\n\tvar CryptoJS = CryptoJS || (function (Math, undefined) {\n\t    /*\n\t     * Local polyfil of Object.create\n\t     */\n\t    var create = Object.create || (function () {\n\t        function F() {};\n\n\t        return function (obj) {\n\t            var subtype;\n\n\t            F.prototype = obj;\n\n\t            subtype = new F();\n\n\t            F.prototype = null;\n\n\t            return subtype;\n\t        };\n\t    }())\n\n\t    /**\n\t     * CryptoJS namespace.\n\t     */\n\t    var C = {};\n\n\t    /**\n\t     * Library namespace.\n\t     */\n\t    var C_lib = C.lib = {};\n\n\t    /**\n\t     * Base object for prototypal inheritance.\n\t     */\n\t    var Base = C_lib.Base = (function () {\n\n\n\t        return {\n\t            /**\n\t             * Creates a new object that inherits from this object.\n\t             *\n\t             * @param {Object} overrides Properties to copy into the new object.\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         field: 'value',\n\t             *\n\t             *         method: function () {\n\t             *         }\n\t             *     });\n\t             */\n\t            extend: function (overrides) {\n\t                // Spawn\n\t                var subtype = create(this);\n\n\t                // Augment\n\t                if (overrides) {\n\t                    subtype.mixIn(overrides);\n\t                }\n\n\t                // Create default initializer\n\t                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n\t                    subtype.init = function () {\n\t                        subtype.$super.init.apply(this, arguments);\n\t                    };\n\t                }\n\n\t                // Initializer's prototype is the subtype object\n\t                subtype.init.prototype = subtype;\n\n\t                // Reference supertype\n\t                subtype.$super = this;\n\n\t                return subtype;\n\t            },\n\n\t            /**\n\t             * Extends this object and runs the init method.\n\t             * Arguments to create() will be passed to init().\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var instance = MyType.create();\n\t             */\n\t            create: function () {\n\t                var instance = this.extend();\n\t                instance.init.apply(instance, arguments);\n\n\t                return instance;\n\t            },\n\n\t            /**\n\t             * Initializes a newly created object.\n\t             * Override this method to add some logic when your objects are created.\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         init: function () {\n\t             *             // ...\n\t             *         }\n\t             *     });\n\t             */\n\t            init: function () {\n\t            },\n\n\t            /**\n\t             * Copies properties into this object.\n\t             *\n\t             * @param {Object} properties The properties to mix in.\n\t             *\n\t             * @example\n\t             *\n\t             *     MyType.mixIn({\n\t             *         field: 'value'\n\t             *     });\n\t             */\n\t            mixIn: function (properties) {\n\t                for (var propertyName in properties) {\n\t                    if (properties.hasOwnProperty(propertyName)) {\n\t                        this[propertyName] = properties[propertyName];\n\t                    }\n\t                }\n\n\t                // IE won't copy toString using the loop above\n\t                if (properties.hasOwnProperty('toString')) {\n\t                    this.toString = properties.toString;\n\t                }\n\t            },\n\n\t            /**\n\t             * Creates a copy of this object.\n\t             *\n\t             * @return {Object} The clone.\n\t             *\n\t             * @example\n\t             *\n\t             *     var clone = instance.clone();\n\t             */\n\t            clone: function () {\n\t                return this.init.prototype.extend(this);\n\t            }\n\t        };\n\t    }());\n\n\t    /**\n\t     * An array of 32-bit words.\n\t     *\n\t     * @property {Array} words The array of 32-bit words.\n\t     * @property {number} sigBytes The number of significant bytes in this word array.\n\t     */\n\t    var WordArray = C_lib.WordArray = Base.extend({\n\t        /**\n\t         * Initializes a newly created word array.\n\t         *\n\t         * @param {Array} words (Optional) An array of 32-bit words.\n\t         * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.create();\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n\t         */\n\t        init: function (words, sigBytes) {\n\t            words = this.words = words || [];\n\n\t            if (sigBytes != undefined) {\n\t                this.sigBytes = sigBytes;\n\t            } else {\n\t                this.sigBytes = words.length * 4;\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts this word array to a string.\n\t         *\n\t         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n\t         *\n\t         * @return {string} The stringified word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = wordArray + '';\n\t         *     var string = wordArray.toString();\n\t         *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n\t         */\n\t        toString: function (encoder) {\n\t            return (encoder || Hex).stringify(this);\n\t        },\n\n\t        /**\n\t         * Concatenates a word array to this word array.\n\t         *\n\t         * @param {WordArray} wordArray The word array to append.\n\t         *\n\t         * @return {WordArray} This word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray1.concat(wordArray2);\n\t         */\n\t        concat: function (wordArray) {\n\t            // Shortcuts\n\t            var thisWords = this.words;\n\t            var thatWords = wordArray.words;\n\t            var thisSigBytes = this.sigBytes;\n\t            var thatSigBytes = wordArray.sigBytes;\n\n\t            // Clamp excess bits\n\t            this.clamp();\n\n\t            // Concat\n\t            if (thisSigBytes % 4) {\n\t                // Copy one byte at a time\n\t                for (var i = 0; i < thatSigBytes; i++) {\n\t                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n\t                }\n\t            } else {\n\t                // Copy one word at a time\n\t                for (var i = 0; i < thatSigBytes; i += 4) {\n\t                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n\t                }\n\t            }\n\t            this.sigBytes += thatSigBytes;\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Removes insignificant bits.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray.clamp();\n\t         */\n\t        clamp: function () {\n\t            // Shortcuts\n\t            var words = this.words;\n\t            var sigBytes = this.sigBytes;\n\n\t            // Clamp\n\t            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n\t            words.length = Math.ceil(sigBytes / 4);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this word array.\n\t         *\n\t         * @return {WordArray} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = wordArray.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone.words = this.words.slice(0);\n\n\t            return clone;\n\t        },\n\n\t        /**\n\t         * Creates a word array filled with random bytes.\n\t         *\n\t         * @param {number} nBytes The number of random bytes to generate.\n\t         *\n\t         * @return {WordArray} The random word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.random(16);\n\t         */\n\t        random: function (nBytes) {\n\t            var words = [];\n\n\t            var r = (function (m_w) {\n\t                var m_w = m_w;\n\t                var m_z = 0x3ade68b1;\n\t                var mask = 0xffffffff;\n\n\t                return function () {\n\t                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;\n\t                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;\n\t                    var result = ((m_z << 0x10) + m_w) & mask;\n\t                    result /= 0x100000000;\n\t                    result += 0.5;\n\t                    return result * (Math.random() > .5 ? 1 : -1);\n\t                }\n\t            });\n\n\t            for (var i = 0, rcache; i < nBytes; i += 4) {\n\t                var _r = r((rcache || Math.random()) * 0x100000000);\n\n\t                rcache = _r() * 0x3ade67b7;\n\t                words.push((_r() * 0x100000000) | 0);\n\t            }\n\n\t            return new WordArray.init(words, nBytes);\n\t        }\n\t    });\n\n\t    /**\n\t     * Encoder namespace.\n\t     */\n\t    var C_enc = C.enc = {};\n\n\t    /**\n\t     * Hex encoding strategy.\n\t     */\n\t    var Hex = C_enc.Hex = {\n\t        /**\n\t         * Converts a word array to a hex string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The hex string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var hexChars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                hexChars.push((bite >>> 4).toString(16));\n\t                hexChars.push((bite & 0x0f).toString(16));\n\t            }\n\n\t            return hexChars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a hex string to a word array.\n\t         *\n\t         * @param {string} hexStr The hex string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n\t         */\n\t        parse: function (hexStr) {\n\t            // Shortcut\n\t            var hexStrLength = hexStr.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < hexStrLength; i += 2) {\n\t                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n\t            }\n\n\t            return new WordArray.init(words, hexStrLength / 2);\n\t        }\n\t    };\n\n\t    /**\n\t     * Latin1 encoding strategy.\n\t     */\n\t    var Latin1 = C_enc.Latin1 = {\n\t        /**\n\t         * Converts a word array to a Latin1 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Latin1 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var latin1Chars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                latin1Chars.push(String.fromCharCode(bite));\n\t            }\n\n\t            return latin1Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Latin1 string to a word array.\n\t         *\n\t         * @param {string} latin1Str The Latin1 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n\t         */\n\t        parse: function (latin1Str) {\n\t            // Shortcut\n\t            var latin1StrLength = latin1Str.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < latin1StrLength; i++) {\n\t                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n\t            }\n\n\t            return new WordArray.init(words, latin1StrLength);\n\t        }\n\t    };\n\n\t    /**\n\t     * UTF-8 encoding strategy.\n\t     */\n\t    var Utf8 = C_enc.Utf8 = {\n\t        /**\n\t         * Converts a word array to a UTF-8 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The UTF-8 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            try {\n\t                return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n\t            } catch (e) {\n\t                throw new Error('Malformed UTF-8 data');\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts a UTF-8 string to a word array.\n\t         *\n\t         * @param {string} utf8Str The UTF-8 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n\t         */\n\t        parse: function (utf8Str) {\n\t            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract buffered block algorithm template.\n\t     *\n\t     * The property blockSize must be implemented in a concrete subtype.\n\t     *\n\t     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n\t     */\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\t        /**\n\t         * Resets this block algorithm's data buffer to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm.reset();\n\t         */\n\t        reset: function () {\n\t            // Initial values\n\t            this._data = new WordArray.init();\n\t            this._nDataBytes = 0;\n\t        },\n\n\t        /**\n\t         * Adds new data to this block algorithm's buffer.\n\t         *\n\t         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm._append('data');\n\t         *     bufferedBlockAlgorithm._append(wordArray);\n\t         */\n\t        _append: function (data) {\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof data == 'string') {\n\t                data = Utf8.parse(data);\n\t            }\n\n\t            // Append\n\t            this._data.concat(data);\n\t            this._nDataBytes += data.sigBytes;\n\t        },\n\n\t        /**\n\t         * Processes available data blocks.\n\t         *\n\t         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n\t         *\n\t         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n\t         *\n\t         * @return {WordArray} The processed data.\n\t         *\n\t         * @example\n\t         *\n\t         *     var processedData = bufferedBlockAlgorithm._process();\n\t         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n\t         */\n\t        _process: function (doFlush) {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\t            var dataSigBytes = data.sigBytes;\n\t            var blockSize = this.blockSize;\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count blocks ready\n\t            var nBlocksReady = dataSigBytes / blockSizeBytes;\n\t            if (doFlush) {\n\t                // Round up to include partial blocks\n\t                nBlocksReady = Math.ceil(nBlocksReady);\n\t            } else {\n\t                // Round down to include only full blocks,\n\t                // less the number of blocks that must remain in the buffer\n\t                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n\t            }\n\n\t            // Count words ready\n\t            var nWordsReady = nBlocksReady * blockSize;\n\n\t            // Count bytes ready\n\t            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n\t            // Process blocks\n\t            if (nWordsReady) {\n\t                for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n\t                    // Perform concrete-algorithm logic\n\t                    this._doProcessBlock(dataWords, offset);\n\t                }\n\n\t                // Remove processed words\n\t                var processedWords = dataWords.splice(0, nWordsReady);\n\t                data.sigBytes -= nBytesReady;\n\t            }\n\n\t            // Return processed words\n\t            return new WordArray.init(processedWords, nBytesReady);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this object.\n\t         *\n\t         * @return {Object} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = bufferedBlockAlgorithm.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone._data = this._data.clone();\n\n\t            return clone;\n\t        },\n\n\t        _minBufferSize: 0\n\t    });\n\n\t    /**\n\t     * Abstract hasher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n\t     */\n\t    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Initializes a newly created hasher.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hasher = CryptoJS.algo.SHA256.create();\n\t         */\n\t        init: function (cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this hasher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-hasher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Updates this hasher with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {Hasher} This hasher.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.update('message');\n\t         *     hasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            // Append\n\t            this._append(messageUpdate);\n\n\t            // Update the hash\n\t            this._process();\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the hash computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The hash.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hash = hasher.finalize();\n\t         *     var hash = hasher.finalize('message');\n\t         *     var hash = hasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Final message update\n\t            if (messageUpdate) {\n\t                this._append(messageUpdate);\n\t            }\n\n\t            // Perform concrete-hasher logic\n\t            var hash = this._doFinalize();\n\n\t            return hash;\n\t        },\n\n\t        blockSize: 512/32,\n\n\t        /**\n\t         * Creates a shortcut function to a hasher's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to create a helper for.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHelper: function (hasher) {\n\t            return function (message, cfg) {\n\t                return new hasher.init(cfg).finalize(message);\n\t            };\n\t        },\n\n\t        /**\n\t         * Creates a shortcut function to the HMAC's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to use in this HMAC helper.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHmacHelper: function (hasher) {\n\t            return function (message, key) {\n\t                return new C_algo.HMAC.init(hasher, key).finalize(message);\n\t            };\n\t        }\n\t    });\n\n\t    /**\n\t     * Algorithm namespace.\n\t     */\n\t    var C_algo = C.algo = {};\n\n\t    return C;\n\t}(Math));\n\n\n\treturn CryptoJS;\n\n}));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-js/core.js\n// module id = 6\n// module chunks = 0 1"],"sourceRoot":""}