https://gardner-webb.edu/wp-content/themes/gardnerwebb-twenty/js/dist/gallerySlider.bundle.js?ver=1790854316

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24/******/
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28/******/
29/******/
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32/******/
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35/******/
36/******/ 	// define getter function for harmony exports
37/******/ 	__webpack_require__.d = function(exports, name, getter) {
38/******/ 		if(!__webpack_require__.o(exports, name)) {
39/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
40/******/ 		}
41/******/ 	};
42/******/
43/******/ 	// define __esModule on exports
44/******/ 	__webpack_require__.r = function(exports) {
45/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
46/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
47/******/ 		}
48/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
49/******/ 	};
50/******/
51/******/ 	// create a fake namespace object
52/******/ 	// mode & 1: value is a module id, require it
53/******/ 	// mode & 2: merge all properties of value into the ns
54/******/ 	// mode & 4: return value when already ns object
55/******/ 	// mode & 8|1: behave like require
56/******/ 	__webpack_require__.t = function(value, mode) {
57/******/ 		if(mode & 1) value = __webpack_require__(value);
58/******/ 		if(mode & 8) return value;
59/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
60/******/ 		var ns = Object.create(null);
61/******/ 		__webpack_require__.r(ns);
62/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
63/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
64/******/ 		return ns;
65/******/ 	};
66/******/
67/******/ 	// getDefaultExport function for compatibility with non-harmony modules
68/******/ 	__webpack_require__.n = function(module) {
69/******/ 		var getter = module && module.__esModule ?
70/******/ 			function getDefault() { return module['default']; } :
71/******/ 			function getModuleExports() { return module; };
72/******/ 		__webpack_require__.d(getter, 'a', getter);
73/******/ 		return getter;
74/******/ 	};
75/******/
76/******/ 	// Object.prototype.hasOwnProperty.call
77/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
78/******/
79/******/ 	// __webpack_public_path__
80/******/ 	__webpack_require__.p = "";
81/******/
82/******/
83/******/ 	// Load entry module and return exports
84/******/ 	return __webpack_require__(__webpack_require__.s = 2);
85/******/ })
86/************************************************************************/
87/******/ ({
88

845/***/ "../../../upup-baseline/node_modules/hammerjs/hammer.js":
846/*!***************************************************************************************************************************!*\
847  !*** /Applications/XAMPP/xamppfiles/htdocs/gwu-wordpress/wp-content/themes/upup-baseline/node_modules/hammerjs/hammer.js ***!
848  \***************************************************************************************************************************/
849/*! no static exports found */
850/***/ (function(module, exports, __webpack_require__) {
851
852var __WEBPACK_AMD_DEFINE_RESULT__;/*! Hammer.JS - v2.0.7 - 2016-04-22
853 * http://hammerjs.github.io/
854 *
855 * Copyright (c) 2016 Jorik Tangelder;
856 * Licensed under the MIT license */
857(function(window, document, exportName, undefined) {
858  'use strict';
859
860var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
861var TEST_ELEMENT = document.createElement('div');
862
863var TYPE_FUNCTION = 'function';
864
865var round = Math.round;
866var abs = Math.abs;
867var now = Date.now;
868
869/**
870 * set a timeout with a given scope
871 * @param {Function} fn
872 * @param {Number} timeout
873 * @param {Object} context
874 * @returns {number}
875 */
876function setTimeoutContext(fn, timeout, context) {
877    return setTimeout(bindFn(fn, context), timeout);
878}
879
880/**
881 * if the argument is an array, we want to execute the fn on each entry
882 * if it aint an array we don't want to do a thing.
883 * this is used by all the methods that accept a single and array argument.
884 * @param {*|Array} arg
885 * @param {String} fn
886 * @param {Object} [context]
887 * @returns {Boolean}
888 */
889function invokeArrayArg(arg, fn, context) {
890    if (Array.isArray(arg)) {
891        each(arg, context[fn], context);
892        return true;
893    }
894    return false;
895}
896
897/**
898 * walk objects and arrays
899 * @param {Object} obj
900 * @param {Function} iterator
901 * @param {Object} context
902 */
903function each(obj, iterator, context) {
904    var i;
905
906    if (!obj) {
907        return;
908    }
909
910    if (obj.forEach) {
911        obj.forEach(iterator, context);
912    } else if (obj.length !== undefined) {
913        i = 0;
914        while (i < obj.length) {
915            iterator.call(context, obj[i], i, obj);
916            i++;
917        }
918    } else {
919        for (i in obj) {
920            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
921        }
922    }
923}
924
925/**
926 * wrap a method with a deprecation warning and stack trace
927 * @param {Function} method
928 * @param {String} name
929 * @param {String} message
930 * @returns {Function} A new function wrapping the supplied method.
931 */
932function deprecate(method, name, message) {
933    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\n' + message + ' AT \n';
934    return function() {
935        var e = new Error('get-stack-trace');
936        var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '')
937            .replace(/^\s+at\s+/gm, '')
938            .replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
939
940        var log = window.console && (window.console.warn || window.console.log);
941        if (log) {
942            log.call(window.console, deprecationMessage, stack);
943        }
944        return method.apply(this, arguments);
945    };
946}
947
948/**
949 * extend object.
950 * means that properties in dest will be overwritten by the ones in src.
951 * @param {Object} target
952 * @param {...Object} objects_to_assign
953 * @returns {Object} target
954 */
955var assign;
956if (typeof Object.assign !== 'function') {
957    assign = function assign(target) {
958        if (target === undefined || target === null) {
959            throw new TypeError('Cannot convert undefined or null to object');
960        }
961
962        var output = Object(target);
963        for (var index = 1; index < arguments.length; index++) {
964            var source = arguments[index];
965            if (source !== undefined && source !== null) {
966                for (var nextKey in source) {
967                    if (source.hasOwnProperty(nextKey)) {
968                        output[nextKey] = source[nextKey];
969                    }
970                }
971            }
972        }
973        return output;
974    };
975} else {
976    assign = Object.assign;
977}
978
979/**
980 * extend object.
981 * means that properties in dest will be overwritten by the ones in src.
982 * @param {Object} dest
983 * @param {Object} src
984 * @param {Boolean} [merge=false]
985 * @returns {Object} dest
986 */
987var extend = deprecate(function extend(dest, src, merge) {
988    var keys = Object.keys(src);
989    var i = 0;
990    while (i < keys.length) {
991        if (!merge || (merge && dest[keys[i]] === undefined)) {
992            dest[keys[i]] = src[keys[i]];
993        }
994        i++;
995    }
996    return dest;
997}, 'extend', 'Use `assign`.');
998
999/**
1000 * merge the values from src in the dest.
1001 * means that properties that exist in dest will not be overwritten by src
1002 * @param {Object} dest
1003 * @param {Object} src
1004 * @returns {Object} dest
1005 */
1006var merge = deprecate(function merge(dest, src) {
1007    return extend(dest, src, true);
1008}, 'merge', 'Use `assign`.');
1009
1010/**
1011 * simple class inheritance
1012 * @param {Function} child
1013 * @param {Function} base
1014 * @param {Object} [properties]
1015 */
1016function inherit(child, base, properties) {
1017    var baseP = base.prototype,
1018        childP;
1019
1020    childP = child.prototype = Object.create(baseP);
1021    childP.constructor = child;
1022    childP._super = baseP;
1023
1024    if (properties) {
1025        assign(childP, properties);
1026    }
1027}
1028
1029/**
1030 * simple function bind
1031 * @param {Function} fn
1032 * @param {Object} context
1033 * @returns {Function}
1034 */
1035function bindFn(fn, context) {
1036    return function boundFn() {
1037        return fn.apply(context, arguments);
1038    };
1039}
1040
1041/**
1042 * let a boolean value also be a function that must return a boolean
1043 * this first item in args will be used as the context
1044 * @param {Boolean|Function} val
1045 * @param {Array} [args]
1046 * @returns {Boolean}
1047 */
1048function boolOrFn(val, args) {
1049    if (typeof val == TYPE_FUNCTION) {
1050        return val.apply(args ? args[0] || undefined : undefined, args);
1051    }
1052    return val;
1053}
1054
1055/**
1056 * use the val2 when val1 is undefined
1057 * @param {*} val1
1058 * @param {*} val2
1059 * @returns {*}
1060 */
1061function ifUndefined(val1, val2) {
1062    return (val1 === undefined) ? val2 : val1;
1063}
1064
1065/**
1066 * addEventListener with multiple events at once
1067 * @param {EventTarget} target
1068 * @param {String} types
1069 * @param {Function} handler
1070 */
1071function addEventListeners(target, types, handler) {
1072    each(splitStr(types), function(type) {
1073        target.addEventListener(type, handler, false);
1074    });
1075}
1076
1077/**
1078 * removeEventListener with multiple events at once
1079 * @param {EventTarget} target
1080 * @param {String} types
1081 * @param {Function} handler
1082 */
1083function removeEventListeners(target, types, handler) {
1084    each(splitStr(types), function(type) {
1085        target.removeEventListener(type, handler, false);
1086    });
1087}
1088
1089/**
1090 * find if a node is in the given parent
1091 * @method hasParent
1092 * @param {HTMLElement} node
1093 * @param {HTMLElement} parent
1094 * @return {Boolean} found
1095 */
1096function hasParent(node, parent) {
1097    while (node) {
1098        if (node == parent) {
1099            return true;
1100        }
1101        node = node.parentNode;
1102    }
1103    return false;
1104}
1105
1106/**
1107 * small indexOf wrapper
1108 * @param {String} str
1109 * @param {String} find
1110 * @returns {Boolean} found
1111 */
1112function inStr(str, find) {
1113    return str.indexOf(find) > -1;
1114}
1115
1116/**
1117 * split string on whitespace
1118 * @param {String} str
1119 * @returns {Array} words
1120 */
1121function splitStr(str) {
1122    return str.trim().split(/\s+/g);
1123}
1124
1125/**
1126 * find if a array contains the object using indexOf or a simple polyFill
1127 * @param {Array} src
1128 * @param {String} find
1129 * @param {String} [findByKey]
1130 * @return {Boolean|Number} false when not found, or the index
1131 */
1132function inArray(src, find, findByKey) {
1133    if (src.indexOf && !findByKey) {
1134        return src.indexOf(find);
1135    } else {
1136        var i = 0;
1137        while (i < src.length) {
1138            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
1139                return i;
1140            }
1141            i++;
1142        }
1143        return -1;
1144    }
1145}
1146
1147/**
1148 * convert array-like objects to real arrays
1149 * @param {Object} obj
1150 * @returns {Array}
1151 */
1152function toArray(obj) {
1153    return Array.prototype.slice.call(obj, 0);
1154}
1155
1156/**
1157 * unique array with objects based on a key (like 'id') or just by the array's value
1158 * @param {Array} src [{id:1},{id:2},{id:1}]
1159 * @param {String} [key]
1160 * @param {Boolean} [sort=False]
1161 * @returns {Array} [{id:1},{id:2}]
1162 */
1163function uniqueArray(src, key, sort) {
1164    var results = [];
1165    var values = [];
1166    var i = 0;
1167
1168    while (i < src.length) {
1169        var val = key ? src[i][key] : src[i];
1170        if (inArray(values, val) < 0) {
1171            results.push(src[i]);
1172        }
1173        values[i] = val;
1174        i++;
1175    }
1176
1177    if (sort) {
1178        if (!key) {
1179            results = results.sort();
1180        } else {
1181            results = results.sort(function sortUniqueArray(a, b) {
1182                return a[key] > b[key];
1183            });
1184        }
1185    }
1186
1187    return results;
1188}
1189
1190/**
1191 * get the prefixed property
1192 * @param {Object} obj
1193 * @param {String} property
1194 * @returns {String|Undefined} prefixed
1195 */
1196function prefixed(obj, property) {
1197    var prefix, prop;
1198    var camelProp = property[0].toUpperCase() + property.slice(1);
1199
1200    var i = 0;
1201    while (i < VENDOR_PREFIXES.length) {
1202        prefix = VENDOR_PREFIXES[i];
1203        prop = (prefix) ? prefix + camelProp : property;
1204
1205        if (prop in obj) {
1206            return prop;
1207        }
1208        i++;
1209    }
1210    return undefined;
1211}
1212
1213/**
1214 * get a unique id
1215 * @returns {number} uniqueId
1216 */
1217var _uniqueId = 1;
1218function uniqueId() {
1219    return _uniqueId++;
1220}
1221
1222/**
1223 * get the window object of an element
1224 * @param {HTMLElement} element
1225 * @returns {DocumentView|Window}
1226 */
1227function getWindowForElement(element) {
1228    var doc = element.ownerDocument || element;
1229    return (doc.defaultView || doc.parentWindow || window);
1230}
1231
1232var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
1233
1234var SUPPORT_TOUCH = ('ontouchstart' in window);
1235var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
1236var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
1237
1238var INPUT_TYPE_TOUCH = 'touch';
1239var INPUT_TYPE_PEN = 'pen';
1240var INPUT_TYPE_MOUSE = 'mouse';
1241var INPUT_TYPE_KINECT = 'kinect';
1242
1243var COMPUTE_INTERVAL = 25;
1244
1245var INPUT_START = 1;
1246var INPUT_MOVE = 2;
1247var INPUT_END = 4;
1248var INPUT_CANCEL = 8;
1249
1250var DIRECTION_NONE = 1;
1251var DIRECTION_LEFT = 2;
1252var DIRECTION_RIGHT = 4;
1253var DIRECTION_UP = 8;
1254var DIRECTION_DOWN = 16;
1255
1256var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
1257var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
1258var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
1259
1260var PROPS_XY = ['x', 'y'];
1261var PROPS_CLIENT_XY = ['clientX', 'clientY'];
1262
1263/**
1264 * create new input type manager
1265 * @param {Manager} manager
1266 * @param {Function} callback
1267 * @returns {Input}
1268 * @constructor
1269 */
1270function Input(manager, callback) {
1271    var self = this;
1272    this.manager = manager;
1273    this.callback = callback;
1274    this.element = manager.element;
1275    this.target = manager.options.inputTarget;
1276
1277    // smaller wrapper around the handler, for the scope and the enabled state of the manager,
1278    // so when disabled the input events are completely bypassed.
1279    this.domHandler = function(ev) {
1280        if (boolOrFn(manager.options.enable, [manager])) {
1281            self.handler(ev);
1282        }
1283    };
1284
1285    this.init();
1286
1287}
1288
1289Input.prototype = {
1290    /**
1291     * should handle the inputEvent data and trigger the callback
1292     * @virtual
1293     */
1294    handler: function() { },
1295
1296    /**
1297     * bind the events
1298     */
1299    init: function() {
1300        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
1301        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
1302        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
1303    },
1304
1305    /**
1306     * unbind the events
1307     */
1308    destroy: function() {
1309        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
1310        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
1311        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
1312    }
1313};
1314
1315/**
1316 * create new input type manager
1317 * called by the Manager constructor
1318 * @param {Hammer} manager
1319 * @returns {Input}
1320 */
1321function createInputInstance(manager) {
1322    var Type;
1323    var inputClass = manager.options.inputClass;
1324
1325    if (inputClass) {
1326        Type = inputClass;
1327    } else if (SUPPORT_POINTER_EVENTS) {
1328        Type = PointerEventInput;
1329    } else if (SUPPORT_ONLY_TOUCH) {
1330        Type = TouchInput;
1331    } else if (!SUPPORT_TOUCH) {
1332        Type = MouseInput;
1333    } else {
1334        Type = TouchMouseInput;
1335    }
1336    return new (Type)(manager, inputHandler);
1337}
1338
1339/**
1340 * handle input events
1341 * @param {Manager} manager
1342 * @param {String} eventType
1343 * @param {Object} input
1344 */
1345function inputHandler(manager, eventType, input) {
1346    var pointersLen = input.pointers.length;
1347    var changedPointersLen = input.changedPointers.length;
1348    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
1349    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
1350
1351    input.isFirst = !!isFirst;
1352    input.isFinal = !!isFinal;
1353
1354    if (isFirst) {
1355        manager.session = {};
1356    }
1357
1358    // source event is the normalized value of the domEvents
1359    // like 'touchstart, mouseup, pointerdown'
1360    input.eventType = eventType;
1361
1362    // compute scale, rotation etc
1363    computeInputData(manager, input);
1364
1365    // emit secret event
1366    manager.emit('hammer.input', input);
1367
1368    manager.recognize(input);
1369    manager.session.prevInput = input;
1370}
1371
1372/**
1373 * extend the data with some usable properties like scale, rotate, velocity etc
1374 * @param {Object} manager
1375 * @param {Object} input
1376 */
1377function computeInputData(manager, input) {
1378    var session = manager.session;
1379    var pointers = input.pointers;
1380    var pointersLength = pointers.length;
1381
1382    // store the first input to calculate the distance and direction
1383    if (!session.firstInput) {
1384        session.firstInput = simpleCloneInputData(input);
1385    }
1386
1387    // to compute scale and rotation we need to store the multiple touches
1388    if (pointersLength > 1 && !session.firstMultiple) {
1389        session.firstMultiple = simpleCloneInputData(input);
1390    } else if (pointersLength === 1) {
1391        session.firstMultiple = false;
1392    }
1393
1394    var firstInput = session.firstInput;
1395    var firstMultiple = session.firstMultiple;
1396    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
1397
1398    var center = input.center = getCenter(pointers);
1399    input.timeStamp = now();
1400    input.deltaTime = input.timeStamp - firstInput.timeStamp;
1401
1402    input.angle = getAngle(offsetCenter, center);
1403    input.distance = getDistance(offsetCenter, center);
1404
1405    computeDeltaXY(session, input);
1406    input.offsetDirection = getDirection(input.deltaX, input.deltaY);
1407
1408    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
1409    input.overallVelocityX = overallVelocity.x;
1410    input.overallVelocityY = overallVelocity.y;
1411    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;
1412
1413    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
1414    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
1415
1416    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >
1417        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);
1418
1419    computeIntervalInputData(session, input);
1420
1421    // find the correct target
1422    var target = manager.element;
1423    if (hasParent(input.srcEvent.target, target)) {
1424        target = input.srcEvent.target;
1425    }
1426    input.target = target;
1427}
1428
1429function computeDeltaXY(session, input) {
1430    var center = input.center;
1431    var offset = session.offsetDelta || {};
1432    var prevDelta = session.prevDelta || {};
1433    var prevInput = session.prevInput || {};
1434
1435    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
1436        prevDelta = session.prevDelta = {
1437            x: prevInput.deltaX || 0,
1438            y: prevInput.deltaY || 0
1439        };
1440
1441        offset = session.offsetDelta = {
1442            x: center.x,
1443            y: center.y
1444        };
1445    }
1446
1447    input.deltaX = prevDelta.x + (center.x - offset.x);
1448    input.deltaY = prevDelta.y + (center.y - offset.y);
1449}
1450
1451/**
1452 * velocity is calculated every x ms
1453 * @param {Object} session
1454 * @param {Object} input
1455 */
1456function computeIntervalInputData(session, input) {
1457    var last = session.lastInterval || input,
1458        deltaTime = input.timeStamp - last.timeStamp,
1459        velocity, velocityX, velocityY, direction;
1460
1461    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
1462        var deltaX = input.deltaX - last.deltaX;
1463        var deltaY = input.deltaY - last.deltaY;
1464
1465        var v = getVelocity(deltaTime, deltaX, deltaY);
1466        velocityX = v.x;
1467        velocityY = v.y;
1468        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
1469        direction = getDirection(deltaX, deltaY);
1470
1471        session.lastInterval = input;
1472    } else {
1473        // use latest velocity info if it doesn't overtake a minimum period
1474        velocity = last.velocity;
1475        velocityX = last.velocityX;
1476        velocityY = last.velocityY;
1477        direction = last.direction;
1478    }
1479
1480    input.velocity = velocity;
1481    input.velocityX = velocityX;
1482    input.velocityY = velocityY;
1483    input.direction = direction;
1484}
1485
1486/**
1487 * create a simple clone from the input used for storage of firstInput and firstMultiple
1488 * @param {Object} input
1489 * @returns {Object} clonedInputData
1490 */
1491function simpleCloneInputData(input) {
1492    // make a simple copy of the pointers because we will get a reference if we don't
1493    // we only need clientXY for the calculations
1494    var pointers = [];
1495    var i = 0;
1496    while (i < input.pointers.length) {
1497        pointers[i] = {
1498            clientX: round(input.pointers[i].clientX),
1499            clientY: round(input.pointers[i].clientY)
1500        };
1501        i++;
1502    }
1503
1504    return {
1505        timeStamp: now(),
1506        pointers: pointers,
1507        center: getCenter(pointers),
1508        deltaX: input.deltaX,
1509        deltaY: input.deltaY
1510    };
1511}
1512
1513/**
1514 * get the center of all the pointers
1515 * @param {Array} pointers
1516 * @return {Object} center contains `x` and `y` properties
1517 */
1518function getCenter(pointers) {
1519    var pointersLength = pointers.length;
1520
1521    // no need to loop when only one touch
1522    if (pointersLength === 1) {
1523        return {
1524            x: round(pointers[0].clientX),
1525            y: round(pointers[0].clientY)
1526        };
1527    }
1528
1529    var x = 0, y = 0, i = 0;
1530    while (i < pointersLength) {
1531        x += pointers[i].clientX;
1532        y += pointers[i].clientY;
1533        i++;
1534    }
1535
1536    return {
1537        x: round(x / pointersLength),
1538        y: round(y / pointersLength)
1539    };
1540}
1541
1542/**
1543 * calculate the velocity between two points. unit is in px per ms.
1544 * @param {Number} deltaTime
1545 * @param {Number} x
1546 * @param {Number} y
1547 * @return {Object} velocity `x` and `y`
1548 */
1549function getVelocity(deltaTime, x, y) {
1550    return {
1551        x: x / deltaTime || 0,
1552        y: y / deltaTime || 0
1553    };
1554}
1555
1556/**
1557 * get the direction between two points
1558 * @param {Number} x
1559 * @param {Number} y
1560 * @return {Number} direction
1561 */
1562function getDirection(x, y) {
1563    if (x === y) {
1564        return DIRECTION_NONE;
1565    }
1566
1567    if (abs(x) >= abs(y)) {
1568        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
1569    }
1570    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
1571}
1572
1573/**
1574 * calculate the absolute distance between two points
1575 * @param {Object} p1 {x, y}
1576 * @param {Object} p2 {x, y}
1577 * @param {Array} [props] containing x and y keys
1578 * @return {Number} distance
1579 */
1580function getDistance(p1, p2, props) {
1581    if (!props) {
1582        props = PROPS_XY;
1583    }
1584    var x = p2[props[0]] - p1[props[0]],
1585        y = p2[props[1]] - p1[props[1]];
1586
1587    return Math.sqrt((x * x) + (y * y));
1588}
1589
1590/**
1591 * calculate the angle between two coordinates
1592 * @param {Object} p1
1593 * @param {Object} p2
1594 * @param {Array} [props] containing x and y keys
1595 * @return {Number} angle
1596 */
1597function getAngle(p1, p2, props) {
1598    if (!props) {
1599        props = PROPS_XY;
1600    }
1601    var x = p2[props[0]] - p1[props[0]],
1602        y = p2[props[1]] - p1[props[1]];
1603    return Math.atan2(y, x) * 180 / Math.PI;
1604}
1605
1606/**
1607 * calculate the rotation degrees between two pointersets
1608 * @param {Array} start array of pointers
1609 * @param {Array} end array of pointers
1610 * @return {Number} rotation
1611 */
1612function getRotation(start, end) {
1613    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
1614}
1615
1616/**
1617 * calculate the scale factor between two pointersets
1618 * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
1619 * @param {Array} start array of pointers
1620 * @param {Array} end array of pointers
1621 * @return {Number} scale
1622 */
1623function getScale(start, end) {
1624    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
1625}
1626
1627var MOUSE_INPUT_MAP = {
1628    mousedown: INPUT_START,
1629    mousemove: INPUT_MOVE,
1630    mouseup: INPUT_END
1631};
1632
1633var MOUSE_ELEMENT_EVENTS = 'mousedown';
1634var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
1635
1636/**
1637 * Mouse events input
1638 * @constructor
1639 * @extends Input
1640 */
1641function MouseInput() {
1642    this.evEl = MOUSE_ELEMENT_EVENTS;
1643    this.evWin = MOUSE_WINDOW_EVENTS;
1644
1645    this.pressed = false; // mousedown state
1646
1647    Input.apply(this, arguments);
1648}
1649
1650inherit(MouseInput, Input, {
1651    /**
1652     * handle mouse events
1653     * @param {Object} ev
1654     */
1655    handler: function MEhandler(ev) {
1656        var eventType = MOUSE_INPUT_MAP[ev.type];
1657
1658        // on start we want to have the left mouse button down
1659        if (eventType & INPUT_START && ev.button === 0) {
1660            this.pressed = true;
1661        }
1662
1663        if (eventType & INPUT_MOVE && ev.which !== 1) {
1664            eventType = INPUT_END;
1665        }
1666
1667        // mouse must be down
1668        if (!this.pressed) {
1669            return;
1670        }
1671
1672        if (eventType & INPUT_END) {
1673            this.pressed = false;
1674        }
1675
1676        this.callback(this.manager, eventType, {
1677            pointers: [ev],
1678            changedPointers: [ev],
1679            pointerType: INPUT_TYPE_MOUSE,
1680            srcEvent: ev
1681        });
1682    }
1683});
1684
1685var POINTER_INPUT_MAP = {
1686    pointerdown: INPUT_START,
1687    pointermove: INPUT_MOVE,
1688    pointerup: INPUT_END,
1689    pointercancel: INPUT_CANCEL,
1690    pointerout: INPUT_CANCEL
1691};
1692
1693// in IE10 the pointer types is defined as an enum
1694var IE10_POINTER_TYPE_ENUM = {
1695    2: INPUT_TYPE_TOUCH,
1696    3: INPUT_TYPE_PEN,
1697    4: INPUT_TYPE_MOUSE,
1698    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
1699};
1700
1701var POINTER_ELEMENT_EVENTS = 'pointerdown';
1702var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
1703
1704// IE10 has prefixed support, and case-sensitive
1705if (window.MSPointerEvent && !window.PointerEvent) {
1706    POINTER_ELEMENT_EVENTS = 'MSPointerDown';
1707    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
1708}
1709
1710/**
1711 * Pointer events input
1712 * @constructor
1713 * @extends Input
1714 */
1715function PointerEventInput() {
1716    this.evEl = POINTER_ELEMENT_EVENTS;
1717    this.evWin = POINTER_WINDOW_EVENTS;
1718
1719    Input.apply(this, arguments);
1720
1721    this.store = (this.manager.session.pointerEvents = []);
1722}
1723
1724inherit(PointerEventInput, Input, {
1725    /**
1726     * handle mouse events
1727     * @param {Object} ev
1728     */
1729    handler: function PEhandler(ev) {
1730        var store = this.store;
1731        var removePointer = false;
1732
1733        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
1734        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
1735        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
1736
1737        var isTouch = (pointerType == INPUT_TYPE_TOUCH);
1738
1739        // get index of the event in the store
1740        var storeIndex = inArray(store, ev.pointerId, 'pointerId');
1741
1742        // start and mouse must be down
1743        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
1744            if (storeIndex < 0) {
1745                store.push(ev);
1746                storeIndex = store.length - 1;
1747            }
1748        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
1749            removePointer = true;
1750        }
1751
1752        // it not found, so the pointer hasn't been down (so it's probably a hover)
1753        if (storeIndex < 0) {
1754            return;
1755        }
1756
1757        // update the event in the store
1758        store[storeIndex] = ev;
1759
1760        this.callback(this.manager, eventType, {
1761            pointers: store,
1762            changedPointers: [ev],
1763            pointerType: pointerType,
1764            srcEvent: ev
1765        });
1766
1767        if (removePointer) {
1768            // remove from the store
1769            store.splice(storeIndex, 1);
1770        }
1771    }
1772});
1773
1774var SINGLE_TOUCH_INPUT_MAP = {
1775    touchstart: INPUT_START,
1776    touchmove: INPUT_MOVE,
1777    touchend: INPUT_END,
1778    touchcancel: INPUT_CANCEL
1779};
1780
1781var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
1782var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
1783
1784/**
1785 * Touch events input
1786 * @constructor
1787 * @extends Input
1788 */
1789function SingleTouchInput() {
1790    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
1791    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
1792    this.started = false;
1793
1794    Input.apply(this, arguments);
1795}
1796
1797inherit(SingleTouchInput, Input, {
1798    handler: function TEhandler(ev) {
1799        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
1800
1801        // should we handle the touch events?
1802        if (type === INPUT_START) {
1803            this.started = true;
1804        }
1805
1806        if (!this.started) {
1807            return;
1808        }
1809
1810        var touches = normalizeSingleTouches.call(this, ev, type);
1811
1812        // when done, reset the started state
1813        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
1814            this.started = false;
1815        }
1816
1817        this.callback(this.manager, type, {
1818            pointers: touches[0],
1819            changedPointers: touches[1],
1820            pointerType: INPUT_TYPE_TOUCH,
1821            srcEvent: ev
1822        });
1823    }
1824});
1825
1826/**
1827 * @this {TouchInput}
1828 * @param {Object} ev
1829 * @param {Number} type flag
1830 * @returns {undefined|Array} [all, changed]
1831 */
1832function normalizeSingleTouches(ev, type) {
1833    var all = toArray(ev.touches);
1834    var changed = toArray(ev.changedTouches);
1835
1836    if (type & (INPUT_END | INPUT_CANCEL)) {
1837        all = uniqueArray(all.concat(changed), 'identifier', true);
1838    }
1839
1840    return [all, changed];
1841}
1842
1843var TOUCH_INPUT_MAP = {
1844    touchstart: INPUT_START,
1845    touchmove: INPUT_MOVE,
1846    touchend: INPUT_END,
1847    touchcancel: INPUT_CANCEL
1848};
1849
1850var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
1851
1852/**
1853 * Multi-user touch events input
1854 * @constructor
1855 * @extends Input
1856 */
1857function TouchInput() {
1858    this.evTarget = TOUCH_TARGET_EVENTS;
1859    this.targetIds = {};
1860
1861    Input.apply(this, arguments);
1862}
1863
1864inherit(TouchInput, Input, {
1865    handler: function MTEhandler(ev) {
1866        var type = TOUCH_INPUT_MAP[ev.type];
1867        var touches = getTouches.call(this, ev, type);
1868        if (!touches) {
1869            return;
1870        }
1871
1872        this.callback(this.manager, type, {
1873            pointers: touches[0],
1874            changedPointers: touches[1],
1875            pointerType: INPUT_TYPE_TOUCH,
1876            srcEvent: ev
1877        });
1878    }
1879});
1880
1881/**
1882 * @this {TouchInput}
1883 * @param {Object} ev
1884 * @param {Number} type flag
1885 * @returns {undefined|Array} [all, changed]
1886 */
1887function getTouches(ev, type) {
1888    var allTouches = toArray(ev.touches);
1889    var targetIds = this.targetIds;
1890
1891    // when there is only one touch, the process can be simplified
1892    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
1893        targetIds[allTouches[0].identifier] = true;
1894        return [allTouches, allTouches];
1895    }
1896
1897    var i,
1898        targetTouches,
1899        changedTouches = toArray(ev.changedTouches),
1900        changedTargetTouches = [],
1901        target = this.target;
1902
1903    // get target touches from touches
1904    targetTouches = allTouches.filter(function(touch) {
1905        return hasParent(touch.target, target);
1906    });
1907
1908    // collect touches
1909    if (type === INPUT_START) {
1910        i = 0;
1911        while (i < targetTouches.length) {
1912            targetIds[targetTouches[i].identifier] = true;
1913            i++;
1914        }
1915    }
1916
1917    // filter changed touches to only contain touches that exist in the collected target ids
1918    i = 0;
1919    while (i < changedTouches.length) {
1920        if (targetIds[changedTouches[i].identifier]) {
1921            changedTargetTouches.push(changedTouches[i]);
1922        }
1923
1924        // cleanup removed touches
1925        if (type & (INPUT_END | INPUT_CANCEL)) {
1926            delete targetIds[changedTouches[i].identifier];
1927        }
1928        i++;
1929    }
1930
1931    if (!changedTargetTouches.length) {
1932        return;
1933    }
1934
1935    return [
1936        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
1937        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
1938        changedTargetTouches
1939    ];
1940}
1941
1942/**
1943 * Combined touch and mouse input
1944 *
1945 * Touch has a higher priority then mouse, and while touching no mouse events are allowed.
1946 * This because touch devices also emit mouse events while doing a touch.
1947 *
1948 * @constructor
1949 * @extends Input
1950 */
1951
1952var DEDUP_TIMEOUT = 2500;
1953var DEDUP_DISTANCE = 25;
1954
1955function TouchMouseInput() {
1956    Input.apply(this, arguments);
1957
1958    var handler = bindFn(this.handler, this);
1959    this.touch = new TouchInput(this.manager, handler);
1960    this.mouse = new MouseInput(this.manager, handler);
1961
1962    this.primaryTouch = null;
1963    this.lastTouches = [];
1964}
1965
1966inherit(TouchMouseInput, Input, {
1967    /**
1968     * handle mouse and touch events
1969     * @param {Hammer} manager
1970     * @param {String} inputEvent
1971     * @param {Object} inputData
1972     */
1973    handler: function TMEhandler(manager, inputEvent, inputData) {
1974        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),
1975            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
1976
1977        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
1978            return;
1979        }
1980
1981        // when we're in a touch event, record touches to  de-dupe synthetic mouse event
1982        if (isTouch) {
1983            recordTouches.call(this, inputEvent, inputData);
1984        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {
1985            return;
1986        }
1987
1988        this.callback(manager, inputEvent, inputData);
1989    },
1990
1991    /**
1992     * remove the event listeners
1993     */
1994    destroy: function destroy() {
1995        this.touch.destroy();
1996        this.mouse.destroy();
1997    }
1998});
1999
2000function recordTouches(eventType, eventData) {
2001    if (eventType & INPUT_START) {
2002        this.primaryTouch = eventData.changedPointers[0].identifier;
2003        setLastTouch.call(this, eventData);
2004    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
2005        setLastTouch.call(this, eventData);
2006    }
2007}
2008
2009function setLastTouch(eventData) {
2010    var touch = eventData.changedPointers[0];
2011
2012    if (touch.identifier === this.primaryTouch) {
2013        var lastTouch = {x: touch.clientX, y: touch.clientY};
2014        this.lastTouches.push(lastTouch);
2015        var lts = this.lastTouches;
2016        var removeLastTouch = function() {
2017            var i = lts.indexOf(lastTouch);
2018            if (i > -1) {
2019                lts.splice(i, 1);
2020            }
2021        };
2022        setTimeout(removeLastTouch, DEDUP_TIMEOUT);
2023    }
2024}
2025
2026function isSyntheticEvent(eventData) {
2027    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;
2028    for (var i = 0; i < this.lastTouches.length; i++) {
2029        var t = this.lastTouches[i];
2030        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
2031        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
2032            return true;
2033        }
2034    }
2035    return false;
2036}
2037
2038var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
2039var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
2040
2041// magical touchAction value
2042var TOUCH_ACTION_COMPUTE = 'compute';
2043var TOUCH_ACTION_AUTO = 'auto';
2044var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
2045var TOUCH_ACTION_NONE = 'none';
2046var TOUCH_ACTION_PAN_X = 'pan-x';
2047var TOUCH_ACTION_PAN_Y = 'pan-y';
2048var TOUCH_ACTION_MAP = getTouchActionProps();
2049
2050/**
2051 * Touch Action
2052 * sets the touchAction property or uses the js alternative
2053 * @param {Manager} manager
2054 * @param {String} value
2055 * @constructor
2056 */
2057function TouchAction(manager, value) {
2058    this.manager = manager;
2059    this.set(value);
2060}
2061
2062TouchAction.prototype = {
2063    /**
2064     * set the touchAction value on the element or enable the polyfill
2065     * @param {String} value
2066     */
2067    set: function(value) {
2068        // find out the touch-action by the event handlers
2069        if (value == TOUCH_ACTION_COMPUTE) {
2070            value = this.compute();
2071        }
2072
2073        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
2074            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
2075        }
2076        this.actions = value.toLowerCase().trim();
2077    },
2078
2079    /**
2080     * just re-set the touchAction value
2081     */
2082    update: function() {
2083        this.set(this.manager.options.touchAction);
2084    },
2085
2086    /**
2087     * compute the value for the touchAction property based on the recognizer's settings
2088     * @returns {String} value
2089     */
2090    compute: function() {
2091        var actions = [];
2092        each(this.manager.recognizers, function(recognizer) {
2093            if (boolOrFn(recognizer.options.enable, [recognizer])) {
2094                actions = actions.concat(recognizer.getTouchAction());
2095            }
2096        });
2097        return cleanTouchActions(actions.join(' '));
2098    },
2099
2100    /**
2101     * this method is called on each input cycle and provides the preventing of the browser behavior
2102     * @param {Object} input
2103     */
2104    preventDefaults: function(input) {
2105        var srcEvent = input.srcEvent;
2106        var direction = input.offsetDirection;
2107
2108        // if the touch action did prevented once this session
2109        if (this.manager.session.prevented) {
2110            srcEvent.preventDefault();
2111            return;
2112        }
2113
2114        var actions = this.actions;
2115        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
2116        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
2117        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
2118
2119        if (hasNone) {
2120            //do not prevent defaults if this is a tap gesture
2121
2122            var isTapPointer = input.pointers.length === 1;
2123            var isTapMovement = input.distance < 2;
2124            var isTapTouchTime = input.deltaTime < 250;
2125
2126            if (isTapPointer && isTapMovement && isTapTouchTime) {
2127                return;
2128            }
2129        }
2130
2131        if (hasPanX && hasPanY) {
2132            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
2133            return;
2134        }
2135
2136        if (hasNone ||
2137            (hasPanY && direction & DIRECTION_HORIZONTAL) ||
2138            (hasPanX && direction & DIRECTION_VERTICAL)) {
2139            return this.preventSrc(srcEvent);
2140        }
2141    },
2142
2143    /**
2144     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
2145     * @param {Object} srcEvent
2146     */
2147    preventSrc: function(srcEvent) {
2148        this.manager.session.prevented = true;
2149        srcEvent.preventDefault();
2150    }
2151};
2152
2153/**
2154 * when the touchActions are collected they are not a valid value, so we need to clean things up. *
2155 * @param {String} actions
2156 * @returns {*}
2157 */
2158function cleanTouchActions(actions) {
2159    // none
2160    if (inStr(actions, TOUCH_ACTION_NONE)) {
2161        return TOUCH_ACTION_NONE;
2162    }
2163
2164    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
2165    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
2166
2167    // if both pan-x and pan-y are set (different recognizers
2168    // for different directions, e.g. horizontal pan but vertical swipe?)
2169    // we need none (as otherwise with pan-x pan-y combined none of these
2170    // recognizers will work, since the browser would handle all panning
2171    if (hasPanX && hasPanY) {
2172        return TOUCH_ACTION_NONE;
2173    }
2174
2175    // pan-x OR pan-y
2176    if (hasPanX || hasPanY) {
2177        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
2178    }
2179
2180    // manipulation
2181    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
2182        return TOUCH_ACTION_MANIPULATION;
2183    }
2184
2185    return TOUCH_ACTION_AUTO;
2186}
2187
2188function getTouchActionProps() {
2189    if (!NATIVE_TOUCH_ACTION) {
2190        return false;
2191    }
2192    var touchMap = {};
2193    var cssSupports = window.CSS && window.CSS.supports;
2194    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {
2195
2196        // If css.supports is not supported but there is native touch-action assume it supports
2197        // all values. This is the case for IE 10 and 11.
2198        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;
2199    });
2200    return touchMap;
2201}
2202
2203/**
2204 * Recognizer flow explained; *
2205 * All recognizers have the initial state of POSSIBLE when a input session starts.
2206 * The definition of a input session is from the first input until the last input, with all it's movement in it. *
2207 * Example session for mouse-input: mousedown -> mousemove -> mouseup
2208 *
2209 * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
2210 * which determines with state it should be.
2211 *
2212 * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
2213 * POSSIBLE to give it another change on the next cycle.
2214 *
2215 *               Possible
2216 *                  |
2217 *            +-----+---------------+
2218 *            |                     |
2219 *      +-----+-----+               |
2220 *      |           |               |
2221 *   Failed      Cancelled          |
2222 *                          +-------+------+
2223 *                          |              |
2224 *                      Recognized       Began
2225 *                                         |
2226 *                                      Changed
2227 *                                         |
2228 *                                  Ended/Recognized
2229 */
2230var STATE_POSSIBLE = 1;
2231var STATE_BEGAN = 2;
2232var STATE_CHANGED = 4;
2233var STATE_ENDED = 8;
2234var STATE_RECOGNIZED = STATE_ENDED;
2235var STATE_CANCELLED = 16;
2236var STATE_FAILED = 32;
2237
2238/**
2239 * Recognizer
2240 * Every recognizer needs to extend from this class.
2241 * @constructor
2242 * @param {Object} options
2243 */
2244function Recognizer(options) {
2245    this.options = assign({}, this.defaults, options || {});
2246
2247    this.id = uniqueId();
2248
2249    this.manager = null;
2250
2251    // default is enable true
2252    this.options.enable = ifUndefined(this.options.enable, true);
2253
2254    this.state = STATE_POSSIBLE;
2255
2256    this.simultaneous = {};
2257    this.requireFail = [];
2258}
2259
2260Recognizer.prototype = {
2261    /**
2262     * @virtual
2263     * @type {Object}
2264     */
2265    defaults: {},
2266
2267    /**
2268     * set options
2269     * @param {Object} options
2270     * @return {Recognizer}
2271     */
2272    set: function(options) {
2273        assign(this.options, options);
2274
2275        // also update the touchAction, in case something changed about the directions/enabled state
2276        this.manager && this.manager.touchAction.update();
2277        return this;
2278    },
2279
2280    /**
2281     * recognize simultaneous with an other recognizer.
2282     * @param {Recognizer} otherRecognizer
2283     * @returns {Recognizer} this
2284     */
2285    recognizeWith: function(otherRecognizer) {
2286        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
2287            return this;
2288        }
2289
2290        var simultaneous = this.simultaneous;
2291        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
2292        if (!simultaneous[otherRecognizer.id]) {
2293            simultaneous[otherRecognizer.id] = otherRecognizer;
2294            otherRecognizer.recognizeWith(this);
2295        }
2296        return this;
2297    },
2298
2299    /**
2300     * drop the simultaneous link. it doesnt remove the link on the other recognizer.
2301     * @param {Recognizer} otherRecognizer
2302     * @returns {Recognizer} this
2303     */
2304    dropRecognizeWith: function(otherRecognizer) {
2305        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
2306            return this;
2307        }
2308
2309        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
2310        delete this.simultaneous[otherRecognizer.id];
2311        return this;
2312    },
2313
2314    /**
2315     * recognizer can only run when an other is failing
2316     * @param {Recognizer} otherRecognizer
2317     * @returns {Recognizer} this
2318     */
2319    requireFailure: function(otherRecognizer) {
2320        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
2321            return this;
2322        }
2323
2324        var requireFail = this.requireFail;
2325        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
2326        if (inArray(requireFail, otherRecognizer) === -1) {
2327            requireFail.push(otherRecognizer);
2328            otherRecognizer.requireFailure(this);
2329        }
2330        return this;
2331    },
2332
2333    /**
2334     * drop the requireFailure link. it does not remove the link on the other recognizer.
2335     * @param {Recognizer} otherRecognizer
2336     * @returns {Recognizer} this
2337     */
2338    dropRequireFailure: function(otherRecognizer) {
2339        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
2340            return this;
2341        }
2342
2343        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
2344        var index = inArray(this.requireFail, otherRecognizer);
2345        if (index > -1) {
2346            this.requireFail.splice(index, 1);
2347        }
2348        return this;
2349    },
2350
2351    /**
2352     * has require failures boolean
2353     * @returns {boolean}
2354     */
2355    hasRequireFailures: function() {
2356        return this.requireFail.length > 0;
2357    },
2358
2359    /**
2360     * if the recognizer can recognize simultaneous with an other recognizer
2361     * @param {Recognizer} otherRecognizer
2362     * @returns {Boolean}
2363     */
2364    canRecognizeWith: function(otherRecognizer) {
2365        return !!this.simultaneous[otherRecognizer.id];
2366    },
2367
2368    /**
2369     * You should use `tryEmit` instead of `emit` directly to check
2370     * that all the needed recognizers has failed before emitting.
2371     * @param {Object} input
2372     */
2373    emit: function(input) {
2374        var self = this;
2375        var state = this.state;
2376
2377        function emit(event) {
2378            self.manager.emit(event, input);
2379        }
2380
2381        // 'panstart' and 'panmove'
2382        if (state < STATE_ENDED) {
2383            emit(self.options.event + stateStr(state));
2384        }
2385
2386        emit(self.options.event); // simple 'eventName' events
2387
2388        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)
2389            emit(input.additionalEvent);
2390        }
2391
2392        // panend and pancancel
2393        if (state >= STATE_ENDED) {
2394            emit(self.options.event + stateStr(state));
2395        }
2396    },
2397
2398    /**
2399     * Check that all the require failure recognizers has failed,
2400     * if true, it emits a gesture event,
2401     * otherwise, setup the state to FAILED.
2402     * @param {Object} input
2403     */
2404    tryEmit: function(input) {
2405        if (this.canEmit()) {
2406            return this.emit(input);
2407        }
2408        // it's failing anyway
2409        this.state = STATE_FAILED;
2410    },
2411
2412    /**
2413     * can we emit?
2414     * @returns {boolean}
2415     */
2416    canEmit: function() {
2417        var i = 0;
2418        while (i < this.requireFail.length) {
2419            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
2420                return false;
2421            }
2422            i++;
2423        }
2424        return true;
2425    },
2426
2427    /**
2428     * update the recognizer
2429     * @param {Object} inputData
2430     */
2431    recognize: function(inputData) {
2432        // make a new copy of the inputData
2433        // so we can change the inputData without messing up the other recognizers
2434        var inputDataClone = assign({}, inputData);
2435
2436        // is is enabled and allow recognizing?
2437        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
2438            this.reset();
2439            this.state = STATE_FAILED;
2440            return;
2441        }
2442
2443        // reset when we've reached the end
2444        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
2445            this.state = STATE_POSSIBLE;
2446        }
2447
2448        this.state = this.process(inputDataClone);
2449
2450        // the recognizer has recognized a gesture
2451        // so trigger an event
2452        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
2453            this.tryEmit(inputDataClone);
2454        }
2455    },
2456
2457    /**
2458     * return the state of the recognizer
2459     * the actual recognizing happens in this method
2460     * @virtual
2461     * @param {Object} inputData
2462     * @returns {Const} STATE
2463     */
2464    process: function(inputData) { }, // jshint ignore:line
2465
2466    /**
2467     * return the preferred touch-action
2468     * @virtual
2469     * @returns {Array}
2470     */
2471    getTouchAction: function() { },
2472
2473    /**
2474     * called when the gesture isn't allowed to recognize
2475     * like when another is being recognized or it is disabled
2476     * @virtual
2477     */
2478    reset: function() { }
2479};
2480
2481/**
2482 * get a usable string, used as event postfix
2483 * @param {Const} state
2484 * @returns {String} state
2485 */
2486function stateStr(state) {
2487    if (state & STATE_CANCELLED) {
2488        return 'cancel';
2489    } else if (state & STATE_ENDED) {
2490        return 'end';
2491    } else if (state & STATE_CHANGED) {
2492        return 'move';
2493    } else if (state & STATE_BEGAN) {
2494        return 'start';
2495    }
2496    return '';
2497}
2498
2499/**
2500 * direction cons to string
2501 * @param {Const} direction
2502 * @returns {String}
2503 */
2504function directionStr(direction) {
2505    if (direction == DIRECTION_DOWN) {
2506        return 'down';
2507    } else if (direction == DIRECTION_UP) {
2508        return 'up';
2509    } else if (direction == DIRECTION_LEFT) {
2510        return 'left';
2511    } else if (direction == DIRECTION_RIGHT) {
2512        return 'right';
2513    }
2514    return '';
2515}
2516
2517/**
2518 * get a recognizer by name if it is bound to a manager
2519 * @param {Recognizer|String} otherRecognizer
2520 * @param {Recognizer} recognizer
2521 * @returns {Recognizer}
2522 */
2523function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
2524    var manager = recognizer.manager;
2525    if (manager) {
2526        return manager.get(otherRecognizer);
2527    }
2528    return otherRecognizer;
2529}
2530
2531/**
2532 * This recognizer is just used as a base for the simple attribute recognizers.
2533 * @constructor
2534 * @extends Recognizer
2535 */
2536function AttrRecognizer() {
2537    Recognizer.apply(this, arguments);
2538}
2539
2540inherit(AttrRecognizer, Recognizer, {
2541    /**
2542     * @namespace
2543     * @memberof AttrRecognizer
2544     */
2545    defaults: {
2546        /**
2547         * @type {Number}
2548         * @default 1
2549         */
2550        pointers: 1
2551    },
2552
2553    /**
2554     * Used to check if it the recognizer receives valid input, like input.distance > 10.
2555     * @memberof AttrRecognizer
2556     * @param {Object} input
2557     * @returns {Boolean} recognized
2558     */
2559    attrTest: function(input) {
2560        var optionPointers = this.options.pointers;
2561        return optionPointers === 0 || input.pointers.length === optionPointers;
2562    },
2563
2564    /**
2565     * Process the input and return the state for the recognizer
2566     * @memberof AttrRecognizer
2567     * @param {Object} input
2568     * @returns {*} State
2569     */
2570    process: function(input) {
2571        var state = this.state;
2572        var eventType = input.eventType;
2573
2574        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
2575        var isValid = this.attrTest(input);
2576
2577        // on cancel input and we've recognized before, return STATE_CANCELLED
2578        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
2579            return state | STATE_CANCELLED;
2580        } else if (isRecognized || isValid) {
2581            if (eventType & INPUT_END) {
2582                return state | STATE_ENDED;
2583            } else if (!(state & STATE_BEGAN)) {
2584                return STATE_BEGAN;
2585            }
2586            return state | STATE_CHANGED;
2587        }
2588        return STATE_FAILED;
2589    }
2590});
2591
2592/**
2593 * Pan
2594 * Recognized when the pointer is down and moved in the allowed direction.
2595 * @constructor
2596 * @extends AttrRecognizer
2597 */
2598function PanRecognizer() {
2599    AttrRecognizer.apply(this, arguments);
2600
2601    this.pX = null;
2602    this.pY = null;
2603}
2604
2605inherit(PanRecognizer, AttrRecognizer, {
2606    /**
2607     * @namespace
2608     * @memberof PanRecognizer
2609     */
2610    defaults: {
2611        event: 'pan',
2612        threshold: 10,
2613        pointers: 1,
2614        direction: DIRECTION_ALL
2615    },
2616
2617    getTouchAction: function() {
2618        var direction = this.options.direction;
2619        var actions = [];
2620        if (direction & DIRECTION_HORIZONTAL) {
2621            actions.push(TOUCH_ACTION_PAN_Y);
2622        }
2623        if (direction & DIRECTION_VERTICAL) {
2624            actions.push(TOUCH_ACTION_PAN_X);
2625        }
2626        return actions;
2627    },
2628
2629    directionTest: function(input) {
2630        var options = this.options;
2631        var hasMoved = true;
2632        var distance = input.distance;
2633        var direction = input.direction;
2634        var x = input.deltaX;
2635        var y = input.deltaY;
2636
2637        // lock to axis?
2638        if (!(direction & options.direction)) {
2639            if (options.direction & DIRECTION_HORIZONTAL) {
2640                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
2641                hasMoved = x != this.pX;
2642                distance = Math.abs(input.deltaX);
2643            } else {
2644                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;
2645                hasMoved = y != this.pY;
2646                distance = Math.abs(input.deltaY);
2647            }
2648        }
2649        input.direction = direction;
2650        return hasMoved && distance > options.threshold && direction & options.direction;
2651    },
2652
2653    attrTest: function(input) {
2654        return AttrRecognizer.prototype.attrTest.call(this, input) &&
2655            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
2656    },
2657
2658    emit: function(input) {
2659
2660        this.pX = input.deltaX;
2661        this.pY = input.deltaY;
2662
2663        var direction = directionStr(input.direction);
2664
2665        if (direction) {
2666            input.additionalEvent = this.options.event + direction;
2667        }
2668        this._super.emit.call(this, input);
2669    }
2670});
2671
2672/**
2673 * Pinch
2674 * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
2675 * @constructor
2676 * @extends AttrRecognizer
2677 */
2678function PinchRecognizer() {
2679    AttrRecognizer.apply(this, arguments);
2680}
2681
2682inherit(PinchRecognizer, AttrRecognizer, {
2683    /**
2684     * @namespace
2685     * @memberof PinchRecognizer
2686     */
2687    defaults: {
2688        event: 'pinch',
2689        threshold: 0,
2690        pointers: 2
2691    },
2692
2693    getTouchAction: function() {
2694        return [TOUCH_ACTION_NONE];
2695    },
2696
2697    attrTest: function(input) {
2698        return this._super.attrTest.call(this, input) &&
2699            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
2700    },
2701
2702    emit: function(input) {
2703        if (input.scale !== 1) {
2704            var inOut = input.scale < 1 ? 'in' : 'out';
2705            input.additionalEvent = this.options.event + inOut;
2706        }
2707        this._super.emit.call(this, input);
2708    }
2709});
2710
2711/**
2712 * Press
2713 * Recognized when the pointer is down for x ms without any movement.
2714 * @constructor
2715 * @extends Recognizer
2716 */
2717function PressRecognizer() {
2718    Recognizer.apply(this, arguments);
2719
2720    this._timer = null;
2721    this._input = null;
2722}
2723
2724inherit(PressRecognizer, Recognizer, {
2725    /**
2726     * @namespace
2727     * @memberof PressRecognizer
2728     */
2729    defaults: {
2730        event: 'press',
2731        pointers: 1,
2732        time: 251, // minimal time of the pointer to be pressed
2733        threshold: 9 // a minimal movement is ok, but keep it low
2734    },
2735
2736    getTouchAction: function() {
2737        return [TOUCH_ACTION_AUTO];
2738    },
2739
2740    process: function(input) {
2741        var options = this.options;
2742        var validPointers = input.pointers.length === options.pointers;
2743        var validMovement = input.distance < options.threshold;
2744        var validTime = input.deltaTime > options.time;
2745
2746        this._input = input;
2747
2748        // we only allow little movement
2749        // and we've reached an end event, so a tap is possible
2750        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {
2751            this.reset();
2752        } else if (input.eventType & INPUT_START) {
2753            this.reset();
2754            this._timer = setTimeoutContext(function() {
2755                this.state = STATE_RECOGNIZED;
2756                this.tryEmit();
2757            }, options.time, this);
2758        } else if (input.eventType & INPUT_END) {
2759            return STATE_RECOGNIZED;
2760        }
2761        return STATE_FAILED;
2762    },
2763
2764    reset: function() {
2765        clearTimeout(this._timer);
2766    },
2767
2768    emit: function(input) {
2769        if (this.state !== STATE_RECOGNIZED) {
2770            return;
2771        }
2772
2773        if (input && (input.eventType & INPUT_END)) {
2774            this.manager.emit(this.options.event + 'up', input);
2775        } else {
2776            this._input.timeStamp = now();
2777            this.manager.emit(this.options.event, this._input);
2778        }
2779    }
2780});
2781
2782/**
2783 * Rotate
2784 * Recognized when two or more pointer are moving in a circular motion.
2785 * @constructor
2786 * @extends AttrRecognizer
2787 */
2788function RotateRecognizer() {
2789    AttrRecognizer.apply(this, arguments);
2790}
2791
2792inherit(RotateRecognizer, AttrRecognizer, {
2793    /**
2794     * @namespace
2795     * @memberof RotateRecognizer
2796     */
2797    defaults: {
2798        event: 'rotate',
2799        threshold: 0,
2800        pointers: 2
2801    },
2802
2803    getTouchAction: function() {
2804        return [TOUCH_ACTION_NONE];
2805    },
2806
2807    attrTest: function(input) {
2808        return this._super.attrTest.call(this, input) &&
2809            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
2810    }
2811});
2812
2813/**
2814 * Swipe
2815 * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
2816 * @constructor
2817 * @extends AttrRecognizer
2818 */
2819function SwipeRecognizer() {
2820    AttrRecognizer.apply(this, arguments);
2821}
2822
2823inherit(SwipeRecognizer, AttrRecognizer, {
2824    /**
2825     * @namespace
2826     * @memberof SwipeRecognizer
2827     */
2828    defaults: {
2829        event: 'swipe',
2830        threshold: 10,
2831        velocity: 0.3,
2832        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
2833        pointers: 1
2834    },
2835
2836    getTouchAction: function() {
2837        return PanRecognizer.prototype.getTouchAction.call(this);
2838    },
2839
2840    attrTest: function(input) {
2841        var direction = this.options.direction;
2842        var velocity;
2843
2844        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
2845            velocity = input.overallVelocity;
2846        } else if (direction & DIRECTION_HORIZONTAL) {
2847            velocity = input.overallVelocityX;
2848        } else if (direction & DIRECTION_VERTICAL) {
2849            velocity = input.overallVelocityY;
2850        }
2851
2852        return this._super.attrTest.call(this, input) &&
2853            direction & input.offsetDirection &&
2854            input.distance > this.options.threshold &&
2855            input.maxPointers == this.options.pointers &&
2856            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
2857    },
2858
2859    emit: function(input) {
2860        var direction = directionStr(input.offsetDirection);
2861        if (direction) {
2862            this.manager.emit(this.options.event + direction, input);
2863        }
2864
2865        this.manager.emit(this.options.event, input);
2866    }
2867});
2868
2869/**
2870 * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
2871 * between the given interval and position. The delay option can be used to recognize multi-taps without firing
2872 * a single tap.
2873 *
2874 * The eventData from the emitted event contains the property `tapCount`, which contains the amount of
2875 * multi-taps being recognized.
2876 * @constructor
2877 * @extends Recognizer
2878 */
2879function TapRecognizer() {
2880    Recognizer.apply(this, arguments);
2881
2882    // previous time and center,
2883    // used for tap counting
2884    this.pTime = false;
2885    this.pCenter = false;
2886
2887    this._timer = null;
2888    this._input = null;
2889    this.count = 0;
2890}
2891
2892inherit(TapRecognizer, Recognizer, {
2893    /**
2894     * @namespace
2895     * @memberof PinchRecognizer
2896     */
2897    defaults: {
2898        event: 'tap',
2899        pointers: 1,
2900        taps: 1,
2901        interval: 300, // max time between the multi-tap taps
2902        time: 250, // max time of the pointer to be down (like finger on the screen)
2903        threshold: 9, // a minimal movement is ok, but keep it low
2904        posThreshold: 10 // a multi-tap can be a bit off the initial position
2905    },
2906
2907    getTouchAction: function() {
2908        return [TOUCH_ACTION_MANIPULATION];
2909    },
2910
2911    process: function(input) {
2912        var options = this.options;
2913
2914        var validPointers = input.pointers.length === options.pointers;
2915        var validMovement = input.distance < options.threshold;
2916        var validTouchTime = input.deltaTime < options.time;
2917
2918        this.reset();
2919
2920        if ((input.eventType & INPUT_START) && (this.count === 0)) {
2921            return this.failTimeout();
2922        }
2923
2924        // we only allow little movement
2925        // and we've reached an end event, so a tap is possible
2926        if (validMovement && validTouchTime && validPointers) {
2927            if (input.eventType != INPUT_END) {
2928                return this.failTimeout();
2929            }
2930
2931            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
2932            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
2933
2934            this.pTime = input.timeStamp;
2935            this.pCenter = input.center;
2936
2937            if (!validMultiTap || !validInterval) {
2938                this.count = 1;
2939            } else {
2940                this.count += 1;
2941            }
2942
2943            this._input = input;
2944
2945            // if tap count matches we have recognized it,
2946            // else it has began recognizing...
2947            var tapCount = this.count % options.taps;
2948            if (tapCount === 0) {
2949                // no failing requirements, immediately trigger the tap event
2950                // or wait as long as the multitap interval to trigger
2951                if (!this.hasRequireFailures()) {
2952                    return STATE_RECOGNIZED;
2953                } else {
2954                    this._timer = setTimeoutContext(function() {
2955                        this.state = STATE_RECOGNIZED;
2956                        this.tryEmit();
2957                    }, options.interval, this);
2958                    return STATE_BEGAN;
2959                }
2960            }
2961        }
2962        return STATE_FAILED;
2963    },
2964
2965    failTimeout: function() {
2966        this._timer = setTimeoutContext(function() {
2967            this.state = STATE_FAILED;
2968        }, this.options.interval, this);
2969        return STATE_FAILED;
2970    },
2971
2972    reset: function() {
2973        clearTimeout(this._timer);
2974    },
2975
2976    emit: function() {
2977        if (this.state == STATE_RECOGNIZED) {
2978            this._input.tapCount = this.count;
2979            this.manager.emit(this.options.event, this._input);
2980        }
2981    }
2982});
2983
2984/**
2985 * Simple way to create a manager with a default set of recognizers.
2986 * @param {HTMLElement} element
2987 * @param {Object} [options]
2988 * @constructor
2989 */
2990function Hammer(element, options) {
2991    options = options || {};
2992    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
2993    return new Manager(element, options);
2994}
2995
2996/**
2997 * @const {string}
2998 */
2999Hammer.VERSION = '2.0.7';
3000
3001/**
3002 * default settings
3003 * @namespace
3004 */
3005Hammer.defaults = {
3006    /**
3007     * set if DOM events are being triggered.
3008     * But this is slower and unused by simple implementations, so disabled by default.
3009     * @type {Boolean}
3010     * @default false
3011     */
3012    domEvents: false,
3013
3014    /**
3015     * The value for the touchAction property/fallback.
3016     * When set to `compute` it will magically set the correct value based on the added recognizers.
3017     * @type {String}
3018     * @default compute
3019     */
3020    touchAction: TOUCH_ACTION_COMPUTE,
3021
3022    /**
3023     * @type {Boolean}
3024     * @default true
3025     */
3026    enable: true,
3027
3028    /**
3029     * EXPERIMENTAL FEATURE -- can be removed/changed
3030     * Change the parent input target element.
3031     * If Null, then it is being set the to main element.
3032     * @type {Null|EventTarget}
3033     * @default null
3034     */
3035    inputTarget: null,
3036
3037    /**
3038     * force an input class
3039     * @type {Null|Function}
3040     * @default null
3041     */
3042    inputClass: null,
3043
3044    /**
3045     * Default recognizer setup when calling `Hammer()`
3046     * When creating a new Manager these will be skipped.
3047     * @type {Array}
3048     */
3049    preset: [
3050        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
3051        [RotateRecognizer, {enable: false}],
3052        [PinchRecognizer, {enable: false}, ['rotate']],
3053        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],
3054        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],
3055        [TapRecognizer],
3056        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],
3057        [PressRecognizer]
3058    ],
3059
3060    /**
3061     * Some CSS properties can be used to improve the working of Hammer.
3062     * Add them to this method and they will be set when creating a new Manager.
3063     * @namespace
3064     */
3065    cssProps: {
3066        /**
3067         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
3068         * @type {String}
3069         * @default 'none'
3070         */
3071        userSelect: 'none',
3072
3073        /**
3074         * Disable the Windows Phone grippers when pressing an element.
3075         * @type {String}
3076         * @default 'none'
3077         */
3078        touchSelect: 'none',
3079
3080        /**
3081         * Disables the default callout shown when you touch and hold a touch target.
3082         * On iOS, when you touch and hold a touch target such as a link, Safari displays
3083         * a callout containing information about the link. This property allows you to disable that callout.
3084         * @type {String}
3085         * @default 'none'
3086         */
3087        touchCallout: 'none',
3088
3089        /**
3090         * Specifies whether zooming is enabled. Used by IE10>
3091         * @type {String}
3092         * @default 'none'
3093         */
3094        contentZooming: 'none',
3095
3096        /**
3097         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
3098         * @type {String}
3099         * @default 'none'
3100         */
3101        userDrag: 'none',
3102
3103        /**
3104         * Overrides the highlight color shown when the user taps a link or a JavaScript
3105         * clickable element in iOS. This property obeys the alpha value, if specified.
3106         * @type {String}
3107         * @default 'rgba(0,0,0,0)'
3108         */
3109        tapHighlightColor: 'rgba(0,0,0,0)'
3110    }
3111};
3112
3113var STOP = 1;
3114var FORCED_STOP = 2;
3115
3116/**
3117 * Manager
3118 * @param {HTMLElement} element
3119 * @param {Object} [options]
3120 * @constructor
3121 */
3122function Manager(element, options) {
3123    this.options = assign({}, Hammer.defaults, options || {});
3124
3125    this.options.inputTarget = this.options.inputTarget || element;
3126
3127    this.handlers = {};
3128    this.session = {};
3129    this.recognizers = [];
3130    this.oldCssProps = {};
3131
3132    this.element = element;
3133    this.input = createInputInstance(this);
3134    this.touchAction = new TouchAction(this, this.options.touchAction);
3135
3136    toggleCssProps(this, true);
3137
3138    each(this.options.recognizers, function(item) {
3139        var recognizer = this.add(new (item[0])(item[1]));
3140        item[2] && recognizer.recognizeWith(item[2]);
3141        item[3] && recognizer.requireFailure(item[3]);
3142    }, this);
3143}
3144
3145Manager.prototype = {
3146    /**
3147     * set options
3148     * @param {Object} options
3149     * @returns {Manager}
3150     */
3151    set: function(options) {
3152        assign(this.options, options);
3153
3154        // Options that need a little more setup
3155        if (options.touchAction) {
3156            this.touchAction.update();
3157        }
3158        if (options.inputTarget) {
3159            // Clean up existing event listeners and reinitialize
3160            this.input.destroy();
3161            this.input.target = options.inputTarget;
3162            this.input.init();
3163        }
3164        return this;
3165    },
3166
3167    /**
3168     * stop recognizing for this session.
3169     * This session will be discarded, when a new [input]start event is fired.
3170     * When forced, the recognizer cycle is stopped immediately.
3171     * @param {Boolean} [force]
3172     */
3173    stop: function(force) {
3174        this.session.stopped = force ? FORCED_STOP : STOP;
3175    },
3176
3177    /**
3178     * run the recognizers!
3179     * called by the inputHandler function on every movement of the pointers (touches)
3180     * it walks through all the recognizers and tries to detect the gesture that is being made
3181     * @param {Object} inputData
3182     */
3183    recognize: function(inputData) {
3184        var session = this.session;
3185        if (session.stopped) {
3186            return;
3187        }
3188
3189        // run the touch-action polyfill
3190        this.touchAction.preventDefaults(inputData);
3191
3192        var recognizer;
3193        var recognizers = this.recognizers;
3194
3195        // this holds the recognizer that is being recognized.
3196        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
3197        // if no recognizer is detecting a thing, it is set to `null`
3198        var curRecognizer = session.curRecognizer;
3199
3200        // reset when the last recognizer is recognized
3201        // or when we're in a new session
3202        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
3203            curRecognizer = session.curRecognizer = null;
3204        }
3205
3206        var i = 0;
3207        while (i < recognizers.length) {
3208            recognizer = recognizers[i];
3209
3210            // find out if we are allowed try to recognize the input for this one.
3211            // 1.   allow if the session is NOT forced stopped (see the .stop() method)
3212            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
3213            //      that is being recognized.
3214            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
3215            //      this can be setup with the `recognizeWith()` method on the recognizer.
3216            if (session.stopped !== FORCED_STOP && ( // 1
3217                    !curRecognizer || recognizer == curRecognizer || // 2
3218                    recognizer.canRecognizeWith(curRecognizer))) { // 3
3219                recognizer.recognize(inputData);
3220            } else {
3221                recognizer.reset();
3222            }
3223
3224            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
3225            // current active recognizer. but only if we don't already have an active recognizer
3226            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
3227                curRecognizer = session.curRecognizer = recognizer;
3228            }
3229            i++;
3230        }
3231    },
3232
3233    /**
3234     * get a recognizer by its event name.
3235     * @param {Recognizer|String} recognizer
3236     * @returns {Recognizer|Null}
3237     */
3238    get: function(recognizer) {
3239        if (recognizer instanceof Recognizer) {
3240            return recognizer;
3241        }
3242
3243        var recognizers = this.recognizers;
3244        for (var i = 0; i < recognizers.length; i++) {
3245            if (recognizers[i].options.event == recognizer) {
3246                return recognizers[i];
3247            }
3248        }
3249        return null;
3250    },
3251
3252    /**
3253     * add a recognizer to the manager
3254     * existing recognizers with the same event name will be removed
3255     * @param {Recognizer} recognizer
3256     * @returns {Recognizer|Manager}
3257     */
3258    add: function(recognizer) {
3259        if (invokeArrayArg(recognizer, 'add', this)) {
3260            return this;
3261        }
3262
3263        // remove existing
3264        var existing = this.get(recognizer.options.event);
3265        if (existing) {
3266            this.remove(existing);
3267        }
3268
3269        this.recognizers.push(recognizer);
3270        recognizer.manager = this;
3271
3272        this.touchAction.update();
3273        return recognizer;
3274    },
3275
3276    /**
3277     * remove a recognizer by name or instance
3278     * @param {Recognizer|String} recognizer
3279     * @returns {Manager}
3280     */
3281    remove: function(recognizer) {
3282        if (invokeArrayArg(recognizer, 'remove', this)) {
3283            return this;
3284        }
3285
3286        recognizer = this.get(recognizer);
3287
3288        // let's make sure this recognizer exists
3289        if (recognizer) {
3290            var recognizers = this.recognizers;
3291            var index = inArray(recognizers, recognizer);
3292
3293            if (index !== -1) {
3294                recognizers.splice(index, 1);
3295                this.touchAction.update();
3296            }
3297        }
3298
3299        return this;
3300    },
3301
3302    /**
3303     * bind event
3304     * @param {String} events
3305     * @param {Function} handler
3306     * @returns {EventEmitter} this
3307     */
3308    on: function(events, handler) {
3309        if (events === undefined) {
3310            return;
3311        }
3312        if (handler === undefined) {
3313            return;
3314        }
3315
3316        var handlers = this.handlers;
3317        each(splitStr(events), function(event) {
3318            handlers[event] = handlers[event] || [];
3319            handlers[event].push(handler);
3320        });
3321        return this;
3322    },
3323
3324    /**
3325     * unbind event, leave emit blank to remove all handlers
3326     * @param {String} events
3327     * @param {Function} [handler]
3328     * @returns {EventEmitter} this
3329     */
3330    off: function(events, handler) {
3331        if (events === undefined) {
3332            return;
3333        }
3334
3335        var handlers = this.handlers;
3336        each(splitStr(events), function(event) {
3337            if (!handler) {
3338                delete handlers[event];
3339            } else {
3340                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
3341            }
3342        });
3343        return this;
3344    },
3345
3346    /**
3347     * emit event to the listeners
3348     * @param {String} event
3349     * @param {Object} data
3350     */
3351    emit: function(event, data) {
3352        // we also want to trigger dom events
3353        if (this.options.domEvents) {
3354            triggerDomEvent(event, data);
3355        }
3356
3357        // no handlers, so skip it all
3358        var handlers = this.handlers[event] && this.handlers[event].slice();
3359        if (!handlers || !handlers.length) {
3360            return;
3361        }
3362
3363        data.type = event;
3364        data.preventDefault = function() {
3365            data.srcEvent.preventDefault();
3366        };
3367
3368        var i = 0;
3369        while (i < handlers.length) {
3370            handlers[i](data);
3371            i++;
3372        }
3373    },
3374
3375    /**
3376     * destroy the manager and unbinds all events
3377     * it doesn't unbind dom events, that is the user own responsibility
3378     */
3379    destroy: function() {
3380        this.element && toggleCssProps(this, false);
3381
3382        this.handlers = {};
3383        this.session = {};
3384        this.input.destroy();
3385        this.element = null;
3386    }
3387};
3388
3389/**
3390 * add/remove the css properties as defined in manager.options.cssProps
3391 * @param {Manager} manager
3392 * @param {Boolean} add
3393 */
3394function toggleCssProps(manager, add) {
3395    var element = manager.element;
3396    if (!element.style) {
3397        return;
3398    }
3399    var prop;
3400    each(manager.options.cssProps, function(value, name) {
3401        prop = prefixed(element.style, name);
3402        if (add) {
3403            manager.oldCssProps[prop] = element.style[prop];
3404            element.style[prop] = value;
3405        } else {
3406            element.style[prop] = manager.oldCssProps[prop] || '';
3407        }
3408    });
3409    if (!add) {
3410        manager.oldCssProps = {};
3411    }
3412}
3413
3414/**
3415 * trigger dom event
3416 * @param {String} event
3417 * @param {Object} data
3418 */
3419function triggerDomEvent(event, data) {
3420    var gestureEvent = document.createEvent('Event');
3421    gestureEvent.initEvent(event, true, true);
3422    gestureEvent.gesture = data;
3423    data.target.dispatchEvent(gestureEvent);
3424}
3425
3426assign(Hammer, {
3427    INPUT_START: INPUT_START,
3428    INPUT_MOVE: INPUT_MOVE,
3429    INPUT_END: INPUT_END,
3430    INPUT_CANCEL: INPUT_CANCEL,
3431
3432    STATE_POSSIBLE: STATE_POSSIBLE,
3433    STATE_BEGAN: STATE_BEGAN,
3434    STATE_CHANGED: STATE_CHANGED,
3435    STATE_ENDED: STATE_ENDED,
3436    STATE_RECOGNIZED: STATE_RECOGNIZED,
3437    STATE_CANCELLED: STATE_CANCELLED,
3438    STATE_FAILED: STATE_FAILED,
3439
3440    DIRECTION_NONE: DIRECTION_NONE,
3441    DIRECTION_LEFT: DIRECTION_LEFT,
3442    DIRECTION_RIGHT: DIRECTION_RIGHT,
3443    DIRECTION_UP: DIRECTION_UP,
3444    DIRECTION_DOWN: DIRECTION_DOWN,
3445    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
3446    DIRECTION_VERTICAL: DIRECTION_VERTICAL,
3447    DIRECTION_ALL: DIRECTION_ALL,
3448
3449    Manager: Manager,
3450    Input: Input,
3451    TouchAction: TouchAction,
3452
3453    TouchInput: TouchInput,
3454    MouseInput: MouseInput,
3455    PointerEventInput: PointerEventInput,
3456    TouchMouseInput: TouchMouseInput,
3457    SingleTouchInput: SingleTouchInput,
3458
3459    Recognizer: Recognizer,
3460    AttrRecognizer: AttrRecognizer,
3461    Tap: TapRecognizer,
3462    Pan: PanRecognizer,
3463    Swipe: SwipeRecognizer,
3464    Pinch: PinchRecognizer,
3465    Rotate: RotateRecognizer,
3466    Press: PressRecognizer,
3467
3468    on: addEventListeners,
3469    off: removeEventListeners,
3470    each: each,
3471    merge: merge,
3472    extend: extend,
3473    assign: assign,
3474    inherit: inherit,
3475    bindFn: bindFn,
3476    prefixed: prefixed
3477});
3478
3479// this prevents errors when Hammer is loaded in the presence of an AMD
3480//  style loader but by script tag, not by the loader.
3481var freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line
3482freeGlobal.Hammer = Hammer;
3483
3484if (true) {
3485    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
3486        return Hammer;
3487    }).call(exports, __webpack_require__, exports, module),
3488				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
3489} else {}
3490
3491})(window, document, 'Hammer');
3492
3493
3494/***/ }),
3495