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

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 = 0);
85/******/ })
86/************************************************************************/
87/******/ ({
88

147/***/ "../../../../plugins/upup-baseline-plugin/js/src/menu-button/menu-button.js":
148/*!*************************************************************************************************************************************!*\
149  !*** /Applications/XAMPP/xamppfiles/htdocs/gwu-wordpress/wp-content/plugins/upup-baseline-plugin/js/src/menu-button/menu-button.js ***!
150  \*************************************************************************************************************************************/
151/*! exports provided: default */
152/***/ (function(module, __webpack_exports__, __webpack_require__) {
153
154"use strict";
155__webpack_require__.r(__webpack_exports__);
156/* harmony import */ var velocity_animate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! velocity-animate */ "../../../../plugins/upup-baseline-plugin/node_modules/velocity-animate/velocity.js");
157/* harmony import */ var velocity_animate__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(velocity_animate__WEBPACK_IMPORTED_MODULE_0__);
158/* harmony import */ var _utility__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utility */ "../../../../plugins/upup-baseline-plugin/js/src/utility.js");
159function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
160
161function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
162
163function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
164
165function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
166
167
168/**
169 * Menu button is intended to follow the pattern recommended by W3C for a menu button control
170 * https://www.w3.org/TR/wai-aria-practices-1.1/examples/menu-button/menu-button-links.html
171 *
172 * To do this, the constructor receives the button and the menu
173 * It then applies the correct key handling
174 *
175 * Proper labelling is assumed (aria labels)
176 * It is also assumed that the menu is comprised of links and is one level (or that all items are visible - no collapsed 

887/***/ "../../../../plugins/upup-baseline-plugin/node_modules/velocity-animate/velocity.js":
888/*!*********************************************************************************************************************************************!*\
889  !*** /Applications/XAMPP/xamppfiles/htdocs/gwu-wordpress/wp-content/plugins/upup-baseline-plugin/node_modules/velocity-animate/velocity.js ***!
890  \*********************************************************************************************************************************************/
891/*! no static exports found */
892/***/ (function(module, exports, __webpack_require__) {
893
894var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! VelocityJS.org (1.5.2). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License */
895
896/*************************
897 Velocity jQuery Shim
898 *************************/
899
900/*! VelocityJS.org jQuery Shim (1.0.1). (C) 2014 The jQuery Foundation. MIT @license: en.wikipedia.org/wiki/MIT_License. */
901
902/* This file contains the jQuery functions that Velocity relies on, thereby removing Velocity's dependency on a full copy of jQuery, and allowing it to work in any environment. */
903/* These shimmed functions are only used if jQuery isn't present. If both this shim and jQuery are loaded, Velocity defaults to jQuery proper. */
904/* Browser support: Using this shim instead of jQuery proper removes support for IE8. */
905
906(function(window) {
907	"use strict";
908	/***************
909	 Setup
910	 ***************/
911
912	/* If jQuery is already loaded, there's no point in loading this shim. */
913	if (window.jQuery) {
914		return;
915	}
916
917	/* jQuery base. */
918	var $ = function(selector, context) {
919		return new $.fn.init(selector, context);
920	};
921
922	/********************
923	 Private Methods
924	 ********************/
925
926	/* jQuery */
927	$.isWindow = function(obj) {
928		/* jshint eqeqeq: false */
929		return obj && obj === obj.window;
930	};
931
932	/* jQuery */
933	$.type = function(obj) {
934		if (!obj) {
935			return obj + "";
936		}
937
938		return typeof obj === "object" || typeof obj === "function" ?
939				class2type[toString.call(obj)] || "object" :
940				typeof obj;
941	};
942
943	/* jQuery */
944	$.isArray = Array.isArray || function(obj) {
945		return $.type(obj) === "array";
946	};
947
948	/* jQuery */
949	function isArraylike(obj) {
950		var length = obj.length,
951				type = $.type(obj);
952
953		if (type === "function" || $.isWindow(obj)) {
954			return false;
955		}
956
957		if (obj.nodeType === 1 && length) {
958			return true;
959		}
960
961		return type === "array" || length === 0 || typeof length === "number" && length > 0 && (length - 1) in obj;
962	}
963
964	/***************
965	 $ Methods
966	 ***************/
967
968	/* jQuery: Support removed for IE<9. */
969	$.isPlainObject = function(obj) {
970		var key;
971
972		if (!obj || $.type(obj) !== "object" || obj.nodeType || $.isWindow(obj)) {
973			return false;
974		}
975
976		try {
977			if (obj.constructor &&
978					!hasOwn.call(obj, "constructor") &&
979					!hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
980				return false;
981			}
982		} catch (e) {
983			return false;
984		}
985
986		for (key in obj) {
987		}
988
989		return key === undefined || hasOwn.call(obj, key);
990	};
991
992	/* jQuery */
993	$.each = function(obj, callback, args) {
994		var value,
995				i = 0,
996				length = obj.length,
997				isArray = isArraylike(obj);
998
999		if (args) {
1000			if (isArray) {
1001				for (; i < length; i++) {
1002					value = callback.apply(obj[i], args);
1003
1004					if (value === false) {
1005						break;
1006					}
1007				}
1008			} else {
1009				for (i in obj) {
1010					if (!obj.hasOwnProperty(i)) {
1011						continue;
1012					}
1013					value = callback.apply(obj[i], args);
1014
1015					if (value === false) {
1016						break;
1017					}
1018				}
1019			}
1020
1021		} else {
1022			if (isArray) {
1023				for (; i < length; i++) {
1024					value = callback.call(obj[i], i, obj[i]);
1025
1026					if (value === false) {
1027						break;
1028					}
1029				}
1030			} else {
1031				for (i in obj) {
1032					if (!obj.hasOwnProperty(i)) {
1033						continue;
1034					}
1035					value = callback.call(obj[i], i, obj[i]);
1036
1037					if (value === false) {
1038						break;
1039					}
1040				}
1041			}
1042		}
1043
1044		return obj;
1045	};
1046
1047	/* Custom */
1048	$.data = function(node, key, value) {
1049		/* $.getData() */
1050		if (value === undefined) {
1051			var getId = node[$.expando],
1052					store = getId && cache[getId];
1053
1054			if (key === undefined) {
1055				return store;
1056			} else if (store) {
1057				if (key in store) {
1058					return store[key];
1059				}
1060			}
1061			/* $.setData() */
1062		} else if (key !== undefined) {
1063			var setId = node[$.expando] || (node[$.expando] = ++$.uuid);
1064
1065			cache[setId] = cache[setId] || {};
1066			cache[setId][key] = value;
1067
1068			return value;
1069		}
1070	};
1071
1072	/* Custom */
1073	$.removeData = function(node, keys) {
1074		var id = node[$.expando],
1075				store = id && cache[id];
1076
1077		if (store) {
1078			// Cleanup the entire store if no keys are provided.
1079			if (!keys) {
1080				delete cache[id];
1081			} else {
1082				$.each(keys, function(_, key) {
1083					delete store[key];
1084				});
1085			}
1086		}
1087	};
1088
1089	/* jQuery */
1090	$.extend = function() {
1091		var src, copyIsArray, copy, name, options, clone,
1092				target = arguments[0] || {},
1093				i = 1,
1094				length = arguments.length,
1095				deep = false;
1096
1097		if (typeof target === "boolean") {
1098			deep = target;
1099
1100			target = arguments[i] || {};
1101			i++;
1102		}
1103
1104		if (typeof target !== "object" && $.type(target) !== "function") {
1105			target = {};
1106		}
1107
1108		if (i === length) {
1109			target = this;
1110			i--;
1111		}
1112
1113		for (; i < length; i++) {
1114			if ((options = arguments[i])) {
1115				for (name in options) {
1116					if (!options.hasOwnProperty(name)) {
1117						continue;
1118					}
1119					src = target[name];
1120					copy = options[name];
1121
1122					if (target === copy) {
1123						continue;
1124					}
1125
1126					if (deep && copy && ($.isPlainObject(copy) || (copyIsArray = $.isArray(copy)))) {
1127						if (copyIsArray) {
1128							copyIsArray = false;
1129							clone = src && $.isArray(src) ? src : [];
1130
1131						} else {
1132							clone = src && $.isPlainObject(src) ? src : {};
1133						}
1134
1135						target[name] = $.extend(deep, clone, copy);
1136
1137					} else if (copy !== undefined) {
1138						target[name] = copy;
1139					}
1140				}
1141			}
1142		}
1143
1144		return target;
1145	};
1146
1147	/* jQuery 1.4.3 */
1148	$.queue = function(elem, type, data) {
1149		function $makeArray(arr, results) {
1150			var ret = results || [];
1151
1152			if (arr) {
1153				if (isArraylike(Object(arr))) {
1154					/* $.merge */
1155					(function(first, second) {
1156						var len = +second.length,
1157								j = 0,
1158								i = first.length;
1159
1160						while (j < len) {
1161							first[i++] = second[j++];
1162						}
1163
1164						if (len !== len) {
1165							while (second[j] !== undefined) {
1166								first[i++] = second[j++];
1167							}
1168						}
1169
1170						first.length = i;
1171
1172						return first;
1173					})(ret, typeof arr === "string" ? [arr] : arr);
1174				} else {
1175					[].push.call(ret, arr);
1176				}
1177			}
1178
1179			return ret;
1180		}
1181
1182		if (!elem) {
1183			return;
1184		}
1185
1186		type = (type || "fx") + "queue";
1187
1188		var q = $.data(elem, type);
1189
1190		if (!data) {
1191			return q || [];
1192		}
1193
1194		if (!q || $.isArray(data)) {
1195			q = $.data(elem, type, $makeArray(data));
1196		} else {
1197			q.push(data);
1198		}
1199
1200		return q;
1201	};
1202
1203	/* jQuery 1.4.3 */
1204	$.dequeue = function(elems, type) {
1205		/* Custom: Embed element iteration. */
1206		$.each(elems.nodeType ? [elems] : elems, function(i, elem) {
1207			type = type || "fx";
1208
1209			var queue = $.queue(elem, type),
1210					fn = queue.shift();
1211
1212			if (fn === "inprogress") {
1213				fn = queue.shift();
1214			}
1215
1216			if (fn) {
1217				if (type === "fx") {
1218					queue.unshift("inprogress");
1219				}
1220
1221				fn.call(elem, function() {
1222					$.dequeue(elem, type);
1223				});
1224			}
1225		});
1226	};
1227
1228	/******************
1229	 $.fn Methods
1230	 ******************/
1231
1232	/* jQuery */
1233	$.fn = $.prototype = {
1234		init: function(selector) {
1235			/* Just return the element wrapped inside an array; don't proceed with the actual jQuery node wrapping process. */
1236			if (selector.nodeType) {
1237				this[0] = selector;
1238
1239				return this;
1240			} else {
1241				throw new Error("Not a DOM node.");
1242			}
1243		},
1244		offset: function() {
1245			/* jQuery altered code: Dropped disconnected DOM node checking. */
1246			var box = this[0].getBoundingClientRect ? this[0].getBoundingClientRect() : {top: 0, left: 0};
1247
1248			return {
1249				top: box.top + (window.pageYOffset || document.scrollTop || 0) - (document.clientTop || 0),
1250				left: box.left + (window.pageXOffset || document.scrollLeft || 0) - (document.clientLeft || 0)
1251			};
1252		},
1253		position: function() {
1254			/* jQuery */
1255			function offsetParentFn(elem) {
1256				var offsetParent = elem.offsetParent;
1257
1258				while (offsetParent && (offsetParent.nodeName.toLowerCase() !== "html" && offsetParent.style && offsetParent.style.position.toLowerCase() === "static")) {
1259					offsetParent = offsetParent.offsetParent;
1260				}
1261
1262				return offsetParent || document;
1263			}
1264
1265			/* Zepto */
1266			var elem = this[0],
1267					offsetParent = offsetParentFn(elem),
1268					offset = this.offset(),
1269					parentOffset = /^(?:body|html)$/i.test(offsetParent.nodeName) ? {top: 0, left: 0} : $(offsetParent).offset();
1270
1271			offset.top -= parseFloat(elem.style.marginTop) || 0;
1272			offset.left -= parseFloat(elem.style.marginLeft) || 0;
1273
1274			if (offsetParent.style) {
1275				parentOffset.top += parseFloat(offsetParent.style.borderTopWidth) || 0;
1276				parentOffset.left += parseFloat(offsetParent.style.borderLeftWidth) || 0;
1277			}
1278
1279			return {
1280				top: offset.top - parentOffset.top,
1281				left: offset.left - parentOffset.left
1282			};
1283		}
1284	};
1285
1286	/**********************
1287	 Private Variables
1288	 **********************/
1289
1290	/* For $.data() */
1291	var cache = {};
1292	$.expando = "velocity" + (new Date().getTime());
1293	$.uuid = 0;
1294
1295	/* For $.queue() */
1296	var class2type = {},
1297			hasOwn = class2type.hasOwnProperty,
1298			toString = class2type.toString;
1299
1300	var types = "Boolean Number String Function Array Date RegExp Object Error".split(" ");
1301	for (var i = 0; i < types.length; i++) {
1302		class2type["[object " + types[i] + "]"] = types[i].toLowerCase();
1303	}
1304
1305	/* Makes $(node) possible, without having to call init. */
1306	$.fn.init.prototype = $.fn;
1307
1308	/* Globalize Velocity onto the window, and assign its Utilities property. */
1309	window.Velocity = {Utilities: $};
1310})(window);
1311
1312/******************
1313 Velocity.js
1314 ******************/
1315
1316(function(factory) {
1317	"use strict";
1318	/* CommonJS module. */
1319	if ( true && typeof module.exports === "object") {
1320		module.exports = factory();
1321		/* AMD module. */
1322	} else if (true) {
1323		!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
1324				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
1325				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
1326				__WEBPACK_AMD_DEFINE_FACTORY__),
1327				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
1328		/* Browser globals. */
1329	} else {}
1330}(function() {
1331	"use strict";
1332	return function(global, window, document, undefined) {
1333
1334		/***************
1335		 Summary
1336		 ***************/
1337
1338		/*
1339		 - CSS: CSS stack that works independently from the rest of Velocity.
1340		 - animate(): Core animation method that iterates over the targeted elements and queues the incoming call onto each element individually.
1341		 - Pre-Queueing: Prepare the element for animation by instantiating its data cache and processing the call's options.
1342		 - Queueing: The logic that runs once the call has reached its point of execution in the element's $.queue() stack.
1343		 Most logic is placed here to avoid risking it becoming stale (if the element's properties have changed).
1344		 - Pushing: Consolidation of the tween data followed by its push onto the global in-progress calls container.
1345		 - tick(): The single requestAnimationFrame loop responsible for tweening all in-progress calls.
1346		 - completeCall(): Handles the cleanup process for each Velocity call.
1347		 */
1348
1349		/*********************
1350		 Helper Functions
1351		 *********************/
1352
1353		/* IE detection. Gist: https://gist.github.com/julianshapiro/9098609 */
1354		var IE = (function() {
1355			if (document.documentMode) {
1356				return document.documentMode;
1357			} else {
1358				for (var i = 7; i > 4; i--) {
1359					var div = document.createElement("div");
1360
1361					div.innerHTML = "<!--[if IE " + i + "]><span></span><![endif]-->";
1362
1363					if (div.getElementsByTagName("span").length) {
1364						div = null;
1365
1366						return i;
1367					}
1368				}
1369			}
1370
1371			return undefined;
1372		})();
1373
1374		/* rAF shim. Gist: https://gist.github.com/julianshapiro/9497513 */
1375		var rAFShim = (function() {
1376			var timeLast = 0;
1377
1378			return window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function(callback) {
1379				var timeCurrent = (new Date()).getTime(),
1380						timeDelta;
1381
1382				/* Dynamically set delay on a per-tick basis to match 60fps. */
1383				/* Technique by Erik Moller. MIT license: https://gist.github.com/paulirish/1579671 */
1384				timeDelta = Math.max(0, 16 - (timeCurrent - timeLast));
1385				timeLast = timeCurrent + timeDelta;
1386
1387				return setTimeout(function() {
1388					callback(timeCurrent + timeDelta);
1389				}, timeDelta);
1390			};
1391		})();
1392
1393		var performance = (function() {
1394			var perf = window.performance || {};
1395
1396			if (typeof perf.now !== "function") {
1397				var nowOffset = perf.timing && perf.timing.navigationStart ? perf.timing.navigationStart : (new Date()).getTime();
1398
1399				perf.now = function() {
1400					return (new Date()).getTime() - nowOffset;
1401				};
1402			}
1403			return perf;
1404		})();
1405
1406		/* Array compacting. Copyright Lo-Dash. MIT License: https://github.com/lodash/lodash/blob/master/LICENSE.txt */
1407		function compactSparseArray(array) {
1408			var index = -1,
1409					length = array ? array.length : 0,
1410					result = [];
1411
1412			while (++index < length) {
1413				var value = array[index];
1414
1415				if (value) {
1416					result.push(value);
1417				}
1418			}
1419
1420			return result;
1421		}
1422
1423		/**
1424		 * Shim for "fixing" IE's lack of support (IE < 9) for applying slice
1425		 * on host objects like NamedNodeMap, NodeList, and HTMLCollection
1426		 * (technically, since host objects have been implementation-dependent,
1427		 * at least before ES2015, IE hasn't needed to work this way).
1428		 * Also works on strings, fixes IE < 9 to allow an explicit undefined
1429		 * for the 2nd argument (as in Firefox), and prevents errors when
1430		 * called on other DOM objects.
1431		 */
1432		var _slice = (function() {
1433			var slice = Array.prototype.slice;
1434
1435			try {
1436				// Can't be used with DOM elements in IE < 9
1437				slice.call(document.documentElement);
1438				return slice;
1439			} catch (e) { // Fails in IE < 9
1440
1441				// This will work for genuine arrays, array-like objects, 
1442				// NamedNodeMap (attributes, entities, notations),
1443				// NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes),
1444				// and will not fail on other DOM objects (as do DOM elements in IE < 9)
1445				return function(begin, end) {
1446					var len = this.length;
1447
1448					if (typeof begin !== "number") {
1449						begin = 0;
1450					}
1451					// IE < 9 gets unhappy with an undefined end argument
1452					if (typeof end !== "number") {
1453						end = len;
1454					}
1455					// For native Array objects, we use the native slice function
1456					if (this.slice) {
1457						return slice.call(this, begin, end);
1458					}
1459					// For array like object we handle it ourselves.
1460					var i,
1461							cloned = [],
1462							// Handle negative value for "begin"
1463							start = (begin >= 0) ? begin : Math.max(0, len + begin),
1464							// Handle negative value for "end"
1465							upTo = end < 0 ? len + end : Math.min(end, len),
1466							// Actual expected size of the slice
1467							size = upTo - start;
1468
1469					if (size > 0) {
1470						cloned = new Array(size);
1471						if (this.charAt) {
1472							for (i = 0; i < size; i++) {
1473								cloned[i] = this.charAt(start + i);
1474							}
1475						} else {
1476							for (i = 0; i < size; i++) {
1477								cloned[i] = this[start + i];
1478							}
1479						}
1480					}
1481					return cloned;
1482				};
1483			}
1484		})();
1485
1486		/* .indexOf doesn't exist in IE<9 */
1487		var _inArray = (function() {
1488			if (Array.prototype.includes) {
1489				return function(arr, val) {
1490					return arr.includes(val);
1491				};
1492			}
1493			if (Array.prototype.indexOf) {
1494				return function(arr, val) {
1495					return arr.indexOf(val) >= 0;
1496				};
1497			}
1498			return function(arr, val) {
1499				for (var i = 0; i < arr.length; i++) {
1500					if (arr[i] === val) {
1501						return true;
1502					}
1503				}
1504				return false;
1505			};
1506		});
1507
1508		function sanitizeElements(elements) {
1509			/* Unwrap jQuery/Zepto objects. */
1510			if (Type.isWrapped(elements)) {
1511				elements = _slice.call(elements);
1512				/* Wrap a single element in an array so that $.each() can iterate with the element instead of its node's children. */
1513			} else if (Type.isNode(elements)) {
1514				elements = [elements];
1515			}
1516
1517			return elements;
1518		}
1519
1520		var Type = {
1521			isNumber: function(variable) {
1522				return (typeof variable === "number");
1523			},
1524			isString: function(variable) {
1525				return (typeof variable === "string");
1526			},
1527			isArray: Array.isArray || function(variable) {
1528				return Object.prototype.toString.call(variable) === "[object Array]";
1529			},
1530			isFunction: function(variable) {
1531				return Object.prototype.toString.call(variable) === "[object Function]";
1532			},
1533			isNode: function(variable) {
1534				return variable && variable.nodeType;
1535			},
1536			/* Determine if variable is an array-like wrapped jQuery, Zepto or similar element, or even a NodeList etc. */
1537			/* NOTE: HTMLFormElements also have a length. */
1538			isWrapped: function(variable) {
1539				return variable
1540						&& variable !== window
1541						&& Type.isNumber(variable.length)
1542						&& !Type.isString(variable)
1543						&& !Type.isFunction(variable)
1544						&& !Type.isNode(variable)
1545						&& (variable.length === 0 || Type.isNode(variable[0]));
1546			},
1547			isSVG: function(variable) {
1548				return window.SVGElement && (variable instanceof window.SVGElement);
1549			},
1550			isEmptyObject: function(variable) {
1551				for (var name in variable) {
1552					if (variable.hasOwnProperty(name)) {
1553						return false;
1554					}
1555				}
1556
1557				return true;
1558			}
1559		};
1560
1561		/*****************
1562		 Dependencies
1563		 *****************/
1564
1565		var $,
1566				isJQuery = false;
1567
1568		if (global.fn && global.fn.jquery) {
1569			$ = global;
1570			isJQuery = true;
1571		} else {
1572			$ = window.Velocity.Utilities;
1573		}
1574
1575		if (IE <= 8 && !isJQuery) {
1576			throw new Error("Velocity: IE8 and below require jQuery to be loaded before Velocity.");
1577		} else if (IE <= 7) {
1578			/* Revert to jQuery's $.animate(), and lose Velocity's extra features. */
1579			jQuery.fn.velocity = jQuery.fn.animate;
1580
1581			/* Now that $.fn.velocity is aliased, abort this Velocity declaration. */
1582			return;
1583		}
1584
1585		/*****************
1586		 Constants
1587		 *****************/
1588
1589		var DURATION_DEFAULT = 400,
1590				EASING_DEFAULT = "swing";
1591
1592		/*************
1593		 State
1594		 *************/
1595
1596		var Velocity = {
1597			/* Container for page-wide Velocity state data. */
1598			State: {
1599				/* Detect mobile devices to determine if mobileHA should be turned on. */
1600				isMobile: /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(window.navigator.userAgent),
1601				/* The mobileHA option's behavior changes on older Android devices (Gingerbread, versions 2.3.3-2.3.7). */
1602				isAndroid: /Android/i.test(window.navigator.userAgent),
1603				isGingerbread: /Android 2\.3\.[3-7]/i.test(window.navigator.userAgent),
1604				isChrome: window.chrome,
1605				isFirefox: /Firefox/i.test(window.navigator.userAgent),
1606				/* Create a cached element for re-use when checking for CSS property prefixes. */
1607				prefixElement: document.createElement("div"),
1608				/* Cache every prefix match to avoid repeating lookups. */
1609				prefixMatches: {},
1610				/* Cache the anchor used for animating window scrolling. */
1611				scrollAnchor: null,
1612				/* Cache the browser-specific property names associated with the scroll anchor. */
1613				scrollPropertyLeft: null,
1614				scrollPropertyTop: null,
1615				/* Keep track of whether our RAF tick is running. */
1616				isTicking: false,
1617				/* Container for every in-progress call to Velocity. */
1618				calls: [],
1619				delayedElements: {
1620					count: 0
1621				}
1622			},
1623			/* Velocity's custom CSS stack. Made global for unit testing. */
1624			CSS: {/* Defined below. */},
1625			/* A shim of the jQuery utility functions used by Velocity -- provided by Velocity's optional jQuery shim. */
1626			Utilities: $,
1627			/* Container for the user's custom animation redirects that are referenced by name in place of the properties map argument. */
1628			Redirects: {/* Manually registered by the user. */},
1629			Easings: {/* Defined below. */},
1630			/* Attempt to use ES6 Promises by default. Users can override this with a third-party promises library. */
1631			Promise: window.Promise,
1632			/* Velocity option defaults, which can be overriden by the user. */
1633			defaults: {
1634				queue: "",
1635				duration: DURATION_DEFAULT,
1636				easing: EASING_DEFAULT,
1637				begin: undefined,
1638				complete: undefined,
1639				progress: undefined,
1640				display: undefined,
1641				visibility: undefined,
1642				loop: false,
1643				delay: false,
1644				mobileHA: true,
1645				/* Advanced: Set to false to prevent property values from being cached between consecutive Velocity-initiated chain calls. */
1646				_cacheValues: true,
1647				/* Advanced: Set to false if the promise should always resolve on empty element lists. */
1648				promiseRejectEmpty: true
1649			},
1650			/* A design goal of Velocity is to cache data wherever possible in order to avoid DOM requerying. Accordingly, each element has a data cache. */
1651			init: function(element) {
1652				$.data(element, "velocity", {
1653					/* Store whether this is an SVG element, since its properties are retrieved and updated differently than standard HTML elements. */
1654					isSVG: Type.isSVG(element),
1655					/* Keep track of whether the element is currently being animated by Velocity.
1656					 This is used to ensure that property values are not transferred between non-consecutive (stale) calls. */
1657					isAnimating: false,
1658					/* A reference to the element's live computedStyle object. Learn more here: https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle */
1659					computedStyle: null,
1660					/* Tween data is cached for each animation on the element so that data can be passed across calls --
1661					 in particular, end values are used as subsequent start values in consecutive Velocity calls. */
1662					tweensContainer: null,
1663					/* The full root property values of each CSS hook being animated on this element are cached so that:
1664					 1) Concurrently-animating hooks sharing the same root can have their root values' merged into one while tweening.
1665					 2) Post-hook-injection root values can be transferred over to consecutively chained Velocity calls as starting root values. */
1666					rootPropertyValueCache: {},
1667					/* A cache for transform updates, which must be manually flushed via CSS.flushTransformCache(). */
1668					transformCache: {}
1669				});
1670			},
1671			/* A parallel to jQuery's $.css(), used for getting/setting Velocity's hooked CSS properties. */
1672			hook: null, /* Defined below. */
1673			/* Velocity-wide animation time remapping for testing purposes. */
1674			mock: false,
1675			version: {major: 1, minor: 5, patch: 2},
1676			/* Set to 1 or 2 (most verbose) to output debug info to console. */
1677			debug: false,
1678			/* Use rAF high resolution timestamp when available */
1679			timestamp: true,
1680			/* Pause all animations */
1681			pauseAll: function(queueName) {
1682				var currentTime = (new Date()).getTime();
1683
1684				$.each(Velocity.State.calls, function(i, activeCall) {
1685
1686					if (activeCall) {
1687
1688						/* If we have a queueName and this call is not on that queue, skip */
1689						if (queueName !== undefined && ((activeCall[2].queue !== queueName) || (activeCall[2].queue === false))) {
1690							return true;
1691						}
1692
1693						/* Set call to paused */
1694						activeCall[5] = {
1695							resume: false
1696						};
1697					}
1698				});
1699
1700				/* Pause timers on any currently delayed calls */
1701				$.each(Velocity.State.delayedElements, function(k, element) {
1702					if (!element) {
1703						return;
1704					}
1705					pauseDelayOnElement(element, currentTime);
1706				});
1707			},
1708			/* Resume all animations */
1709			resumeAll: function(queueName) {
1710				var currentTime = (new Date()).getTime();
1711
1712				$.each(Velocity.State.calls, function(i, activeCall) {
1713
1714					if (activeCall) {
1715
1716						/* If we have a queueName and this call is not on that queue, skip */
1717						if (queueName !== undefined && ((activeCall[2].queue !== queueName) || (activeCall[2].queue === false))) {
1718							return true;
1719						}
1720
1721						/* Set call to resumed if it was paused */
1722						if (activeCall[5]) {
1723							activeCall[5].resume = true;
1724						}
1725					}
1726				});
1727				/* Resume timers on any currently delayed calls */
1728				$.each(Velocity.State.delayedElements, function(k, element) {
1729					if (!element) {
1730						return;
1731					}
1732					resumeDelayOnElement(element, currentTime);
1733				});
1734			}
1735		};
1736
1737		/* Retrieve the appropriate scroll anchor and property name for the browser: https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY */
1738		if (window.pageYOffset !== undefined) {
1739			Velocity.State.scrollAnchor = window;
1740			Velocity.State.scrollPropertyLeft = "pageXOffset";
1741			Velocity.State.scrollPropertyTop = "pageYOffset";
1742		} else {
1743			Velocity.State.scrollAnchor = document.documentElement || document.body.parentNode || document.body;
1744			Velocity.State.scrollPropertyLeft = "scrollLeft";
1745			Velocity.State.scrollPropertyTop = "scrollTop";
1746		}
1747
1748		/* Shorthand alias for jQuery's $.data() utility. */
1749		function Data(element) {
1750			/* Hardcode a reference to the plugin name. */
1751			var response = $.data(element, "velocity");
1752
1753			/* jQuery <=1.4.2 returns null instead of undefined when no match is found. We normalize this behavior. */
1754			return response === null ? undefined : response;
1755		}
1756
1757		/**************
1758		 Delay Timer
1759		 **************/
1760
1761		function pauseDelayOnElement(element, currentTime) {
1762			/* Check for any delay timers, and pause the set timeouts (while preserving time data)
1763			 to be resumed when the "resume" command is issued */
1764			var data = Data(element);
1765			if (data && data.delayTimer && !data.delayPaused) {
1766				data.delayRemaining = data.delay - currentTime + data.delayBegin;
1767				data.delayPaused = true;
1768				clearTimeout(data.delayTimer.setTimeout);
1769			}
1770		}
1771
1772		function resumeDelayOnElement(element, currentTime) {
1773			/* Check for any paused timers and resume */
1774			var data = Data(element);
1775			if (data && data.delayTimer && data.delayPaused) {
1776				/* If the element was mid-delay, re initiate the timeout with the remaining delay */
1777				data.delayPaused = false;
1778				data.delayTimer.setTimeout = setTimeout(data.delayTimer.next, data.delayRemaining);
1779			}
1780		}
1781
1782
1783
1784		/**************
1785		 Easing
1786		 **************/
1787
1788		/* Step easing generator. */
1789		function generateStep(steps) {
1790			return function(p) {
1791				return Math.round(p * steps) * (1 / steps);
1792			};
1793		}
1794
1795		/* Bezier curve function generator. Copyright Gaetan Renaudeau. MIT License: http://en.wikipedia.org/wiki/MIT_License */
1796		function generateBezier(mX1, mY1, mX2, mY2) {
1797			var NEWTON_ITERATIONS = 4,
1798					NEWTON_MIN_SLOPE = 0.001,
1799					SUBDIVISION_PRECISION = 0.0000001,
1800					SUBDIVISION_MAX_ITERATIONS = 10,
1801					kSplineTableSize = 11,
1802					kSampleStepSize = 1.0 / (kSplineTableSize - 1.0),
1803					float32ArraySupported = "Float32Array" in window;
1804
1805			/* Must contain four arguments. */
1806			if (arguments.length !== 4) {
1807				return false;
1808			}
1809
1810			/* Arguments must be numbers. */
1811			for (var i = 0; i < 4; ++i) {
1812				if (typeof arguments[i] !== "number" || isNaN(arguments[i]) || !isFinite(arguments[i])) {
1813					return false;
1814				}
1815			}
1816
1817			/* X values must be in the [0, 1] range. */
1818			mX1 = Math.min(mX1, 1);
1819			mX2 = Math.min(mX2, 1);
1820			mX1 = Math.max(mX1, 0);
1821			mX2 = Math.max(mX2, 0);
1822
1823			var mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
1824
1825			function A(aA1, aA2) {
1826				return 1.0 - 3.0 * aA2 + 3.0 * aA1;
1827			}
1828			function B(aA1, aA2) {
1829				return 3.0 * aA2 - 6.0 * aA1;
1830			}
1831			function C(aA1) {
1832				return 3.0 * aA1;
1833			}
1834
1835			function calcBezier(aT, aA1, aA2) {
1836				return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
1837			}
1838
1839			function getSlope(aT, aA1, aA2) {
1840				return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
1841			}
1842
1843			function newtonRaphsonIterate(aX, aGuessT) {
1844				for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
1845					var currentSlope = getSlope(aGuessT, mX1, mX2);
1846
1847					if (currentSlope === 0.0) {
1848						return aGuessT;
1849					}
1850
1851					var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
1852					aGuessT -= currentX / currentSlope;
1853				}
1854
1855				return aGuessT;
1856			}
1857
1858			function calcSampleValues() {
1859				for (var i = 0; i < kSplineTableSize; ++i) {
1860					mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
1861				}
1862			}
1863
1864			function binarySubdivide(aX, aA, aB) {
1865				var currentX, currentT, i = 0;
1866
1867				do {
1868					currentT = aA + (aB - aA) / 2.0;
1869					currentX = calcBezier(currentT, mX1, mX2) - aX;
1870					if (currentX > 0.0) {
1871						aB = currentT;
1872					} else {
1873						aA = currentT;
1874					}
1875				} while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
1876
1877				return currentT;
1878			}
1879
1880			function getTForX(aX) {
1881				var intervalStart = 0.0,
1882						currentSample = 1,
1883						lastSample = kSplineTableSize - 1;
1884
1885				for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
1886					intervalStart += kSampleStepSize;
1887				}
1888
1889				--currentSample;
1890
1891				var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]),
1892						guessForT = intervalStart + dist * kSampleStepSize,
1893						initialSlope = getSlope(guessForT, mX1, mX2);
1894
1895				if (initialSlope >= NEWTON_MIN_SLOPE) {
1896					return newtonRaphsonIterate(aX, guessForT);
1897				} else if (initialSlope === 0.0) {
1898					return guessForT;
1899				} else {
1900					return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize);
1901				}
1902			}
1903
1904			var _precomputed = false;
1905
1906			function precompute() {
1907				_precomputed = true;
1908				if (mX1 !== mY1 || mX2 !== mY2) {
1909					calcSampleValues();
1910				}
1911			}
1912
1913			var f = function(aX) {
1914				if (!_precomputed) {
1915					precompute();
1916				}
1917				if (mX1 === mY1 && mX2 === mY2) {
1918					return aX;
1919				}
1920				if (aX === 0) {
1921					return 0;
1922				}
1923				if (aX === 1) {
1924					return 1;
1925				}
1926
1927				return calcBezier(getTForX(aX), mY1, mY2);
1928			};
1929
1930			f.getControlPoints = function() {
1931				return [{x: mX1, y: mY1}, {x: mX2, y: mY2}];
1932			};
1933
1934			var str = "generateBezier(" + [mX1, mY1, mX2, mY2] + ")";
1935			f.toString = function() {
1936				return str;
1937			};
1938
1939			return f;
1940		}
1941
1942		/* Runge-Kutta spring physics function generator. Adapted from Framer.js, copyright Koen Bok. MIT License: http://en.wikipedia.org/wiki/MIT_License */
1943		/* Given a tension, friction, and duration, a simulation at 60FPS will first run without a defined duration in order to calculate the full path. A second pass
1944		 then adjusts the time delta -- using the relation between actual time and duration -- to calculate the path for the duration-constrained animation. */
1945		var generateSpringRK4 = (function() {
1946			function springAccelerationForState(state) {
1947				return (-state.tension * state.x) - (state.friction * state.v);
1948			}
1949
1950			function springEvaluateStateWithDerivative(initialState, dt, derivative) {
1951				var state = {
1952					x: initialState.x + derivative.dx * dt,
1953					v: initialState.v + derivative.dv * dt,
1954					tension: initialState.tension,
1955					friction: initialState.friction
1956				};
1957
1958				return {dx: state.v, dv: springAccelerationForState(state)};
1959			}
1960
1961			function springIntegrateState(state, dt) {
1962				var a = {
1963					dx: state.v,
1964					dv: springAccelerationForState(state)
1965				},
1966						b = springEvaluateStateWithDerivative(state, dt * 0.5, a),
1967						c = springEvaluateStateWithDerivative(state, dt * 0.5, b),
1968						d = springEvaluateStateWithDerivative(state, dt, c),
1969						dxdt = 1.0 / 6.0 * (a.dx + 2.0 * (b.dx + c.dx) + d.dx),
1970						dvdt = 1.0 / 6.0 * (a.dv + 2.0 * (b.dv + c.dv) + d.dv);
1971
1972				state.x = state.x + dxdt * dt;
1973				state.v = state.v + dvdt * dt;
1974
1975				return state;
1976			}
1977
1978			return function springRK4Factory(tension, friction, duration) {
1979
1980				var initState = {
1981					x: -1,
1982					v: 0,
1983					tension: null,
1984					friction: null
1985				},
1986						path = [0],
1987						time_lapsed = 0,
1988						tolerance = 1 / 10000,
1989						DT = 16 / 1000,
1990						have_duration, dt, last_state;
1991
1992				tension = parseFloat(tension) || 500;
1993				friction = parseFloat(friction) || 20;
1994				duration = duration || null;
1995
1996				initState.tension = tension;
1997				initState.friction = friction;
1998
1999				have_duration = duration !== null;
2000
2001				/* Calculate the actual time it takes for this animation to complete with the provided conditions. */
2002				if (have_duration) {
2003					/* Run the simulation without a duration. */
2004					time_lapsed = springRK4Factory(tension, friction);
2005					/* Compute the adjusted time delta. */
2006					dt = time_lapsed / duration * DT;
2007				} else {
2008					dt = DT;
2009				}
2010
2011				while (true) {
2012					/* Next/step function .*/
2013					last_state = springIntegrateState(last_state || initState, dt);
2014					/* Store the position. */
2015					path.push(1 + last_state.x);
2016					time_lapsed += 16;
2017					/* If the change threshold is reached, break. */
2018					if (!(Math.abs(last_state.x) > tolerance && Math.abs(last_state.v) > tolerance)) {
2019						break;
2020					}
2021				}
2022
2023				/* If duration is not defined, return the actual time required for completing this animation. Otherwise, return a closure that holds the
2024				 computed path and returns a snapshot of the position according to a given percentComplete. */
2025				return !have_duration ? time_lapsed : function(percentComplete) {
2026					return path[ (percentComplete * (path.length - 1)) | 0 ];
2027				};
2028			};
2029		}());
2030
2031		/* jQuery easings. */
2032		Velocity.Easings = {
2033			linear: function(p) {
2034				return p;
2035			},
2036			swing: function(p) {
2037				return 0.5 - Math.cos(p * Math.PI) / 2;
2038			},
2039			/* Bonus "spring" easing, which is a less exaggerated version of easeInOutElastic. */
2040			spring: function(p) {
2041				return 1 - (Math.cos(p * 4.5 * Math.PI) * Math.exp(-p * 6));
2042			}
2043		};
2044
2045		/* CSS3 and Robert Penner easings. */
2046		$.each(
2047				[
2048					["ease", [0.25, 0.1, 0.25, 1.0]],
2049					["ease-in", [0.42, 0.0, 1.00, 1.0]],
2050					["ease-out", [0.00, 0.0, 0.58, 1.0]],
2051					["ease-in-out", [0.42, 0.0, 0.58, 1.0]],
2052					["easeInSine", [0.47, 0, 0.745, 0.715]],
2053					["easeOutSine", [0.39, 0.575, 0.565, 1]],
2054					["easeInOutSine", [0.445, 0.05, 0.55, 0.95]],
2055					["easeInQuad", [0.55, 0.085, 0.68, 0.53]],
2056					["easeOutQuad", [0.25, 0.46, 0.45, 0.94]],
2057					["easeInOutQuad", [0.455, 0.03, 0.515, 0.955]],
2058					["easeInCubic", [0.55, 0.055, 0.675, 0.19]],
2059					["easeOutCubic", [0.215, 0.61, 0.355, 1]],
2060					["easeInOutCubic", [0.645, 0.045, 0.355, 1]],
2061					["easeInQuart", [0.895, 0.03, 0.685, 0.22]],
2062					["easeOutQuart", [0.165, 0.84, 0.44, 1]],
2063					["easeInOutQuart", [0.77, 0, 0.175, 1]],
2064					["easeInQuint", [0.755, 0.05, 0.855, 0.06]],
2065					["easeOutQuint", [0.23, 1, 0.32, 1]],
2066					["easeInOutQuint", [0.86, 0, 0.07, 1]],
2067					["easeInExpo", [0.95, 0.05, 0.795, 0.035]],
2068					["easeOutExpo", [0.19, 1, 0.22, 1]],
2069					["easeInOutExpo", [1, 0, 0, 1]],
2070					["easeInCirc", [0.6, 0.04, 0.98, 0.335]],
2071					["easeOutCirc", [0.075, 0.82, 0.165, 1]],
2072					["easeInOutCirc", [0.785, 0.135, 0.15, 0.86]]
2073				], function(i, easingArray) {
2074			Velocity.Easings[easingArray[0]] = generateBezier.apply(null, easingArray[1]);
2075		});
2076
2077		/* Determine the appropriate easing type given an easing input. */
2078		function getEasing(value, duration) {
2079			var easing = value;
2080
2081			/* The easing option can either be a string that references a pre-registered easing,
2082			 or it can be a two-/four-item array of integers to be converted into a bezier/spring function. */
2083			if (Type.isString(value)) {
2084				/* Ensure that the easing has been assigned to jQuery's Velocity.Easings object. */
2085				if (!Velocity.Easings[value]) {
2086					easing = false;
2087				}
2088			} else if (Type.isArray(value) && value.length === 1) {
2089				easing = generateStep.apply(null, value);
2090			} else if (Type.isArray(value) && value.length === 2) {
2091				/* springRK4 must be passed the animation's duration. */
2092				/* Note: If the springRK4 array contains non-numbers, generateSpringRK4() returns an easing
2093				 function generated with default tension and friction values. */
2094				easing = generateSpringRK4.apply(null, value.concat([duration]));
2095			} else if (Type.isArray(value) && value.length === 4) {
2096				/* Note: If the bezier array contains non-numbers, generateBezier() returns false. */
2097				easing = generateBezier.apply(null, value);
2098			} else {
2099				easing = false;
2100			}
2101
2102			/* Revert to the Velocity-wide default easing type, or fall back to "swing" (which is also jQuery's default)
2103			 if the Velocity-wide default has been incorrectly modified. */
2104			if (easing === false) {
2105				if (Velocity.Easings[Velocity.defaults.easing]) {
2106					easing = Velocity.defaults.easing;
2107				} else {
2108					easing = EASING_DEFAULT;
2109				}
2110			}
2111
2112			return easing;
2113		}
2114
2115		/*****************
2116		 CSS Stack
2117		 *****************/
2118
2119		/* The CSS object is a highly condensed and performant CSS stack that fully replaces jQuery's.
2120		 It handles the validation, getting, and setting of both standard CSS properties and CSS property hooks. */
2121		/* Note: A "CSS" shorthand is aliased so that our code is easier to read. */
2122		var CSS = Velocity.CSS = {
2123			/*************
2124			 RegEx
2125			 *************/
2126
2127			RegEx: {
2128				isHex: /^#([A-f\d]{3}){1,2}$/i,
2129				/* Unwrap a property value's surrounding text, e.g. "rgba(4, 3, 2, 1)" ==> "4, 3, 2, 1" and "rect(4px 3px 2px 1px)" ==> "4px 3px 2px 1px". */
2130				valueUnwrap: /^[A-z]+\((.*)\)$/i,
2131				wrappedValueAlreadyExtracted: /[0-9.]+ [0-9.]+ [0-9.]+( [0-9.]+)?/,
2132				/* Split a multi-value property into an array of subvalues, e.g. "rgba(4, 3, 2, 1) 4px 3px 2px 1px" ==> [ "rgba(4, 3, 2, 1)", "4px", "3px", "2px", "1px" ]. */
2133				valueSplit: /([A-z]+\(.+\))|(([A-z0-9#-.]+?)(?=\s|$))/ig
2134			},
2135			/************
2136			 Lists
2137			 ************/
2138
2139			Lists: {
2140				colors: ["fill", "stroke", "stopColor", "color", "backgroundColor", "borderColor", "borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor", "outlineColor"],
2141				transformsBase: ["translateX", "translateY", "scale", "scaleX", "scaleY", "skewX", "skewY", "rotateZ"],
2142				transforms3D: ["transformPerspective", "translateZ", "scaleZ", "rotateX", "rotateY"],
2143				units: [
2144					"%", // relative
2145					"em", "ex", "ch", "rem", // font relative
2146					"vw", "vh", "vmin", "vmax", // viewport relative
2147					"cm", "mm", "Q", "in", "pc", "pt", "px", // absolute lengths
2148					"deg", "grad", "rad", "turn", // angles
2149					"s", "ms" // time
2150				],
2151				colorNames: {
2152					"aliceblue": "240,248,255",
2153					"antiquewhite": "250,235,215",
2154					"aquamarine": "127,255,212",
2155					"aqua": "0,255,255",
2156					"azure": "240,255,255",
2157					"beige": "245,245,220",
2158					"bisque": "255,228,196",
2159					"black": "0,0,0",
2160					"blanchedalmond": "255,235,205",
2161					"blueviolet": "138,43,226",
2162					"blue": "0,0,255",
2163					"brown": "165,42,42",
2164					"burlywood": "222,184,135",
2165					"cadetblue": "95,158,160",
2166					"chartreuse": "127,255,0",
2167					"chocolate": "210,105,30",
2168					"coral": "255,127,80",
2169					"cornflowerblue": "100,149,237",
2170					"cornsilk": "255,248,220",
2171					"crimson": "220,20,60",
2172					"cyan": "0,255,255",
2173					"darkblue": "0,0,139",
2174					"darkcyan": "0,139,139",
2175					"darkgoldenrod": "184,134,11",
2176					"darkgray": "169,169,169",
2177					"darkgrey": "169,169,169",
2178					"darkgreen": "0,100,0",
2179					"darkkhaki": "189,183,107",
2180					"darkmagenta": "139,0,139",
2181					"darkolivegreen": "85,107,47",
2182					"darkorange": "255,140,0",
2183					"darkorchid": "153,50,204",
2184					"darkred": "139,0,0",
2185					"darksalmon": "233,150,122",
2186					"darkseagreen": "143,188,143",
2187					"darkslateblue": "72,61,139",
2188					"darkslategray": "47,79,79",
2189					"darkturquoise": "0,206,209",
2190					"darkviolet": "148,0,211",
2191					"deeppink": "255,20,147",
2192					"deepskyblue": "0,191,255",
2193					"dimgray": "105,105,105",
2194					"dimgrey": "105,105,105",
2195					"dodgerblue": "30,144,255",
2196					"firebrick": "178,34,34",
2197					"floralwhite": "255,250,240",
2198					"forestgreen": "34,139,34",
2199					"fuchsia": "255,0,255",
2200					"gainsboro": "220,220,220",
2201					"ghostwhite": "248,248,255",
2202					"gold": "255,215,0",
2203					"goldenrod": "218,165,32",
2204					"gray": "128,128,128",
2205					"grey": "128,128,128",
2206					"greenyellow": "173,255,47",
2207					"green": "0,128,0",
2208					"honeydew": "240,255,240",
2209					"hotpink": "255,105,180",
2210					"indianred": "205,92,92",
2211					"indigo": "75,0,130",
2212					"ivory": "255,255,240",
2213					"khaki": "240,230,140",
2214					"lavenderblush": "255,240,245",
2215					"lavender": "230,230,250",
2216					"lawngreen": "124,252,0",
2217					"lemonchiffon": "255,250,205",
2218					"lightblue": "173,216,230",
2219					"lightcoral": "240,128,128",
2220					"lightcyan": "224,255,255",
2221					"lightgoldenrodyellow": "250,250,210",
2222					"lightgray": "211,211,211",
2223					"lightgrey": "211,211,211",
2224					"lightgreen": "144,238,144",
2225					"lightpink": "255,182,193",
2226					"lightsalmon": "255,160,122",
2227					"lightseagreen": "32,178,170",
2228					"lightskyblue": "135,206,250",
2229					"lightslategray": "119,136,153",
2230					"lightsteelblue": "176,196,222",
2231					"lightyellow": "255,255,224",
2232					"limegreen": "50,205,50",
2233					"lime": "0,255,0",
2234					"linen": "250,240,230",
2235					"magenta": "255,0,255",
2236					"maroon": "128,0,0",
2237					"mediumaquamarine": "102,205,170",
2238					"mediumblue": "0,0,205",
2239					"mediumorchid": "186,85,211",
2240					"mediumpurple": "147,112,219",
2241					"mediumseagreen": "60,179,113",
2242					"mediumslateblue": "123,104,238",
2243					"mediumspringgreen": "0,250,154",
2244					"mediumturquoise": "72,209,204",
2245					"mediumvioletred": "199,21,133",
2246					"midnightblue": "25,25,112",
2247					"mintcream": "245,255,250",
2248					"mistyrose": "255,228,225",
2249					"moccasin": "255,228,181",
2250					"navajowhite": "255,222,173",
2251					"navy": "0,0,128",
2252					"oldlace": "253,245,230",
2253					"olivedrab": "107,142,35",
2254					"olive": "128,128,0",
2255					"orangered": "255,69,0",
2256					"orange": "255,165,0",
2257					"orchid": "218,112,214",
2258					"palegoldenrod": "238,232,170",
2259					"palegreen": "152,251,152",
2260					"paleturquoise": "175,238,238",
2261					"palevioletred": "219,112,147",
2262					"papayawhip": "255,239,213",
2263					"peachpuff": "255,218,185",
2264					"peru": "205,133,63",
2265					"pink": "255,192,203",
2266					"plum": "221,160,221",
2267					"powderblue": "176,224,230",
2268					"purple": "128,0,128",
2269					"red": "255,0,0",
2270					"rosybrown": "188,143,143",
2271					"royalblue": "65,105,225",
2272					"saddlebrown": "139,69,19",
2273					"salmon": "250,128,114",
2274					"sandybrown": "244,164,96",
2275					"seagreen": "46,139,87",
2276					"seashell": "255,245,238",
2277					"sienna": "160,82,45",
2278					"silver": "192,192,192",
2279					"skyblue": "135,206,235",
2280					"slateblue": "106,90,205",
2281					"slategray": "112,128,144",
2282					"snow": "255,250,250",
2283					"springgreen": "0,255,127",
2284					"steelblue": "70,130,180",
2285					"tan": "210,180,140",
2286					"teal": "0,128,128",
2287					"thistle": "216,191,216",
2288					"tomato": "255,99,71",
2289					"turquoise": "64,224,208",
2290					"violet": "238,130,238",
2291					"wheat": "245,222,179",
2292					"whitesmoke": "245,245,245",
2293					"white": "255,255,255",
2294					"yellowgreen": "154,205,50",
2295					"yellow": "255,255,0"
2296				}
2297			},
2298			/************
2299			 Hooks
2300			 ************/
2301
2302			/* Hooks allow a subproperty (e.g. "boxShadowBlur") of a compound-value CSS property
2303			 (e.g. "boxShadow: X Y Blur Spread Color") to be animated as if it were a discrete property. */
2304			/* Note: Beyond enabling fine-grained property animation, hooking is necessary since Velocity only
2305			 tweens properties with single numeric values; unlike CSS transitions, Velocity does not interpolate compound-values. */
2306			Hooks: {
2307				/********************
2308				 Registration
2309				 ********************/
2310
2311				/* Templates are a concise way of indicating which subproperties must be individually registered for each compound-value CSS property. */
2312				/* Each template consists of the compound-value's base name, its constituent subproperty names, and those subproperties' default values. */
2313				templates: {
2314					"textShadow": ["Color X Y Blur", "black 0px 0px 0px"],
2315					"boxShadow": ["Color X Y Blur Spread", "black 0px 0px 0px 0px"],
2316					"clip": ["Top Right Bottom Left", "0px 0px 0px 0px"],
2317					"backgroundPosition": ["X Y", "0% 0%"],
2318					"transformOrigin": ["X Y Z", "50% 50% 0px"],
2319					"perspectiveOrigin": ["X Y", "50% 50%"]
2320				},
2321				/* A "registered" hook is one that has been converted from its template form into a live,
2322				 tweenable property. It contains data to associate it with its root property. */
2323				registered: {
2324					/* Note: A registered hook looks like this ==> textShadowBlur: [ "textShadow", 3 ],
2325					 which consists of the subproperty's name, the associated root property's name,
2326					 and the subproperty's position in the root's value. */
2327				},
2328				/* Convert the templates into individual hooks then append them to the registered object above. */
2329				register: function() {
2330					/* Color hooks registration: Colors are defaulted to white -- as opposed to black -- since colors that are
2331					 currently set to "transparent" default to their respective template below when color-animated,
2332					 and white is typically a closer match to transparent than black is. An exception is made for text ("color"),
2333					 which is almost always set closer to black than white. */
2334					for (var i = 0; i < CSS.Lists.colors.length; i++) {
2335						var rgbComponents = (CSS.Lists.colors[i] === "color") ? "0 0 0 1" : "255 255 255 1";
2336						CSS.Hooks.templates[CSS.Lists.colors[i]] = ["Red Green Blue Alpha", rgbComponents];
2337					}
2338
2339					var rootProperty,
2340							hookTemplate,
2341							hookNames;
2342
2343					/* In IE, color values inside compound-value properties are positioned at the end the value instead of at the beginning.
2344					 Thus, we re-arrange the templates accordingly. */
2345					if (IE) {
2346						for (rootProperty in CSS.Hooks.templates) {
2347							if (!CSS.Hooks.templates.hasOwnProperty(rootProperty)) {
2348								continue;
2349							}
2350							hookTemplate = CSS.Hooks.templates[rootProperty];
2351							hookNames = hookTemplate[0].split(" ");
2352
2353							var defaultValues = hookTemplate[1].match(CSS.RegEx.valueSplit);
2354
2355							if (hookNames[0] === "Color") {
2356								/* Reposition both the hook's name and its default value to the end of their respective strings. */
2357								hookNames.push(hookNames.shift());
2358								defaultValues.push(defaultValues.shift());
2359
2360								/* Replace the existing template for the hook's root property. */
2361								CSS.Hooks.templates[rootProperty] = [hookNames.join(" "), defaultValues.join(" ")];
2362							}
2363						}
2364					}
2365
2366					/* Hook registration. */
2367					for (rootProperty in CSS.Hooks.templates) {
2368						if (!CSS.Hooks.templates.hasOwnProperty(rootProperty)) {
2369							continue;
2370						}
2371						hookTemplate = CSS.Hooks.templates[rootProperty];
2372						hookNames = hookTemplate[0].split(" ");
2373
2374						for (var j in hookNames) {
2375							if (!hookNames.hasOwnProperty(j)) {
2376								continue;
2377							}
2378							var fullHookName = rootProperty + hookNames[j],
2379									hookPosition = j;
2380
2381							/* For each hook, register its full name (e.g. textShadowBlur) with its root property (e.g. textShadow)
2382							 and the hook's position in its template's default value string. */
2383							CSS.Hooks.registered[fullHookName] = [rootProperty, hookPosition];
2384						}
2385					}
2386				},
2387				/*****************************
2388				 Injection and Extraction
2389				 *****************************/
2390
2391				/* Look up the root property associated with the hook (e.g. return "textShadow" for "textShadowBlur"). */
2392				/* Since a hook cannot be set directly (the browser won't recognize it), style updating for hooks is routed through the hook's root property. */
2393				getRoot: function(property) {
2394					var hookData = CSS.Hooks.registered[property];
2395
2396					if (hookData) {
2397						return hookData[0];
2398					} else {
2399						/* If there was no hook match, return the property name untouched. */
2400						return property;
2401					}
2402				},
2403				getUnit: function(str, start) {
2404					var unit = (str.substr(start || 0, 5).match(/^[a-z%]+/) || [])[0] || "";
2405
2406					if (unit && _inArray(CSS.Lists.units, unit)) {
2407						return unit;
2408					}
2409					return "";
2410				},
2411				fixColors: function(str) {
2412					return str.replace(/(rgba?\(\s*)?(\b[a-z]+\b)/g, function($0, $1, $2) {
2413						if (CSS.Lists.colorNames.hasOwnProperty($2)) {
2414							return ($1 ? $1 : "rgba(") + CSS.Lists.colorNames[$2] + ($1 ? "" : ",1)");
2415						}
2416						return $1 + $2;
2417					});
2418				},
2419				/* Convert any rootPropertyValue, null or otherwise, into a space-delimited list of hook values so that
2420				 the targeted hook can be injected or extracted at its standard position. */
2421				cleanRootPropertyValue: function(rootProperty, rootPropertyValue) {
2422					/* If the rootPropertyValue is wrapped with "rgb()", "clip()", etc., remove the wrapping to normalize the value before manipulation. */
2423					if (CSS.RegEx.valueUnwrap.test(rootPropertyValue)) {
2424						rootPropertyValue = rootPropertyValue.match(CSS.RegEx.valueUnwrap)[1];
2425					}
2426
2427					/* If rootPropertyValue is a CSS null-value (from which there's inherently no hook value to extract),
2428					 default to the root's default value as defined in CSS.Hooks.templates. */
2429					/* Note: CSS null-values include "none", "auto", and "transparent". They must be converted into their
2430					 zero-values (e.g. textShadow: "none" ==> textShadow: "0px 0px 0px black") for hook manipulation to proceed. */
2431					if (CSS.Values.isCSSNullValue(rootPropertyValue)) {
2432						rootPropertyValue = CSS.Hooks.templates[rootProperty][1];
2433					}
2434
2435					return rootPropertyValue;
2436				},
2437				/* Extracted the hook's value from its root property's value. This is used to get the starting value of an animating hook. */
2438				extractValue: function(fullHookName, rootPropertyValue) {
2439					var hookData = CSS.Hooks.registered[fullHookName];
2440
2441					if (hookData) {
2442						var hookRoot = hookData[0],
2443								hookPosition = hookData[1];
2444
2445						rootPropertyValue = CSS.Hooks.cleanRootPropertyValue(hookRoot, rootPropertyValue);
2446
2447						/* Split rootPropertyValue into its constituent hook values then grab the desired hook at its standard position. */
2448						return rootPropertyValue.toString().match(CSS.RegEx.valueSplit)[hookPosition];
2449					} else {
2450						/* If the provided fullHookName isn't a registered hook, return the rootPropertyValue that was passed in. */
2451						return rootPropertyValue;
2452					}
2453				},
2454				/* Inject the hook's value into its root property's value. This is used to piece back together the root property
2455				 once Velocity has updated one of its individually hooked values through tweening. */
2456				injectValue: function(fullHookName, hookValue, rootPropertyValue) {
2457					var hookData = CSS.Hooks.registered[fullHookName];
2458
2459					if (hookData) {
2460						var hookRoot = hookData[0],
2461								hookPosition = hookData[1],
2462								rootPropertyValueParts,
2463								rootPropertyValueUpdated;
2464
2465						rootPropertyValue = CSS.Hooks.cleanRootPropertyValue(hookRoot, rootPropertyValue);
2466
2467						/* Split rootPropertyValue into its individual hook values, replace the targeted value with hookValue,
2468						 then reconstruct the rootPropertyValue string. */
2469						rootPropertyValueParts = rootPropertyValue.toString().match(CSS.RegEx.valueSplit);
2470						rootPropertyValueParts[hookPosition] = hookValue;
2471						rootPropertyValueUpdated = rootPropertyValueParts.join(" ");
2472
2473						return rootPropertyValueUpdated;
2474					} else {
2475						/* If the provided fullHookName isn't a registered hook, return the rootPropertyValue that was passed in. */
2476						return rootPropertyValue;
2477					}
2478				}
2479			},
2480			/*******************
2481			 Normalizations
2482			 *******************/
2483
2484			/* Normalizations standardize CSS property manipulation by pollyfilling browser-specific implementations (e.g. opacity)
2485			 and reformatting special properties (e.g. clip, rgba) to look like standard ones. */
2486			Normalizations: {
2487				/* Normalizations are passed a normalization target (either the property's name, its extracted value, or its injected value),
2488				 the targeted element (which may need to be queried), and the targeted property value. */
2489				registered: {
2490					clip: function(type, element, propertyValue) {
2491						switch (type) {
2492							case "name":
2493								return "clip";
2494								/* Clip needs to be unwrapped and stripped of its commas during extraction. */
2495							case "extract":
2496								var extracted;
2497
2498								/* If Velocity also extracted this value, skip extraction. */
2499								if (CSS.RegEx.wrappedValueAlreadyExtracted.test(propertyValue)) {
2500									extracted = propertyValue;
2501								} else {
2502									/* Remove the "rect()" wrapper. */
2503									extracted = propertyValue.toString().match(CSS.RegEx.valueUnwrap);
2504
2505									/* Strip off commas. */
2506									extracted = extracted ? extracted[1].replace(/,(\s+)?/g, " ") : propertyValue;
2507								}
2508
2509								return extracted;
2510								/* Clip needs to be re-wrapped during injection. */
2511							case "inject":
2512								return "rect(" + propertyValue + ")";
2513						}
2514					},
2515					blur: function(type, element, propertyValue) {
2516						switch (type) {
2517							case "name":
2518								return Velocity.State.isFirefox ? "filter" : "-webkit-filter";
2519							case "extract":
2520								var extracted = parseFloat(propertyValue);
2521
2522								/* If extracted is NaN, meaning the value isn't already extracted. */
2523								if (!(extracted || extracted === 0)) {
2524									var blurComponent = propertyValue.toString().match(/blur\(([0-9]+[A-z]+)\)/i);
2525
2526									/* If the filter string had a blur component, return just the blur value and unit type. */
2527									if (blurComponent) {
2528										extracted = blurComponent[1];
2529										/* If the component doesn't exist, default blur to 0. */
2530									} else {
2531										extracted = 0;
2532									}
2533								}
2534
2535								return extracted;
2536								/* Blur needs to be re-wrapped during injection. */
2537							case "inject":
2538								/* For the blur effect to be fully de-applied, it needs to be set to "none" instead of 0. */
2539								if (!parseFloat(propertyValue)) {
2540									return "none";
2541								} else {
2542									return "blur(" + propertyValue + ")";
2543								}
2544						}
2545					},
2546					/* <=IE8 do not support the standard opacity property. They use filter:alpha(opacity=INT) instead. */
2547					opacity: function(type, element, propertyValue) {
2548						if (IE <= 8) {
2549							switch (type) {
2550								case "name":
2551									return "filter";
2552								case "extract":
2553									/* <=IE8 return a "filter" value of "alpha(opacity=\d{1,3})".
2554									 Extract the value and convert it to a decimal value to match the standard CSS opacity property's formatting. */
2555									var extracted = propertyValue.toString().match(/alpha\(opacity=(.*)\)/i);
2556
2557									if (extracted) {
2558										/* Convert to decimal value. */
2559										propertyValue = extracted[1] / 100;
2560									} else {
2561										/* When extracting opacity, default to 1 since a null value means opacity hasn't been set. */
2562										propertyValue = 1;
2563									}
2564
2565									return propertyValue;
2566								case "inject":
2567									/* Opacified elements are required to have their zoom property set to a non-zero value. */
2568									element.style.zoom = 1;
2569
2570									/* Setting the filter property on elements with certain font property combinations can result in a
2571									 highly unappealing ultra-bolding effect. There's no way to remedy this throughout a tween, but dropping the
2572									 value altogether (when opacity hits 1) at leasts ensures that the glitch is gone post-tweening. */
2573									if (parseFloat(propertyValue) >= 1) {
2574										return "";
2575									} else {
2576										/* As per the filter property's spec, convert the decimal value to a whole number and wrap the value. */
2577										return "alpha(opacity=" + parseInt(parseFloat(propertyValue) * 100, 10) + ")";
2578									}
2579							}
2580							/* With all other browsers, normalization is not required; return the same values that were passed in. */
2581						} else {
2582							switch (type) {
2583								case "name":
2584									return "opacity";
2585								case "extract":
2586									return propertyValue;
2587								case "inject":
2588									return propertyValue;
2589							}
2590						}
2591					}
2592				},
2593				/*****************************
2594				 Batched Registrations
2595				 *****************************/
2596
2597				/* Note: Batched normalizations extend the CSS.Normalizations.registered object. */
2598				register: function() {
2599
2600					/*****************
2601					 Transforms
2602					 *****************/
2603
2604					/* Transforms are the subproperties contained by the CSS "transform" property. Transforms must undergo normalization
2605					 so that they can be referenced in a properties map by their individual names. */
2606					/* Note: When transforms are "set", they are actually assigned to a per-element transformCache. When all transform
2607					 setting is complete complete, CSS.flushTransformCache() must be manually called to flush the values to the DOM.
2608					 Transform setting is batched in this way to improve performance: the transform style only needs to be updated
2609					 once when multiple transform subproperties are being animated simultaneously. */
2610					/* Note: IE9 and Android Gingerbread have support for 2D -- but not 3D -- transforms. Since animating unsupported
2611					 transform properties results in the browser ignoring the *entire* transform string, we prevent these 3D values
2612					 from being normalized for these browsers so that tweening skips these properties altogether
2613					 (since it will ignore them as being unsupported by the browser.) */
2614					if ((!IE || IE > 9) && !Velocity.State.isGingerbread) {
2615						/* Note: Since the standalone CSS "perspective" property and the CSS transform "perspective" subproperty
2616						 share the same name, the latter is given a unique token within Velocity: "transformPerspective". */
2617						CSS.Lists.transformsBase = CSS.Lists.transformsBase.concat(CSS.Lists.transforms3D);
2618					}
2619
2620					for (var i = 0; i < CSS.Lists.transformsBase.length; i++) {
2621						/* Wrap the dynamically generated normalization function in a new scope so that transformName's value is
2622						 paired with its respective function. (Otherwise, all functions would take the final for loop's transformName.) */
2623						(function() {
2624							var transformName = CSS.Lists.transformsBase[i];
2625
2626							CSS.Normalizations.registered[transformName] = function(type, element, propertyValue) {
2627								switch (type) {
2628									/* The normalized property name is the parent "transform" property -- the property that is actually set in CSS. */
2629									case "name":
2630										return "transform";
2631										/* Transform values are cached onto a per-element transformCache object. */
2632									case "extract":
2633										/* If this transform has yet to be assigned a value, return its null value. */
2634										if (Data(element) === undefined || Data(element).transformCache[transformName] === undefined) {
2635											/* Scale CSS.Lists.transformsBase default to 1 whereas all other transform properties default to 0. */
2636											return /^scale/i.test(transformName) ? 1 : 0;
2637											/* When transform values are set, they are wrapped in parentheses as per the CSS spec.
2638											 Thus, when extracting their values (for tween calculations), we strip off the parentheses. */
2639										}
2640										return Data(element).transformCache[transformName].replace(/[()]/g, "");
2641									case "inject":
2642										var invalid = false;
2643
2644										/* If an individual transform property contains an unsupported unit type, the browser ignores the *entire* transform property.
2645										 Thus, protect users from themselves by skipping setting for transform values supplied with invalid unit types. */
2646										/* Switch on the base transform type; ignore the axis by removing the last letter from the transform's name. */
2647										switch (transformName.substr(0, transformName.length - 1)) {
2648											/* Whitelist unit types for each transform. */
2649											case "translate":
2650												invalid = !/(%|px|em|rem|vw|vh|\d)$/i.test(propertyValue);
2651												break;
2652												/* Since an axis-free "scale" property is supported as well, a little hack is used here to detect it by chopping off its last letter. */
2653											case "scal":
2654											case "scale":
2655												/* Chrome on Android has a bug in which scaled elements blur if their initial scale
2656												 value is below 1 (which can happen with forcefeeding). Thus, we detect a yet-unset scale property
2657												 and ensure that its first value is always 1. More info: http://stackoverflow.com/questions/10417890/css3-animations-with-transform-causes-blurred-elements-on-webkit/10417962#10417962 */
2658												if (Velocity.State.isAndroid && Data(element).transformCache[transformName] === undefined && propertyValue < 1) {
2659													propertyValue = 1;
2660												}
2661
2662												invalid = !/(\d)$/i.test(propertyValue);
2663												break;
2664											case "skew":
2665												invalid = !/(deg|\d)$/i.test(propertyValue);
2666												break;
2667											case "rotate":
2668												invalid = !/(deg|\d)$/i.test(propertyValue);
2669												break;
2670										}
2671
2672										if (!invalid) {
2673											/* As per the CSS spec, wrap the value in parentheses. */
2674											Data(element).transformCache[transformName] = "(" + propertyValue + ")";
2675										}
2676
2677										/* Although the value is set on the transformCache object, return the newly-updated value for the calling code to process as normal. */
2678										return Data(element).transformCache[transformName];
2679								}
2680							};
2681						})();
2682					}
2683
2684					/*************
2685					 Colors
2686					 *************/
2687
2688					/* Since Velocity only animates a single numeric value per property, color animation is achieved by hooking the individual RGBA components of CSS color properties.
2689					 Accordingly, color values must be normalized (e.g. "#ff0000", "red", and "rgb(255, 0, 0)" ==> "255 0 0 1") so that their components can be injected/extracted by CSS.Hooks logic. */
2690					for (var j = 0; j < CSS.Lists.colors.length; j++) {
2691						/* Wrap the dynamically generated normalization function in a new scope so that colorName's value is paired with its respective function.
2692						 (Otherwise, all functions would take the final for loop's colorName.) */
2693						(function() {
2694							var colorName = CSS.Lists.colors[j];
2695
2696							/* Note: In IE<=8, which support rgb but not rgba, color properties are reverted to rgb by stripping off the alpha component. */
2697							CSS.Normalizations.registered[colorName] = function(type, element, propertyValue) {
2698								switch (type) {
2699									case "name":
2700										return colorName;
2701										/* Convert all color values into the rgb format. (Old IE can return hex values and color names instead of rgb/rgba.) */
2702									case "extract":
2703										var extracted;
2704
2705										/* If the color is already in its hookable form (e.g. "255 255 255 1") due to having been previously extracted, skip extraction. */
2706										if (CSS.RegEx.wrappedValueAlreadyExtracted.test(propertyValue)) {
2707											extracted = propertyValue;
2708										} else {
2709											var converted,
2710													colorNames = {
2711														black: "rgb(0, 0, 0)",
2712														blue: "rgb(0, 0, 255)",
2713														gray: "rgb(128, 128, 128)",
2714														green: "rgb(0, 128, 0)",
2715														red: "rgb(255, 0, 0)",
2716														white: "rgb(255, 255, 255)"
2717													};
2718
2719											/* Convert color names to rgb. */
2720											if (/^[A-z]+$/i.test(propertyValue)) {
2721												if (colorNames[propertyValue] !== undefined) {
2722													converted = colorNames[propertyValue];
2723												} else {
2724													/* If an unmatched color name is provided, default to black. */
2725													converted = colorNames.black;
2726												}
2727												/* Convert hex values to rgb. */
2728											} else if (CSS.RegEx.isHex.test(propertyValue)) {
2729												converted = "rgb(" + CSS.Values.hexToRgb(propertyValue).join(" ") + ")";
2730												/* If the provided color doesn't match any of the accepted color formats, default to black. */
2731											} else if (!(/^rgba?\(/i.test(propertyValue))) {
2732												converted = colorNames.black;
2733											}
2734
2735											/* Remove the surrounding "rgb/rgba()" string then replace commas with spaces and strip
2736											 repeated spaces (in case the value included spaces to begin with). */
2737											extracted = (converted || propertyValue).toString().match(CSS.RegEx.valueUnwrap)[1].replace(/,(\s+)?/g, " ");
2738										}
2739
2740										/* So long as this isn't <=IE8, add a fourth (alpha) component if it's missing and default it to 1 (visible). */
2741										if ((!IE || IE > 8) && extracted.split(" ").length === 3) {
2742											extracted += " 1";
2743										}
2744
2745										return extracted;
2746									case "inject":
2747										/* If we have a pattern then it might already have the right values */
2748										if (/^rgb/.test(propertyValue)) {
2749											return propertyValue;
2750										}
2751
2752										/* If this is IE<=8 and an alpha component exists, strip it off. */
2753										if (IE <= 8) {
2754											if (propertyValue.split(" ").length === 4) {
2755												propertyValue = propertyValue.split(/\s+/).slice(0, 3).join(" ");
2756											}
2757											/* Otherwise, add a fourth (alpha) component if it's missing and default it to 1 (visible). */
2758										} else if (propertyValue.split(" ").length === 3) {
2759											propertyValue += " 1";
2760										}
2761
2762										/* Re-insert the browser-appropriate wrapper("rgb/rgba()"), insert commas, and strip off decimal units
2763										 on all values but the fourth (R, G, and B only accept whole numbers). */
2764										return (IE <= 8 ? "rgb" : "rgba") + "(" + propertyValue.replace(/\s+/g, ",").replace(/\.(\d)+(?=,)/g, "") + ")";
2765								}
2766							};
2767						})();
2768					}
2769
2770					/**************
2771					 Dimensions
2772					 **************/
2773					function augmentDimension(name, element, wantInner) {
2774						var isBorderBox = CSS.getPropertyValue(element, "boxSizing").toString().toLowerCase() === "border-box";
2775
2776						if (isBorderBox === (wantInner || false)) {
2777							/* in box-sizing mode, the CSS width / height accessors already give the outerWidth / outerHeight. */
2778							var i,
2779									value,
2780									augment = 0,
2781									sides = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"],
2782									fields = ["padding" + sides[0], "padding" + sides[1], "border" + sides[0] + "Width", "border" + sides[1] + "Width"];
2783
2784							for (i = 0; i < fields.length; i++) {
2785								value = parseFloat(CSS.getPropertyValue(element, fields[i]));
2786								if (!isNaN(value)) {
2787									augment += value;
2788								}
2789							}
2790							return wantInner ? -augment : augment;
2791						}
2792						return 0;
2793					}
2794					function getDimension(name, wantInner) {
2795						return function(type, element, propertyValue) {
2796							switch (type) {
2797								case "name":
2798									return name;
2799								case "extract":
2800									return parseFloat(propertyValue) + augmentDimension(name, element, wantInner);
2801								case "inject":
2802									return (parseFloat(propertyValue) - augmentDimension(name, element, wantInner)) + "px";
2803							}
2804						};
2805					}
2806					CSS.Normalizations.registered.innerWidth = getDimension("width", true);
2807					CSS.Normalizations.registered.innerHeight = getDimension("height", true);
2808					CSS.Normalizations.registered.outerWidth = getDimension("width");
2809					CSS.Normalizations.registered.outerHeight = getDimension("height");
2810				}
2811			},
2812			/************************
2813			 CSS Property Names
2814			 ************************/
2815
2816			Names: {
2817				/* Camelcase a property name into its JavaScript notation (e.g. "background-color" ==> "backgroundColor").
2818				 Camelcasing is used to normalize property names between and across calls. */
2819				camelCase: function(property) {
2820					return property.replace(/-(\w)/g, function(match, subMatch) {
2821						return subMatch.toUpperCase();
2822					});
2823				},
2824				/* For SVG elements, some properties (namely, dimensional ones) are GET/SET via the element's HTML attributes (instead of via CSS styles). */
2825				SVGAttribute: function(property) {
2826					var SVGAttributes = "width|height|x|y|cx|cy|r|rx|ry|x1|x2|y1|y2";
2827
2828					/* Certain browsers require an SVG transform to be applied as an attribute. (Otherwise, application via CSS is preferable due to 3D support.) */
2829					if (IE || (Velocity.State.isAndroid && !Velocity.State.isChrome)) {
2830						SVGAttributes += "|transform";
2831					}
2832
2833					return new RegExp("^(" + SVGAttributes + ")$", "i").test(property);
2834				},
2835				/* Determine whether a property should be set with a vendor prefix. */
2836				/* If a prefixed version of the property exists, return it. Otherwise, return the original property name.
2837				 If the property is not at all supported by the browser, return a false flag. */
2838				prefixCheck: function(property) {
2839					/* If this property has already been checked, return the cached value. */
2840					if (Velocity.State.prefixMatches[property]) {
2841						return [Velocity.State.prefixMatches[property], true];
2842					} else {
2843						var vendors = ["", "Webkit", "Moz", "ms", "O"];
2844
2845						for (var i = 0, vendorsLength = vendors.length; i < vendorsLength; i++) {
2846							var propertyPrefixed;
2847
2848							if (i === 0) {
2849								propertyPrefixed = property;
2850							} else {
2851								/* Capitalize the first letter of the property to conform to JavaScript vendor prefix notation (e.g. webkitFilter). */
2852								propertyPrefixed = vendors[i] + property.replace(/^\w/, function(match) {
2853									return match.toUpperCase();
2854								});
2855							}
2856
2857							/* Check if the browser supports this property as prefixed. */
2858							if (Type.isString(Velocity.State.prefixElement.style[propertyPrefixed])) {
2859								/* Cache the match. */
2860								Velocity.State.prefixMatches[property] = propertyPrefixed;
2861
2862								return [propertyPrefixed, true];
2863							}
2864						}
2865
2866						/* If the browser doesn't support this property in any form, include a false flag so that the caller can decide how to proceed. */
2867						return [property, false];
2868					}
2869				}
2870			},
2871			/************************
2872			 CSS Property Values
2873			 ************************/
2874
2875			Values: {
2876				/* Hex to RGB conversion. Copyright Tim Down: http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb */
2877				hexToRgb: function(hex) {
2878					var shortformRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i,
2879							longformRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i,
2880							rgbParts;
2881
2882					hex = hex.replace(shortformRegex, function(m, r, g, b) {
2883						return r + r + g + g + b + b;
2884					});
2885
2886					rgbParts = longformRegex.exec(hex);
2887
2888					return rgbParts ? [parseInt(rgbParts[1], 16), parseInt(rgbParts[2], 16), parseInt(rgbParts[3], 16)] : [0, 0, 0];
2889				},
2890				isCSSNullValue: function(value) {
2891					/* The browser defaults CSS values that have not been set to either 0 or one of several possible null-value strings.
2892					 Thus, we check for both falsiness and these special strings. */
2893					/* Null-value checking is performed to default the special strings to 0 (for the sake of tweening) or their hook
2894					 templates as defined as CSS.Hooks (for the sake of hook injection/extraction). */
2895					/* Note: Chrome returns "rgba(0, 0, 0, 0)" for an undefined color whereas IE returns "transparent". */
2896					return (!value || /^(none|auto|transparent|(rgba\(0, ?0, ?0, ?0\)))$/i.test(value));
2897				},
2898				/* Retrieve a property's default unit type. Used for assigning a unit type when one is not supplied by the user. */
2899				getUnitType: function(property) {
2900					if (/^(rotate|skew)/i.test(property)) {
2901						return "deg";
2902					} else if (/(^(scale|scaleX|scaleY|scaleZ|alpha|flexGrow|flexHeight|zIndex|fontWeight)$)|((opacity|red|green|blue|alpha)$)/i.test(property)) {
2903						/* The above properties are unitless. */
2904						return "";
2905					} else {
2906						/* Default to px for all other properties. */
2907						return "px";
2908					}
2909				},
2910				/* HTML elements default to an associated display type when they're not set to display:none. */
2911				/* Note: This function is used for correctly setting the non-"none" display value in certain Velocity redirects, such as fadeIn/Out. */
2912				getDisplayType: function(element) {
2913					var tagName = element && element.tagName.toString().toLowerCase();
2914
2915					if (/^(b|big|i|small|tt|abbr|acronym|cite|code|dfn|em|kbd|strong|samp|var|a|bdo|br|img|map|object|q|script|span|sub|sup|button|input|label|select|textarea)$/i.test(tagName)) {
2916						return "inline";
2917					} else if (/^(li)$/i.test(tagName)) {
2918						return "list-item";
2919					} else if (/^(tr)$/i.test(tagName)) {
2920						return "table-row";
2921					} else if (/^(table)$/i.test(tagName)) {
2922						return "table";
2923					} else if (/^(tbody)$/i.test(tagName)) {
2924						return "table-row-group";
2925						/* Default to "block" when no match is found. */
2926					} else {
2927						return "block";
2928					}
2929				},
2930				/* The class add/remove functions are used to temporarily apply a "velocity-animating" class to elements while they're animating. */
2931				addClass: function(element, className) {
2932					if (element) {
2933						if (element.classList) {
2934							element.classList.add(className);
2935						} else if (Type.isString(element.className)) {
2936							// Element.className is around 15% faster then set/getAttribute
2937							element.className += (element.className.length ? " " : "") + className;
2938						} else {
2939							// Work around for IE strict mode animating SVG - and anything else that doesn't behave correctly - the same way jQuery does it
2940							var currentClass = element.getAttribute(IE <= 7 ? "className" : "class") || "";
2941
2942							element.setAttribute("class", currentClass + (currentClass ? " " : "") + className);
2943						}
2944					}
2945				},
2946				removeClass: function(element, className) {
2947					if (element) {
2948						if (element.classList) {
2949							element.classList.remove(className);
2950						} else if (Type.isString(element.className)) {
2951							// Element.className is around 15% faster then set/getAttribute
2952							// TODO: Need some jsperf tests on performance - can we get rid of the regex and maybe use split / array manipulation?
2953							element.className = element.className.toString().replace(new RegExp("(^|\\s)" + className.split(" ").join("|") + "(\\s|$)", "gi"), " ");
2954						} else {
2955							// Work around for IE strict mode animating SVG - and anything else that doesn't behave correctly - the same way jQuery does it
2956							var currentClass = element.getAttribute(IE <= 7 ? "className" : "class") || "";
2957
2958							element.setAttribute("class", currentClass.replace(new RegExp("(^|\s)" + className.split(" ").join("|") + "(\s|$)", "gi"), " "));
2959						}
2960					}
2961				}
2962			},
2963			/****************************
2964			 Style Getting & Setting
2965			 ****************************/
2966
2967			/* The singular getPropertyValue, which routes the logic for all normalizations, hooks, and standard CSS properties. */
2968			getPropertyValue: function(element, property, rootPropertyValue, forceStyleLookup) {
2969				/* Get an element's computed property value. */
2970				/* Note: Retrieving the value of a CSS property cannot simply be performed by checking an element's
2971				 style attribute (which only reflects user-defined values). Instead, the browser must be queried for a property's
2972				 *computed* value. You can read more about getComputedStyle here: https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle */
2973				function computePropertyValue(element, property) {
2974					/* When box-sizing isn't set to border-box, height and width style values are incorrectly computed when an
2975					 element's scrollbars are visible (which expands the element's dimensions). Thus, we defer to the more accurate
2976					 offsetHeight/Width property, which includes the total dimensions for interior, border, padding, and scrollbar.
2977					 We subtract border and padding to get the sum of interior + scrollbar. */
2978					var computedValue = 0;
2979
2980					/* IE<=8 doesn't support window.getComputedStyle, thus we defer to jQuery, which has an extensive array
2981					 of hacks to accurately retrieve IE8 property values. Re-implementing that logic here is not worth bloating the
2982					 codebase for a dying browser. The performance repercussions of using jQuery here are minimal since
2983					 Velocity is optimized to rarely (and sometimes never) query the DOM. Further, the $.css() codepath isn't that slow. */
2984					if (IE <= 8) {
2985						computedValue = $.css(element, property); /* GET */
2986						/* All other browsers support getComputedStyle. The returned live object reference is cached onto its
2987						 associated element so that it does not need to be refetched upon every GET. */
2988					} else {
2989						/* Browsers do not return height and width values for elements that are set to display:"none". Thus, we temporarily
2990						 toggle display to the element type's default value. */
2991						var toggleDisplay = false;
2992
2993						if (/^(width|height)$/.test(property) && CSS.getPropertyValue(element, "display") === 0) {
2994							toggleDisplay = true;
2995							CSS.setPropertyValue(element, "display", CSS.Values.getDisplayType(element));
2996						}
2997
2998						var revertDisplay = function() {
2999							if (toggleDisplay) {
3000								CSS.setPropertyValue(element, "display", "none");
3001							}
3002						};
3003
3004						if (!forceStyleLookup) {
3005							if (property === "height" && CSS.getPropertyValue(element, "boxSizing").toString().toLowerCase() !== "border-box") {
3006								var contentBoxHeight = element.offsetHeight - (parseFloat(CSS.getPropertyValue(element, "borderTopWidth")) || 0) - (parseFloat(CSS.getPropertyValue(element, "borderBottomWidth")) || 0) - (parseFloat(CSS.getPropertyValue(element, "paddingTop")) || 0) - (parseFloat(CSS.getPropertyValue(element, "paddingBottom")) || 0);
3007								revertDisplay();
3008
3009								return contentBoxHeight;
3010							} else if (property === "width" && CSS.getPropertyValue(element, "boxSizing").toString().toLowerCase() !== "border-box") {
3011								var contentBoxWidth = element.offsetWidth - (parseFloat(CSS.getPropertyValue(element, "borderLeftWidth")) || 0) - (parseFloat(CSS.getPropertyValue(element, "borderRightWidth")) || 0) - (parseFloat(CSS.getPropertyValue(element, "paddingLeft")) || 0) - (parseFloat(CSS.getPropertyValue(element, "paddingRight")) || 0);
3012								revertDisplay();
3013
3014								return contentBoxWidth;
3015							}
3016						}
3017
3018						var computedStyle;
3019
3020						/* For elements that Velocity hasn't been called on directly (e.g. when Velocity queries the DOM on behalf
3021						 of a parent of an element its animating), perform a direct getComputedStyle lookup since the object isn't cached. */
3022						if (Data(element) === undefined) {
3023							computedStyle = window.getComputedStyle(element, null); /* GET */
3024							/* If the computedStyle object has yet to be cached, do so now. */
3025						} else if (!Data(element).computedStyle) {
3026							computedStyle = Data(element).computedStyle = window.getComputedStyle(element, null); /* GET */
3027							/* If computedStyle is cached, use it. */
3028						} else {
3029							computedStyle = Data(element).computedStyle;
3030						}
3031
3032						/* IE and Firefox do not return a value for the generic borderColor -- they only return individual values for each border side's color.
3033						 Also, in all browsers, when border colors aren't all the same, a compound value is returned that Velocity isn't setup to parse.
3034						 So, as a polyfill for querying individual border side colors, we just return the top border's color and animate all borders from that value. */
3035						if (property === "borderColor") {
3036							property = "borderTopColor";
3037						}
3038
3039						/* IE9 has a bug in which the "filter" property must be accessed from computedStyle using the getPropertyValue method
3040						 instead of a direct property lookup. The getPropertyValue method is slower than a direct lookup, which is why we avoid it by default. */
3041						if (IE === 9 && property === "filter") {
3042							computedValue = computedStyle.getPropertyValue(property); /* GET */
3043						} else {
3044							computedValue = computedStyle[property];
3045						}
3046
3047						/* Fall back to the property's style value (if defined) when computedValue returns nothing,
3048						 which can happen when the element hasn't been painted. */
3049						if (computedValue === "" || computedValue === null) {
3050							computedValue = element.style[property];
3051						}
3052
3053						revertDisplay();
3054					}
3055
3056					/* For top, right, bottom, and left (TRBL) values that are set to "auto" on elements of "fixed" or "absolute" position,
3057					 defer to jQuery for converting "auto" to a numeric value. (For elements with a "static" or "relative" position, "auto" has the same
3058					 effect as being set to 0, so no conversion is necessary.) */
3059					/* An example of why numeric conversion is necessary: When an element with "position:absolute" has an untouched "left"
3060					 property, which reverts to "auto", left's value is 0 relative to its parent element, but is often non-zero relative
3061					 to its *containing* (not parent) element, which is the nearest "position:relative" ancestor or the viewport (and always the viewport in the case of "position:fixed"). */
3062					if (computedValue === "auto" && /^(top|right|bottom|left)$/i.test(property)) {
3063						var position = computePropertyValue(element, "position"); /* GET */
3064
3065						/* For absolute positioning, jQuery's $.position() only returns values for top and left;
3066						 right and bottom will have their "auto" value reverted to 0. */
3067						/* Note: A jQuery object must be created here since jQuery doesn't have a low-level alias for $.position().
3068						 Not a big deal since we're currently in a GET batch anyway. */
3069						if (position === "fixed" || (position === "absolute" && /top|left/i.test(property))) {
3070							/* Note: jQuery strips the pixel unit from its returned values; we re-add it here to conform with computePropertyValue's behavior. */
3071							computedValue = $(element).position()[property] + "px"; /* GET */
3072						}
3073					}
3074
3075					return computedValue;
3076				}
3077
3078				var propertyValue;
3079
3080				/* If this is a hooked property (e.g. "clipLeft" instead of the root property of "clip"),
3081				 extract the hook's value from a normalized rootPropertyValue using CSS.Hooks.extractValue(). */
3082				if (CSS.Hooks.registered[property]) {
3083					var hook = property,
3084							hookRoot = CSS.Hooks.getRoot(hook);
3085
3086					/* If a cached rootPropertyValue wasn't passed in (which Velocity always attempts to do in order to avoid requerying the DOM),
3087					 query the DOM for the root property's value. */
3088					if (rootPropertyValue === undefined) {
3089						/* Since the browser is now being directly queried, use the official post-prefixing property name for this lookup. */
3090						rootPropertyValue = CSS.getPropertyValue(element, CSS.Names.prefixCheck(hookRoot)[0]); /* GET */
3091					}
3092
3093					/* If this root has a normalization registered, peform the associated normalization extraction. */
3094					if (CSS.Normalizations.registered[hookRoot]) {
3095						rootPropertyValue = CSS.Normalizations.registered[hookRoot]("extract", element, rootPropertyValue);
3096					}
3097
3098					/* Extract the hook's value. */
3099					propertyValue = CSS.Hooks.extractValue(hook, rootPropertyValue);
3100
3101					/* If this is a normalized property (e.g. "opacity" becomes "filter" in <=IE8) or "translateX" becomes "transform"),
3102					 normalize the property's name and value, and handle the special case of transforms. */
3103					/* Note: Normalizing a property is mutually exclusive from hooking a property since hook-extracted values are strictly
3104					 numerical and therefore do not require normalization extraction. */
3105				} else if (CSS.Normalizations.registered[property]) {
3106					var normalizedPropertyName,
3107							normalizedPropertyValue;
3108
3109					normalizedPropertyName = CSS.Normalizations.registered[property]("name", element);
3110
3111					/* Transform values are calculated via normalization extraction (see below), which checks against the element's transformCache.
3112					 At no point do transform GETs ever actually query the DOM; initial stylesheet values are never processed.
3113					 This is because parsing 3D transform matrices is not always accurate and would bloat our codebase;
3114					 thus, normalization extraction defaults initial transform values to their zero-values (e.g. 1 for scaleX and 0 for translateX). */
3115					if (normalizedPropertyName !== "transform") {
3116						normalizedPropertyValue = computePropertyValue(element, CSS.Names.prefixCheck(normalizedPropertyName)[0]); /* GET */
3117
3118						/* If the value is a CSS null-value and this property has a hook template, use that zero-value template so that hooks can be extracted from it. */
3119						if (CSS.Values.isCSSNullValue(normalizedPropertyValue) && CSS.Hooks.templates[property]) {
3120							normalizedPropertyValue = CSS.Hooks.templates[property][1];
3121						}
3122					}
3123
3124					propertyValue = CSS.Normalizations.registered[property]("extract", element, normalizedPropertyValue);
3125				}
3126
3127				/* If a (numeric) value wasn't produced via hook extraction or normalization, query the DOM. */
3128				if (!/^[\d-]/.test(propertyValue)) {
3129					/* For SVG elements, dimensional properties (which SVGAttribute() detects) are tweened via
3130					 their HTML attribute values instead of their CSS style values. */
3131					var data = Data(element);
3132
3133					if (data && data.isSVG && CSS.Names.SVGAttribute(property)) {
3134						/* Since the height/width attribute values must be set manually, they don't reflect computed values.
3135						 Thus, we use use getBBox() to ensure we always get values for elements with undefined height/width attributes. */
3136						if (/^(height|width)$/i.test(property)) {
3137							/* Firefox throws an error if .getBBox() is called on an SVG that isn't attached to the DOM. */
3138							try {
3139								propertyValue = element.getBBox()[property];
3140							} catch (error) {
3141								propertyValue = 0;
3142							}
3143							/* Otherwise, access the attribute value directly. */
3144						} else {
3145							propertyValue = element.getAttribute(property);
3146						}
3147					} else {
3148						propertyValue = computePropertyValue(element, CSS.Names.prefixCheck(property)[0]); /* GET */
3149					}
3150				}
3151
3152				/* Since property lookups are for animation purposes (which entails computing the numeric delta between start and end values),
3153				 convert CSS null-values to an integer of value 0. */
3154				if (CSS.Values.isCSSNullValue(propertyValue)) {
3155					propertyValue = 0;
3156				}
3157
3158				if (Velocity.debug >= 2) {
3159					console.log("Get " + property + ": " + propertyValue);
3160				}
3161
3162				return propertyValue;
3163			},
3164			/* The singular setPropertyValue, which routes the logic for all normalizations, hooks, and standard CSS properties. */
3165			setPropertyValue: function(element, property, propertyValue, rootPropertyValue, scrollData) {
3166				var propertyName = property;
3167
3168				/* In order to be subjected to call options and element queueing, scroll animation is routed through Velocity as if it were a standard CSS property. */
3169				if (property === "scroll") {
3170					/* If a container option is present, scroll the container instead of the browser window. */
3171					if (scrollData.container) {
3172						scrollData.container["scroll" + scrollData.direction] = propertyValue;
3173						/* Otherwise, Velocity defaults to scrolling the browser window. */
3174					} else {
3175						if (scrollData.direction === "Left") {
3176							window.scrollTo(propertyValue, scrollData.alternateValue);
3177						} else {
3178							window.scrollTo(scrollData.alternateValue, propertyValue);
3179						}
3180					}
3181				} else {
3182					/* Transforms (translateX, rotateZ, etc.) are applied to a per-element transformCache object, which is manually flushed via flushTransformCache().
3183					 Thus, for now, we merely cache transforms being SET. */
3184					if (CSS.Normalizations.registered[property] && CSS.Normalizations.registered[property]("name", element) === "transform") {
3185						/* Perform a normalization injection. */
3186						/* Note: The normalization logic handles the transformCache updating. */
3187						CSS.Normalizations.registered[property]("inject", element, propertyValue);
3188
3189						propertyName = "transform";
3190						propertyValue = Data(element).transformCache[property];
3191					} else {
3192						/* Inject hooks. */
3193						if (CSS.Hooks.registered[property]) {
3194							var hookName = property,
3195									hookRoot = CSS.Hooks.getRoot(property);
3196
3197							/* If a cached rootPropertyValue was not provided, query the DOM for the hookRoot's current value. */
3198							rootPropertyValue = rootPropertyValue || CSS.getPropertyValue(element, hookRoot); /* GET */
3199
3200							propertyValue = CSS.Hooks.injectValue(hookName, propertyValue, rootPropertyValue);
3201							property = hookRoot;
3202						}
3203
3204						/* Normalize names and values. */
3205						if (CSS.Normalizations.registered[property]) {
3206							propertyValue = CSS.Normalizations.registered[property]("inject", element, propertyValue);
3207							property = CSS.Normalizations.registered[property]("name", element);
3208						}
3209
3210						/* Assign the appropriate vendor prefix before performing an official style update. */
3211						propertyName = CSS.Names.prefixCheck(property)[0];
3212
3213						/* A try/catch is used for IE<=8, which throws an error when "invalid" CSS values are set, e.g. a negative width.
3214						 Try/catch is avoided for other browsers since it incurs a performance overhead. */
3215						if (IE <= 8) {
3216							try {
3217								element.style[propertyName] = propertyValue;
3218							} catch (error) {
3219								if (Velocity.debug) {
3220									console.log("Browser does not support [" + propertyValue + "] for [" + propertyName + "]");
3221								}
3222							}
3223							/* SVG elements have their dimensional properties (width, height, x, y, cx, etc.) applied directly as attributes instead of as styles. */
3224							/* Note: IE8 does not support SVG elements, so it's okay that we skip it for SVG animation. */
3225						} else {
3226							var data = Data(element);
3227
3228							if (data && data.isSVG && CSS.Names.SVGAttribute(property)) {
3229								/* Note: For SVG attributes, vendor-prefixed property names are never used. */
3230								/* Note: Not all CSS properties can be animated via attributes, but the browser won't throw an error for unsupported properties. */
3231								element.setAttribute(property, propertyValue);
3232							} else {
3233								element.style[propertyName] = propertyValue;
3234							}
3235						}
3236
3237						if (Velocity.debug >= 2) {
3238							console.log("Set " + property + " (" + propertyName + "): " + propertyValue);
3239						}
3240					}
3241				}
3242
3243				/* Return the normalized property name and value in case the caller wants to know how these values were modified before being applied to the DOM. */
3244				return [propertyName, propertyValue];
3245			},
3246			/* To increase performance by batching transform updates into a single SET, transforms are not directly applied to an element until flushTransformCache() is called. */
3247			/* Note: Velocity applies transform properties in the same order that they are chronogically introduced to the element's CSS styles. */
3248			flushTransformCache: function(element) {
3249				var transformString = "",
3250						data = Data(element);
3251
3252				/* Certain browsers require that SVG transforms be applied as an attribute. However, the SVG transform attribute takes a modified version of CSS's transform string
3253				 (units are dropped and, except for skewX/Y, subproperties are merged into their master property -- e.g. scaleX and scaleY are merged into scale(X Y). */
3254				if ((IE || (Velocity.State.isAndroid && !Velocity.State.isChrome)) && data && data.isSVG) {
3255					/* Since transform values are stored in their parentheses-wrapped form, we use a helper function to strip out their numeric values.
3256					 Further, SVG transform properties only take unitless (representing pixels) values, so it's okay that parseFloat() strips the unit suffixed to the float value. */
3257					var getTransformFloat = function(transformProperty) {
3258						return parseFloat(CSS.getPropertyValue(element, transformProperty));
3259					};
3260
3261					/* Create an object to organize all the transforms that we'll apply to the SVG element. To keep the logic simple,
3262					 we process *all* transform properties -- even those that may not be explicitly applied (since they default to their zero-values anyway). */
3263					var SVGTransforms = {
3264						translate: [getTransformFloat("translateX"), getTransformFloat("translateY")],
3265						skewX: [getTransformFloat("skewX")], skewY: [getTransformFloat("skewY")],
3266						/* If the scale property is set (non-1), use that value for the scaleX and scaleY values
3267						 (this behavior mimics the result of animating all these properties at once on HTML elements). */
3268						scale: getTransformFloat("scale") !== 1 ? [getTransformFloat("scale"), getTransformFloat("scale")] : [getTransformFloat("scaleX"), getTransformFloat("scaleY")],
3269						/* Note: SVG's rotate transform takes three values: rotation degrees followed by the X and Y values
3270						 defining the rotation's origin point. We ignore the origin values (default them to 0). */
3271						rotate: [getTransformFloat("rotateZ"), 0, 0]
3272					};
3273
3274					/* Iterate through the transform properties in the user-defined property map order.
3275					 (This mimics the behavior of non-SVG transform animation.) */
3276					$.each(Data(element).transformCache, function(transformName) {
3277						/* Except for with skewX/Y, revert the axis-specific transform subproperties to their axis-free master
3278						 properties so that they match up with SVG's accepted transform properties. */
3279						if (/^translate/i.test(transformName)) {
3280							transformName = "translate";
3281						} else if (/^scale/i.test(transformName)) {
3282							transformName = "scale";
3283						} else if (/^rotate/i.test(transformName)) {
3284							transformName = "rotate";
3285						}
3286
3287						/* Check that we haven't yet deleted the property from the SVGTransforms container. */
3288						if (SVGTransforms[transformName]) {
3289							/* Append the transform property in the SVG-supported transform format. As per the spec, surround the space-delimited values in parentheses. */
3290							transformString += transformName + "(" + SVGTransforms[transformName].join(" ") + ")" + " ";
3291
3292							/* After processing an SVG transform property, delete it from the SVGTransforms container so we don't
3293							 re-insert the same master property if we encounter another one of its axis-specific properties. */
3294							delete SVGTransforms[transformName];
3295						}
3296					});
3297				} else {
3298					var transformValue,
3299							perspective;
3300
3301					/* Transform properties are stored as members of the transformCache object. Concatenate all the members into a string. */
3302					$.each(Data(element).transformCache, function(transformName) {
3303						transformValue = Data(element).transformCache[transformName];
3304
3305						/* Transform's perspective subproperty must be set first in order to take effect. Store it temporarily. */
3306						if (transformName === "transformPerspective") {
3307							perspective = transformValue;
3308							return true;
3309						}
3310
3311						/* IE9 only supports one rotation type, rotateZ, which it refers to as "rotate". */
3312						if (IE === 9 && transformName === "rotateZ") {
3313							transformName = "rotate";
3314						}
3315
3316						transformString += transformName + transformValue + " ";
3317					});
3318
3319					/* If present, set the perspective subproperty first. */
3320					if (perspective) {
3321						transformString = "perspective" + perspective + " " + transformString;
3322					}
3323				}
3324
3325				CSS.setPropertyValue(element, "transform", transformString);
3326			}
3327		};
3328
3329		/* Register hooks and normalizations. */
3330		CSS.Hooks.register();
3331		CSS.Normalizations.register();
3332
3333		/* Allow hook setting in the same fashion as jQuery's $.css(). */
3334		Velocity.hook = function(elements, arg2, arg3) {
3335			var value;
3336
3337			elements = sanitizeElements(elements);
3338
3339			$.each(elements, function(i, element) {
3340				/* Initialize Velocity's per-element data cache if this element hasn't previously been animated. */
3341				if (Data(element) === undefined) {
3342					Velocity.init(element);
3343				}
3344
3345				/* Get property value. If an element set was passed in, only return the value for the first element. */
3346				if (arg3 === undefined) {
3347					if (value === undefined) {
3348						value = CSS.getPropertyValue(element, arg2);
3349					}
3350					/* Set property value. */
3351				} else {
3352					/* sPV returns an array of the normalized propertyName/propertyValue pair used to update the DOM. */
3353					var adjustedSet = CSS.setPropertyValue(element, arg2, arg3);
3354
3355					/* Transform properties don't automatically set. They have to be flushed to the DOM. */
3356					if (adjustedSet[0] === "transform") {
3357						Velocity.CSS.flushTransformCache(element);
3358					}
3359
3360					value = adjustedSet;
3361				}
3362			});
3363
3364			return value;
3365		};
3366
3367		/*****************
3368		 Animation
3369		 *****************/
3370
3371		var animate = function() {
3372			var opts;
3373
3374			/******************
3375			 Call Chain
3376			 ******************/
3377
3378			/* Logic for determining what to return to the call stack when exiting out of Velocity. */
3379			function getChain() {
3380				/* If we are using the utility function, attempt to return this call's promise. If no promise library was detected,
3381				 default to null instead of returning the targeted elements so that utility function's return value is standardized. */
3382				if (isUtility) {
3383					return promiseData.promise || null;
3384					/* Otherwise, if we're using $.fn, return the jQuery-/Zepto-wrapped element set. */
3385				} else {
3386					return elementsWrapped;
3387				}
3388			}
3389
3390			/*************************
3391			 Arguments Assignment
3392			 *************************/
3393
3394			/* To allow for expressive CoffeeScript code, Velocity supports an alternative syntax in which "elements" (or "e"), "properties" (or "p"), and "options" (or "o")
3395			 objects are defined on a container object that's passed in as Velocity's sole argument. */
3396			/* Note: Some browsers automatically populate arguments with a "properties" object. We detect it by checking for its default "names" property. */
3397			var syntacticSugar = (arguments[0] && (arguments[0].p || (($.isPlainObject(arguments[0].properties) && !arguments[0].properties.names) || Type.isString(arguments[0].properties)))),
3398					/* Whether Velocity was called via the utility function (as opposed to on a jQuery/Zepto object). */
3399					isUtility,
3400					/* When Velocity is called via the utility function ($.Velocity()/Velocity()), elements are explicitly
3401					 passed in as the first parameter. Thus, argument positioning varies. We normalize them here. */
3402					elementsWrapped,
3403					argumentIndex;
3404
3405			var elements,
3406					propertiesMap,
3407					options;
3408
3409			/* Detect jQuery/Zepto elements being animated via the $.fn method. */
3410			if (Type.isWrapped(this)) {
3411				isUtility = false;
3412
3413				argumentIndex = 0;
3414				elements = this;
3415				elementsWrapped = this;
3416				/* Otherwise, raw elements are being animated via the utility function. */
3417			} else {
3418				isUtility = true;
3419
3420				argumentIndex = 1;
3421				elements = syntacticSugar ? (arguments[0].elements || arguments[0].e) : arguments[0];
3422			}
3423
3424			/***************
3425			 Promises
3426			 ***************/
3427
3428			var promiseData = {
3429				promise: null,
3430				resolver: null,
3431				rejecter: null
3432			};
3433
3434			/* If this call was made via the utility function (which is the default method of invocation when jQuery/Zepto are not being used), and if
3435			 promise support was detected, create a promise object for this call and store references to its resolver and rejecter methods. The resolve
3436			 method is used when a call completes naturally or is prematurely stopped by the user. In both cases, completeCall() handles the associated
3437			 call cleanup and promise resolving logic. The reject method is used when an invalid set of arguments is passed into a Velocity call. */
3438			/* Note: Velocity employs a call-based queueing architecture, which means that stopping an animating element actually stops the full call that
3439			 triggered it -- not that one element exclusively. Similarly, there is one promise per call, and all elements targeted by a Velocity call are
3440			 grouped together for the purposes of resolving and rejecting a promise. */
3441			if (isUtility && Velocity.Promise) {
3442				promiseData.promise = new Velocity.Promise(function(resolve, reject) {
3443					promiseData.resolver = resolve;
3444					promiseData.rejecter = reject;
3445				});
3446			}
3447
3448			if (syntacticSugar) {
3449				propertiesMap = arguments[0].properties || arguments[0].p;
3450				options = arguments[0].options || arguments[0].o;
3451			} else {
3452				propertiesMap = arguments[argumentIndex];
3453				options = arguments[argumentIndex + 1];
3454			}
3455
3456			elements = sanitizeElements(elements);
3457
3458			if (!elements) {
3459				if (promiseData.promise) {
3460					if (!propertiesMap || !options || options.promiseRejectEmpty !== false) {
3461						promiseData.rejecter();
3462					} else {
3463						promiseData.resolver();
3464					}
3465				}
3466				return;
3467			}
3468
3469			/* The length of the element set (in the form of a nodeList or an array of elements) is defaulted to 1 in case a
3470			 single raw DOM element is passed in (which doesn't contain a length property). */
3471			var elementsLength = elements.length,
3472					elementsIndex = 0;
3473
3474			/***************************
3475			 Argument Overloading
3476			 ***************************/
3477
3478			/* Support is included for jQuery's argument overloading: $.animate(propertyMap [, duration] [, easing] [, complete]).
3479			 Overloading is detected by checking for the absence of an object being passed into options. */
3480			/* Note: The stop/finish/pause/resume actions do not accept animation options, and are therefore excluded from this check. */
3481			if (!/^(stop|finish|finishAll|pause|resume)$/i.test(propertiesMap) && !$.isPlainObject(options)) {
3482				/* The utility function shifts all arguments one position to the right, so we adjust for that offset. */
3483				var startingArgumentPosition = argumentIndex + 1;
3484
3485				options = {};
3486
3487				/* Iterate through all options arguments */
3488				for (var i = startingArgumentPosition; i < arguments.length; i++) {
3489					/* Treat a number as a duration. Parse it out. */
3490					/* Note: The following RegEx will return true if passed an array with a number as its first item.
3491					 Thus, arrays are skipped from this check. */
3492					if (!Type.isArray(arguments[i]) && (/^(fast|normal|slow)$/i.test(arguments[i]) || /^\d/.test(arguments[i]))) {
3493						options.duration = arguments[i];
3494						/* Treat strings and arrays as easings. */
3495					} else if (Type.isString(arguments[i]) || Type.isArray(arguments[i])) {
3496						options.easing = arguments[i];
3497						/* Treat a function as a complete callback. */
3498					} else if (Type.isFunction(arguments[i])) {
3499						options.complete = arguments[i];
3500					}
3501				}
3502			}
3503
3504			/*********************
3505			 Action Detection
3506			 *********************/
3507
3508			/* Velocity's behavior is categorized into "actions": Elements can either be specially scrolled into view,
3509			 or they can be started, stopped, paused, resumed, or reversed . If a literal or referenced properties map is passed in as Velocity's
3510			 first argument, the associated action is "start". Alternatively, "scroll", "reverse", "pause", "resume" or "stop" can be passed in 
3511			 instead of a properties map. */
3512			var action;
3513
3514			switch (propertiesMap) {
3515				case "scroll":
3516					action = "scroll";
3517					break;
3518
3519				case "reverse":
3520					action = "reverse";
3521					break;
3522
3523				case "pause":
3524
3525					/*******************
3526					 Action: Pause
3527					 *******************/
3528
3529					var currentTime = (new Date()).getTime();
3530
3531					/* Handle delay timers */
3532					$.each(elements, function(i, element) {
3533						pauseDelayOnElement(element, currentTime);
3534					});
3535
3536					/* Pause and Resume are call-wide (not on a per element basis). Thus, calling pause or resume on a 
3537					 single element will cause any calls that containt tweens for that element to be paused/resumed
3538					 as well. */
3539
3540					/* Iterate through all calls and pause any that contain any of our elements */
3541					$.each(Velocity.State.calls, function(i, activeCall) {
3542
3543						var found = false;
3544						/* Inactive calls are set to false by the logic inside completeCall(). Skip them. */
3545						if (activeCall) {
3546							/* Iterate through the active call's targeted elements. */
3547							$.each(activeCall[1], function(k, activeElement) {
3548								var queueName = (options === undefined) ? "" : options;
3549
3550								if (queueName !== true && (activeCall[2].queue !== queueName) && !(options === undefined && activeCall[2].queue === false)) {
3551									return true;
3552								}
3553
3554								/* Iterate through the calls targeted by the stop command. */
3555								$.each(elements, function(l, element) {
3556									/* Check that this call was applied to the target element. */
3557									if (element === activeElement) {
3558
3559										/* Set call to paused */
3560										activeCall[5] = {
3561											resume: false
3562										};
3563
3564										/* Once we match an element, we can bounce out to the next call entirely */
3565										found = true;
3566										return false;
3567									}
3568								});
3569
3570								/* Proceed to check next call if we have already matched */
3571								if (found) {
3572									return false;
3573								}
3574							});
3575						}
3576
3577					});
3578
3579					/* Since pause creates no new tweens, exit out of Velocity. */
3580					return getChain();
3581
3582				case "resume":
3583
3584					/*******************
3585					 Action: Resume
3586					 *******************/
3587
3588					/* Handle delay timers */
3589					$.each(elements, function(i, element) {
3590						resumeDelayOnElement(element, currentTime);
3591					});
3592
3593					/* Pause and Resume are call-wide (not on a per elemnt basis). Thus, calling pause or resume on a 
3594					 single element will cause any calls that containt tweens for that element to be paused/resumed
3595					 as well. */
3596
3597					/* Iterate through all calls and pause any that contain any of our elements */
3598					$.each(Velocity.State.calls, function(i, activeCall) {
3599						var found = false;
3600						/* Inactive calls are set to false by the logic inside completeCall(). Skip them. */
3601						if (activeCall) {
3602							/* Iterate through the active call's targeted elements. */
3603							$.each(activeCall[1], function(k, activeElement) {
3604								var queueName = (options === undefined) ? "" : options;
3605
3606								if (queueName !== true && (activeCall[2].queue !== queueName) && !(options === undefined && activeCall[2].queue === false)) {
3607									return true;
3608								}
3609
3610								/* Skip any calls that have never been paused */
3611								if (!activeCall[5]) {
3612									return true;
3613								}
3614
3615								/* Iterate through the calls targeted by the stop command. */
3616								$.each(elements, function(l, element) {
3617									/* Check that this call was applied to the target element. */
3618									if (element === activeElement) {
3619
3620										/* Flag a pause object to be resumed, which will occur during the next tick. In
3621										 addition, the pause object will at that time be deleted */
3622										activeCall[5].resume = true;
3623
3624										/* Once we match an element, we can bounce out to the next call entirely */
3625										found = true;
3626										return false;
3627									}
3628								});
3629
3630								/* Proceed to check next call if we have already matched */
3631								if (found) {
3632									return false;
3633								}
3634							});
3635						}
3636
3637					});
3638
3639					/* Since resume creates no new tweens, exit out of Velocity. */
3640					return getChain();
3641
3642				case "finish":
3643				case "finishAll":
3644				case "stop":
3645					/*******************
3646					 Action: Stop
3647					 *******************/
3648
3649					/* Clear the currently-active delay on each targeted element. */
3650					$.each(elements, function(i, element) {
3651						if (Data(element) && Data(element).delayTimer) {
3652							/* Stop the timer from triggering its cached next() function. */
3653							clearTimeout(Data(element).delayTimer.setTimeout);
3654
3655							/* Manually call the next() function so that the subsequent queue items can progress. */
3656							if (Data(element).delayTimer.next) {
3657								Data(element).delayTimer.next();
3658							}
3659
3660							delete Data(element).delayTimer;
3661						}
3662
3663						/* If we want to finish everything in the queue, we have to iterate through it
3664						 and call each function. This will make them active calls below, which will
3665						 cause them to be applied via the duration setting. */
3666						if (propertiesMap === "finishAll" && (options === true || Type.isString(options))) {
3667							/* Iterate through the items in the element's queue. */
3668							$.each($.queue(element, Type.isString(options) ? options : ""), function(_, item) {
3669								/* The queue array can contain an "inprogress" string, which we skip. */
3670								if (Type.isFunction(item)) {
3671									item();
3672								}
3673							});
3674
3675							/* Clearing the $.queue() array is achieved by resetting it to []. */
3676							$.queue(element, Type.isString(options) ? options : "", []);
3677						}
3678					});
3679
3680					var callsToStop = [];
3681
3682					/* When the stop action is triggered, the elements' currently active call is immediately stopped. The active call might have
3683					 been applied to multiple elements, in which case all of the call's elements will be stopped. When an element
3684					 is stopped, the next item in its animation queue is immediately triggered. */
3685					/* An additional argument may be passed in to clear an element's remaining queued calls. Either true (which defaults to the "fx" queue)
3686					 or a custom queue string can be passed in. */
3687					/* Note: The stop command runs prior to Velocity's Queueing phase since its behavior is intended to take effect *immediately*,
3688					 regardless of the element's current queue state. */
3689
3690					/* Iterate through every active call. */
3691					$.each(Velocity.State.calls, function(i, activeCall) {
3692						/* Inactive calls are set to false by the logic inside completeCall(). Skip them. */
3693						if (activeCall) {
3694							/* Iterate through the active call's targeted elements. */
3695							$.each(activeCall[1], function(k, activeElement) {
3696								/* If true was passed in as a secondary argument, clear absolutely all calls on this element. Otherwise, only
3697								 clear calls associated with the relevant queue. */
3698								/* Call stopping logic works as follows:
3699								 - options === true --> stop current default queue calls (and queue:false calls), including remaining queued ones.
3700								 - options === undefined --> stop current queue:"" call and all queue:false calls.
3701								 - options === false --> stop only queue:false calls.
3702								 - options === "custom" --> stop current queue:"custom" call, including remaining queued ones (there is no functionality to only clear the currently-running queue:"custom" call). */
3703								var queueName = (options === undefined) ? "" : options;
3704
3705								if (queueName !== true && (activeCall[2].queue !== queueName) && !(options === undefined && activeCall[2].queue === false)) {
3706									return true;
3707								}
3708
3709								/* Iterate through the calls targeted by the stop command. */
3710								$.each(elements, function(l, element) {
3711									/* Check that this call was applied to the target element. */
3712									if (element === activeElement) {
3713										/* Optionally clear the remaining queued calls. If we're doing "finishAll" this won't find anything,
3714										 due to the queue-clearing above. */
3715										if (options === true || Type.isString(options)) {
3716											/* Iterate through the items in the element's queue. */
3717											$.each($.queue(element, Type.isString(options) ? options : ""), function(_, item) {
3718												/* The queue array can contain an "inprogress" string, which we skip. */
3719												if (Type.isFunction(item)) {
3720													/* Pass the item's callback a flag indicating that we want to abort from the queue call.
3721													 (Specifically, the queue will resolve the call's associated promise then abort.)  */
3722													item(null, true);
3723												}
3724											});
3725
3726											/* Clearing the $.queue() array is achieved by resetting it to []. */
3727											$.queue(element, Type.isString(options) ? options : "", []);
3728										}
3729
3730										if (propertiesMap === "stop") {
3731											/* Since "reverse" uses cached start values (the previous call's endValues), these values must be
3732											 changed to reflect the final value that the elements were actually tweened to. */
3733											/* Note: If only queue:false/queue:"custom" animations are currently running on an element, it won't have a tweensContainer
3734											 object. Also, queue:false/queue:"custom" animations can't be reversed. */
3735											var data = Data(element);
3736											if (data && data.tweensContainer && (queueName === true || queueName === "")) {
3737												$.each(data.tweensContainer, function(m, activeTween) {
3738													activeTween.endValue = activeTween.currentValue;
3739												});
3740											}
3741
3742											callsToStop.push(i);
3743										} else if (propertiesMap === "finish" || propertiesMap === "finishAll") {
3744											/* To get active tweens to finish immediately, we forcefully shorten their durations to 1ms so that
3745											 they finish upon the next rAf tick then proceed with normal call completion logic. */
3746											activeCall[2].duration = 1;
3747										}
3748									}
3749								});
3750							});
3751						}
3752					});
3753
3754					/* Prematurely call completeCall() on each matched active call. Pass an additional flag for "stop" to indicate
3755					 that the complete callback and display:none setting should be skipped since we're completing prematurely. */
3756					if (propertiesMap === "stop") {
3757						$.each(callsToStop, function(i, j) {
3758							completeCall(j, true);
3759						});
3760
3761						if (promiseData.promise) {
3762							/* Immediately resolve the promise associated with this stop call since stop runs synchronously. */
3763							promiseData.resolver(elements);
3764						}
3765					}
3766
3767					/* Since we're stopping, and not proceeding with queueing, exit out of Velocity. */
3768					return getChain();
3769
3770				default:
3771					/* Treat a non-empty plain object as a literal properties map. */
3772					if ($.isPlainObject(propertiesMap) && !Type.isEmptyObject(propertiesMap)) {
3773						action = "start";
3774
3775						/****************
3776						 Redirects
3777						 ****************/
3778
3779						/* Check if a string matches a registered redirect (see Redirects above). */
3780					} else if (Type.isString(propertiesMap) && Velocity.Redirects[propertiesMap]) {
3781						opts = $.extend({}, options);
3782
3783						var durationOriginal = opts.duration,
3784								delayOriginal = opts.delay || 0;
3785
3786						/* If the backwards option was passed in, reverse the element set so that elements animate from the last to the first. */
3787						if (opts.backwards === true) {
3788							elements = $.extend(true, [], elements).reverse();
3789						}
3790
3791						/* Individually trigger the redirect for each element in the set to prevent users from having to handle iteration logic in their redirect. */
3792						$.each(elements, function(elementIndex, element) {
3793							/* If the stagger option was passed in, successively delay each element by the stagger value (in ms). Retain the original delay value. */
3794							if (parseFloat(opts.stagger)) {
3795								opts.delay = delayOriginal + (parseFloat(opts.stagger) * elementIndex);
3796							} else if (Type.isFunction(opts.stagger)) {
3797								opts.delay = delayOriginal + opts.stagger.call(element, elementIndex, elementsLength);
3798							}
3799
3800							/* If the drag option was passed in, successively increase/decrease (depending on the presense of opts.backwards)
3801							 the duration of each element's animation, using floors to prevent producing very short durations. */
3802							if (opts.drag) {
3803								/* Default the duration of UI pack effects (callouts and transitions) to 1000ms instead of the usual default duration of 400ms. */
3804								opts.duration = parseFloat(durationOriginal) || (/^(callout|transition)/.test(propertiesMap) ? 1000 : DURATION_DEFAULT);
3805
3806								/* For each element, take the greater duration of: A) animation completion percentage relative to the original duration,
3807								 B) 75% of the original duration, or C) a 200ms fallback (in case duration is already set to a low value).
3808								 The end result is a baseline of 75% of the redirect's duration that increases/decreases as the end of the element set is approached. */
3809								opts.duration = Math.max(opts.duration * (opts.backwards ? 1 - elementIndex / elementsLength : (elementIndex + 1) / elementsLength), opts.duration * 0.75, 200);
3810							}
3811
3812							/* Pass in the call's opts object so that the redirect can optionally extend it. It defaults to an empty object instead of null to
3813							 reduce the opts checking logic required inside the redirect. */
3814							Velocity.Redirects[propertiesMap].call(element, element, opts || {}, elementIndex, elementsLength, elements, promiseData.promise ? promiseData : undefined);
3815						});
3816
3817						/* Since the animation logic resides within the redirect's own code, abort the remainder of this call.
3818						 (The performance overhead up to this point is virtually non-existant.) */
3819						/* Note: The jQuery call chain is kept intact by returning the complete element set. */
3820						return getChain();
3821					} else {
3822						var abortError = "Velocity: First argument (" + propertiesMap + ") was not a property map, a known action, or a registered redirect. Aborting.";
3823
3824						if (promiseData.promise) {
3825							promiseData.rejecter(new Error(abortError));
3826						} else if (window.console) {
3827							console.log(abortError);
3828						}
3829
3830						return getChain();
3831					}
3832			}
3833
3834			/**************************
3835			 Call-Wide Variables
3836			 **************************/
3837
3838			/* A container for CSS unit conversion ratios (e.g. %, rem, and em ==> px) that is used to cache ratios across all elements
3839			 being animated in a single Velocity call. Calculating unit ratios necessitates DOM querying and updating, and is therefore
3840			 avoided (via caching) wherever possible. This container is call-wide instead of page-wide to avoid the risk of using stale
3841			 conversion metrics across Velocity animations that are not immediately consecutively chained. */
3842			var callUnitConversionData = {
3843				lastParent: null,
3844				lastPosition: null,
3845				lastFontSize: null,
3846				lastPercentToPxWidth: null,
3847				lastPercentToPxHeight: null,
3848				lastEmToPx: null,
3849				remToPx: null,
3850				vwToPx: null,
3851				vhToPx: null
3852			};
3853
3854			/* A container for all the ensuing tween data and metadata associated with this call. This container gets pushed to the page-wide
3855			 Velocity.State.calls array that is processed during animation ticking. */
3856			var call = [];
3857
3858			/************************
3859			 Element Processing
3860			 ************************/
3861
3862			/* Element processing consists of three parts -- data processing that cannot go stale and data processing that *can* go stale (i.e. third-party style modifications):
3863			 1) Pre-Queueing: Element-wide variables, including the element's data storage, are instantiated. Call options are prepared. If triggered, the Stop action is executed.
3864			 2) Queueing: The logic that runs once this call has reached its point of execution in the element's $.queue() stack. Most logic is placed here to avoid risking it becoming stale.
3865			 3) Pushing: Consolidation of the tween data followed by its push onto the global in-progress calls container.
3866			 `elementArrayIndex` allows passing index of the element in the original array to value functions.
3867			 If `elementsIndex` were used instead the index would be determined by the elements' per-element queue.
3868			 */
3869			function processElement(element, elementArrayIndex) {
3870
3871				/*************************
3872				 Part I: Pre-Queueing
3873				 *************************/
3874
3875				/***************************
3876				 Element-Wide Variables
3877				 ***************************/
3878
3879				var /* The runtime opts object is the extension of the current call's options and Velocity's page-wide option defaults. */
3880						opts = $.extend({}, Velocity.defaults, options),
3881						/* A container for the processed data associated with each property in the propertyMap.
3882						 (Each property in the map produces its own "tween".) */
3883						tweensContainer = {},
3884						elementUnitConversionData;
3885
3886				/******************
3887				 Element Init
3888				 ******************/
3889
3890				if (Data(element) === undefined) {
3891					Velocity.init(element);
3892				}
3893
3894				/******************
3895				 Option: Delay
3896				 ******************/
3897
3898				/* Since queue:false doesn't respect the item's existing queue, we avoid injecting its delay here (it's set later on). */
3899				/* Note: Velocity rolls its own delay function since jQuery doesn't have a utility alias for $.fn.delay()
3900				 (and thus requires jQuery element creation, which we avoid since its overhead includes DOM querying). */
3901				if (parseFloat(opts.delay) && opts.queue !== false) {
3902					$.queue(element, opts.queue, function(next, clearQueue) {
3903						if (clearQueue === true) {
3904							/* Do not continue with animation queueing. */
3905							return true;
3906						}
3907
3908						/* This is a flag used to indicate to the upcoming completeCall() function that this queue entry was initiated by Velocity. See completeCall() for further details. */
3909						Velocity.velocityQueueEntryFlag = true;
3910
3911						/* The ensuing queue item (which is assigned to the "next" argument that $.queue() automatically passes in) will be triggered after a setTimeout delay.
3912						 The setTimeout is stored so that it can be subjected to clearTimeout() if this animation is prematurely stopped via Velocity's "stop" command, and
3913						 delayBegin/delayTime is used to ensure we can "pause" and "resume" a tween that is still mid-delay. */
3914
3915						/* Temporarily store delayed elements to facilite access for global pause/resume */
3916						var callIndex = Velocity.State.delayedElements.count++;
3917						Velocity.State.delayedElements[callIndex] = element;
3918
3919						var delayComplete = (function(index) {
3920							return function() {
3921								/* Clear the temporary element */
3922								Velocity.State.delayedElements[index] = false;
3923
3924								/* Finally, issue the call */
3925								next();
3926							};
3927						})(callIndex);
3928
3929
3930						Data(element).delayBegin = (new Date()).getTime();
3931						Data(element).delay = parseFloat(opts.delay);
3932						Data(element).delayTimer = {
3933							setTimeout: setTimeout(next, parseFloat(opts.delay)),
3934							next: delayComplete
3935						};
3936					});
3937				}
3938
3939				/*********************
3940				 Option: Duration
3941				 *********************/
3942
3943				/* Support for jQuery's named durations. */
3944				switch (opts.duration.toString().toLowerCase()) {
3945					case "fast":
3946						opts.duration = 200;
3947						break;
3948
3949					case "normal":
3950						opts.duration = DURATION_DEFAULT;
3951						break;
3952
3953					case "slow":
3954						opts.duration = 600;
3955						break;
3956
3957					default:
3958						/* Remove the potential "ms" suffix and default to 1 if the user is attempting to set a duration of 0 (in order to produce an immediate style change). */
3959						opts.duration = parseFloat(opts.duration) || 1;
3960				}
3961
3962				/************************
3963				 Global Option: Mock
3964				 ************************/
3965
3966				if (Velocity.mock !== false) {
3967					/* In mock mode, all animations are forced to 1ms so that they occur immediately upon the next rAF tick.
3968					 Alternatively, a multiplier can be passed in to time remap all delays and durations. */
3969					if (Velocity.mock === true) {
3970						opts.duration = opts.delay = 1;
3971					} else {
3972						opts.duration *= parseFloat(Velocity.mock) || 1;
3973						opts.delay *= parseFloat(Velocity.mock) || 1;
3974					}
3975				}
3976
3977				/*******************
3978				 Option: Easing
3979				 *******************/
3980
3981				opts.easing = getEasing(opts.easing, opts.duration);
3982
3983				/**********************
3984				 Option: Callbacks
3985				 **********************/
3986
3987				/* Callbacks must functions. Otherwise, default to null. */
3988				if (opts.begin && !Type.isFunction(opts.begin)) {
3989					opts.begin = null;
3990				}
3991
3992				if (opts.progress && !Type.isFunction(opts.progress)) {
3993					opts.progress = null;
3994				}
3995
3996				if (opts.complete && !Type.isFunction(opts.complete)) {
3997					opts.complete = null;
3998				}
3999
4000				/*********************************
4001				 Option: Display & Visibility
4002				 *********************************/
4003
4004				/* Refer to Velocity's documentation (VelocityJS.org/#displayAndVisibility) for a description of the display and visibility options' behavior. */
4005				/* Note: We strictly check for undefined instead of falsiness because display accepts an empty string value. */
4006				if (opts.display !== undefined && opts.display !== null) {
4007					opts.display = opts.display.toString().toLowerCase();
4008
4009					/* Users can pass in a special "auto" value to instruct Velocity to set the element to its default display value. */
4010					if (opts.display === "auto") {
4011						opts.display = Velocity.CSS.Values.getDisplayType(element);
4012					}
4013				}
4014
4015				if (opts.visibility !== undefined && opts.visibility !== null) {
4016					opts.visibility = opts.visibility.toString().toLowerCase();
4017				}
4018
4019				/**********************
4020				 Option: mobileHA
4021				 **********************/
4022
4023				/* When set to true, and if this is a mobile device, mobileHA automatically enables hardware acceleration (via a null transform hack)
4024				 on animating elements. HA is removed from the element at the completion of its animation. */
4025				/* Note: Android Gingerbread doesn't support HA. If a null transform hack (mobileHA) is in fact set, it will prevent other tranform subproperties from taking effect. */
4026				/* Note: You can read more about the use of mobileHA in Velocity's documentation: VelocityJS.org/#mobileHA. */
4027				opts.mobileHA = (opts.mobileHA && Velocity.State.isMobile && !Velocity.State.isGingerbread);
4028
4029				/***********************
4030				 Part II: Queueing
4031				 ***********************/
4032
4033				/* When a set of elements is targeted by a Velocity call, the set is broken up and each element has the current Velocity call individually queued onto it.
4034				 In this way, each element's existing queue is respected; some elements may already be animating and accordingly should not have this current Velocity call triggered immediately. */
4035				/* In each queue, tween data is processed for each animating property then pushed onto the call-wide calls array. When the last element in the set has had its tweens processed,
4036				 the call array is pushed to Velocity.State.calls for live processing by the requestAnimationFrame tick. */
4037				function buildQueue(next) {
4038					var data, lastTweensContainer;
4039
4040					/*******************
4041					 Option: Begin
4042					 *******************/
4043
4044					/* The begin callback is fired once per call -- not once per elemenet -- and is passed the full raw DOM element set as both its context and its first argument. */
4045					if (opts.begin && elementsIndex === 0) {
4046						/* We throw callbacks in a setTimeout so that thrown errors don't halt the execution of Velocity itself. */
4047						try {
4048							opts.begin.call(elements, elements);
4049						} catch (error) {
4050							setTimeout(function() {
4051								throw error;
4052							}, 1);
4053						}
4054					}
4055
4056					/*****************************************
4057					 Tween Data Construction (for Scroll)
4058					 *****************************************/
4059
4060					/* Note: In order to be subjected to chaining and animation options, scroll's tweening is routed through Velocity as if it were a standard CSS property animation. */
4061					if (action === "scroll") {
4062						/* The scroll action uniquely takes an optional "offset" option -- specified in pixels -- that offsets the targeted scroll position. */
4063						var scrollDirection = (/^x$/i.test(opts.axis) ? "Left" : "Top"),
4064								scrollOffset = parseFloat(opts.offset) || 0,
4065								scrollPositionCurrent,
4066								scrollPositionCurrentAlternate,
4067								scrollPositionEnd;
4068
4069						/* Scroll also uniquely takes an optional "container" option, which indicates the parent element that should be scrolled --
4070						 as opposed to the browser window itself. This is useful for scrolling toward an element that's inside an overflowing parent element. */
4071						if (opts.container) {
4072							/* Ensure that either a jQuery object or a raw DOM element was passed in. */
4073							if (Type.isWrapped(opts.container) || Type.isNode(opts.container)) {
4074								/* Extract the raw DOM element from the jQuery wrapper. */
4075								opts.container = opts.container[0] || opts.container;
4076								/* Note: Unlike other properties in Velocity, the browser's scroll position is never cached since it so frequently changes
4077								 (due to the user's natural interaction with the page). */
4078								scrollPositionCurrent = opts.container["scroll" + scrollDirection]; /* GET */
4079
4080								/* $.position() values are relative to the container's currently viewable area (without taking into account the container's true dimensions
4081								 -- say, for example, if the container was not overflowing). Thus, the scroll end value is the sum of the child element's position *and*
4082								 the scroll container's current scroll position. */
4083								scrollPositionEnd = (scrollPositionCurrent + $(element).position()[scrollDirection.toLowerCase()]) + scrollOffset; /* GET */
4084								/* If a value other than a jQuery object or a raw DOM element was passed in, default to null so that this option is ignored. */
4085							} else {
4086								opts.container = null;
4087							}
4088						} else {
4089							/* If the window itself is being scrolled -- not a containing element -- perform a live scroll position lookup using
4090							 the appropriate cached property names (which differ based on browser type). */
4091							scrollPositionCurrent = Velocity.State.scrollAnchor[Velocity.State["scrollProperty" + scrollDirection]]; /* GET */
4092							/* When scrolling the browser window, cache the alternate axis's current value since window.scrollTo() doesn't let us change only one value at a time. */
4093							scrollPositionCurrentAlternate = Velocity.State.scrollAnchor[Velocity.State["scrollProperty" + (scrollDirection === "Left" ? "Top" : "Left")]]; /* GET */
4094
4095							/* Unlike $.position(), $.offset() values are relative to the browser window's true dimensions -- not merely its currently viewable area --
4096							 and therefore end values do not need to be compounded onto current values. */
4097							scrollPositionEnd = $(element).offset()[scrollDirection.toLowerCase()] + scrollOffset; /* GET */
4098						}
4099
4100						/* Since there's only one format that scroll's associated tweensContainer can take, we create it manually. */
4101						tweensContainer = {
4102							scroll: {
4103								rootPropertyValue: false,
4104								startValue: scrollPositionCurrent,
4105								currentValue: scrollPositionCurrent,
4106								endValue: scrollPositionEnd,
4107								unitType: "",
4108								easing: opts.easing,
4109								scrollData: {
4110									container: opts.container,
4111									direction: scrollDirection,
4112									alternateValue: scrollPositionCurrentAlternate
4113								}
4114							},
4115							element: element
4116						};
4117
4118						if (Velocity.debug) {
4119							console.log("tweensContainer (scroll): ", tweensContainer.scroll, element);
4120						}
4121
4122						/******************************************
4123						 Tween Data Construction (for Reverse)
4124						 ******************************************/
4125
4126						/* Reverse acts like a "start" action in that a property map is animated toward. The only difference is
4127						 that the property map used for reverse is the inverse of the map used in the previous call. Thus, we manipulate
4128						 the previous call to construct our new map: use the previous map's end values as our new map's start values. Copy over all other data. */
4129						/* Note: Reverse can be directly called via the "reverse" parameter, or it can be indirectly triggered via the loop option. (Loops are composed of multiple reverses.) */
4130						/* Note: Reverse calls do not need to be consecutively chained onto a currently-animating element in order to operate on cached values;
4131						 there is no harm to reverse being called on a potentially stale data cache since reverse's behavior is simply defined
4132						 as reverting to the element's values as they were prior to the previous *Velocity* call. */
4133					} else if (action === "reverse") {
4134						data = Data(element);
4135
4136						/* Abort if there is no prior animation data to reverse to. */
4137						if (!data) {
4138							return;
4139						}
4140
4141						if (!data.tweensContainer) {
4142							/* Dequeue the element so that this queue entry releases itself immediately, allowing subsequent queue entries to run. */
4143							$.dequeue(element, opts.queue);
4144
4145							return;
4146						} else {
4147							/*********************
4148							 Options Parsing
4149							 *********************/
4150
4151							/* If the element was hidden via the display option in the previous call,
4152							 revert display to "auto" prior to reversal so that the element is visible again. */
4153							if (data.opts.display === "none") {
4154								data.opts.display = "auto";
4155							}
4156
4157							if (data.opts.visibility === "hidden") {
4158								data.opts.visibility = "visible";
4159							}
4160
4161							/* If the loop option was set in the previous call, disable it so that "reverse" calls aren't recursively generated.
4162							 Further, remove the previous call's callback options; typically, users do not want these to be refired. */
4163							data.opts.loop = false;
4164							data.opts.begin = null;
4165							data.opts.complete = null;
4166
4167							/* Since we're extending an opts object that has already been extended with the defaults options object,
4168							 we remove non-explicitly-defined properties that are auto-assigned values. */
4169							if (!options.easing) {
4170								delete opts.easing;
4171							}
4172
4173							if (!options.duration) {
4174								delete opts.duration;
4175							}
4176
4177							/* The opts object used for reversal is an extension of the options object optionally passed into this
4178							 reverse call plus the options used in the previous Velocity call. */
4179							opts = $.extend({}, data.opts, opts);
4180
4181							/*************************************
4182							 Tweens Container Reconstruction
4183							 *************************************/
4184
4185							/* Create a deepy copy (indicated via the true flag) of the previous call's tweensContainer. */
4186							lastTweensContainer = $.extend(true, {}, data ? data.tweensContainer : null);
4187
4188							/* Manipulate the previous tweensContainer by replacing its end values and currentValues with its start values. */
4189							for (var lastTween in lastTweensContainer) {
4190								/* In addition to tween data, tweensContainers contain an element property that we ignore here. */
4191								if (lastTweensContainer.hasOwnProperty(lastTween) && lastTween !== "element") {
4192									var lastStartValue = lastTweensContainer[lastTween].startValue;
4193
4194									lastTweensContainer[lastTween].startValue = lastTweensContainer[lastTween].currentValue = lastTweensContainer[lastTween].endValue;
4195									lastTweensContainer[lastTween].endValue = lastStartValue;
4196
4197									/* Easing is the only option that embeds into the individual tween data (since it can be defined on a per-property basis).
4198									 Accordingly, every property's easing value must be updated when an options object is passed in with a reverse call.
4199									 The side effect of this extensibility is that all per-property easing values are forcefully reset to the new value. */
4200									if (!Type.isEmptyObject(options)) {
4201										lastTweensContainer[lastTween].easing = opts.easing;
4202									}
4203
4204									if (Velocity.debug) {
4205										console.log("reverse tweensContainer (" + lastTween + "): " + JSON.stringify(lastTweensContainer[lastTween]), element);
4206									}
4207								}
4208							}
4209
4210							tweensContainer = lastTweensContainer;
4211						}
4212
4213						/*****************************************
4214						 Tween Data Construction (for Start)
4215						 *****************************************/
4216
4217					} else if (action === "start") {
4218
4219						/*************************
4220						 Value Transferring
4221						 *************************/
4222
4223						/* If this queue entry follows a previous Velocity-initiated queue entry *and* if this entry was created
4224						 while the element was in the process of being animated by Velocity, then this current call is safe to use
4225						 the end values from the prior call as its start values. Velocity attempts to perform this value transfer
4226						 process whenever possible in order to avoid requerying the DOM. */
4227						/* If values aren't transferred from a prior call and start values were not forcefed by the user (more on this below),
4228						 then the DOM is queried for the element's current values as a last resort. */
4229						/* Note: Conversely, animation reversal (and looping) *always* perform inter-call value transfers; they never requery the DOM. */
4230
4231						data = Data(element);
4232
4233						/* The per-element isAnimating flag is used to indicate whether it's safe (i.e. the data isn't stale)
4234						 to transfer over end values to use as start values. If it's set to true and there is a previous
4235						 Velocity call to pull values from, do so. */
4236						if (data && data.tweensContainer && data.isAnimating === true) {
4237							lastTweensContainer = data.tweensContainer;
4238						}
4239
4240						/***************************
4241						 Tween Data Calculation
4242						 ***************************/
4243
4244						/* This function parses property data and defaults endValue, easing, and startValue as appropriate. */
4245						/* Property map values can either take the form of 1) a single value representing the end value,
4246						 or 2) an array in the form of [ endValue, [, easing] [, startValue] ].
4247						 The optional third parameter is a forcefed startValue to be used instead of querying the DOM for
4248						 the element's current value. Read Velocity's docmentation to learn more about forcefeeding: VelocityJS.org/#forcefeeding */
4249						var parsePropertyValue = function(valueData, skipResolvingEasing) {
4250							var endValue, easing, startValue;
4251
4252							/* If we have a function as the main argument then resolve it first, in case it returns an array that needs to be split */
4253							if (Type.isFunction(valueData)) {
4254								valueData = valueData.call(element, elementArrayIndex, elementsLength);
4255							}
4256
4257							/* Handle the array format, which can be structured as one of three potential overloads:
4258							 A) [ endValue, easing, startValue ], B) [ endValue, easing ], or C) [ endValue, startValue ] */
4259							if (Type.isArray(valueData)) {
4260								/* endValue is always the first item in the array. Don't bother validating endValue's value now
4261								 since the ensuing property cycling logic does that. */
4262								endValue = valueData[0];
4263
4264								/* Two-item array format: If the second item is a number, function, or hex string, treat it as a
4265								 start value since easings can only be non-hex strings or arrays. */
4266								if ((!Type.isArray(valueData[1]) && /^[\d-]/.test(valueData[1])) || Type.isFunction(valueData[1]) || CSS.RegEx.isHex.test(valueData[1])) {
4267									startValue = valueData[1];
4268									/* Two or three-item array: If the second item is a non-hex string easing name or an array, treat it as an easing. */
4269								} else if ((Type.isString(valueData[1]) && !CSS.RegEx.isHex.test(valueData[1]) && Velocity.Easings[valueData[1]]) || Type.isArray(valueData[1])) {
4270									easing = skipResolvingEasing ? valueData[1] : getEasing(valueData[1], opts.duration);
4271
4272									/* Don't bother validating startValue's value now since the ensuing property cycling logic inherently does that. */
4273									startValue = valueData[2];
4274								} else {
4275									startValue = valueData[1] || valueData[2];
4276								}
4277								/* Handle the single-value format. */
4278							} else {
4279								endValue = valueData;
4280							}
4281
4282							/* Default to the call's easing if a per-property easing type was not defined. */
4283							if (!skipResolvingEasing) {
4284								easing = easing || opts.easing;
4285							}
4286
4287							/* If functions were passed in as values, pass the function the current element as its context,
4288							 plus the element's index and the element set's size as arguments. Then, assign the returned value. */
4289							if (Type.isFunction(endValue)) {
4290								endValue = endValue.call(element, elementArrayIndex, elementsLength);
4291							}
4292
4293							if (Type.isFunction(startValue)) {
4294								startValue = startValue.call(element, elementArrayIndex, elementsLength);
4295							}
4296
4297							/* Allow startValue to be left as undefined to indicate to the ensuing code that its value was not forcefed. */
4298							return [endValue || 0, easing, startValue];
4299						};
4300
4301						var fixPropertyValue = function(property, valueData) {
4302							/* In case this property is a hook, there are circumstances where we will intend to work on the hook's root property and not the hooked subproperty. */
4303							var rootProperty = CSS.Hooks.getRoot(property),
4304									rootPropertyValue = false,
4305									/* Parse out endValue, easing, and startValue from the property's data. */
4306									endValue = valueData[0],
4307									easing = valueData[1],
4308									startValue = valueData[2],
4309									pattern;
4310
4311							/**************************
4312							 Start Value Sourcing
4313							 **************************/
4314
4315							/* Other than for the dummy tween property, properties that are not supported by the browser (and do not have an associated normalization) will
4316							 inherently produce no style changes when set, so they are skipped in order to decrease animation tick overhead.
4317							 Property support is determined via prefixCheck(), which returns a false flag when no supported is detected. */
4318							/* Note: Since SVG elements have some of their properties directly applied as HTML attributes,
4319							 there is no way to check for their explicit browser support, and so we skip skip this check for them. */
4320							if ((!data || !data.isSVG) && rootProperty !== "tween" && CSS.Names.prefixCheck(rootProperty)[1] === false && CSS.Normalizations.registered[rootProperty] === undefined) {
4321								if (Velocity.debug) {
4322									console.log("Skipping [" + rootProperty + "] due to a lack of browser support.");
4323								}
4324								return;
4325							}
4326
4327							/* If the display option is being set to a non-"none" (e.g. "block") and opacity (filter on IE<=8) is being
4328							 animated to an endValue of non-zero, the user's intention is to fade in from invisible, thus we forcefeed opacity
4329							 a startValue of 0 if its startValue hasn't already been sourced by value transferring or prior forcefeeding. */
4330							if (((opts.display !== undefined && opts.display !== null && opts.display !== "none") || (opts.visibility !== undefined && opts.visibility !== "hidden")) && /opacity|filter/.test(property) && !startValue && endValue !== 0) {
4331								startValue = 0;
4332							}
4333
4334							/* If values have been transferred from the previous Velocity call, extract the endValue and rootPropertyValue
4335							 for all of the current call's properties that were *also* animated in the previous call. */
4336							/* Note: Value transferring can optionally be disabled by the user via the _cacheValues option. */
4337							if (opts._cacheValues && lastTweensContainer && lastTweensContainer[property]) {
4338								if (startValue === undefined) {
4339									startValue = lastTweensContainer[property].endValue + lastTweensContainer[property].unitType;
4340								}
4341
4342								/* The previous call's rootPropertyValue is extracted from the element's data cache since that's the
4343								 instance of rootPropertyValue that gets freshly updated by the tweening process, whereas the rootPropertyValue
4344								 attached to the incoming lastTweensContainer is equal to the root property's value prior to any tweening. */
4345								rootPropertyValue = data.rootPropertyValueCache[rootProperty];
4346								/* If values were not transferred from a previous Velocity call, query the DOM as needed. */
4347							} else {
4348								/* Handle hooked properties. */
4349								if (CSS.Hooks.registered[property]) {
4350									if (startValue === undefined) {
4351										rootPropertyValue = CSS.getPropertyValue(element, rootProperty); /* GET */
4352										/* Note: The following getPropertyValue() call does not actually trigger a DOM query;
4353										 getPropertyValue() will extract the hook from rootPropertyValue. */
4354										startValue = CSS.getPropertyValue(element, property, rootPropertyValue);
4355										/* If startValue is already defined via forcefeeding, do not query the DOM for the root property's value;
4356										 just grab rootProperty's zero-value template from CSS.Hooks. This overwrites the element's actual
4357										 root property value (if one is set), but this is acceptable since the primary reason users forcefeed is
4358										 to avoid DOM queries, and thus we likewise avoid querying the DOM for the root property's value. */
4359									} else {
4360										/* Grab this hook's zero-value template, e.g. "0px 0px 0px black". */
4361										rootPropertyValue = CSS.Hooks.templates[rootProperty][1];
4362									}
4363									/* Handle non-hooked properties that haven't already been defined via forcefeeding. */
4364								} else if (startValue === undefined) {
4365									startValue = CSS.getPropertyValue(element, property); /* GET */
4366								}
4367							}
4368
4369							/**************************
4370							 Value Data Extraction
4371							 **************************/
4372
4373							var separatedValue,
4374									endValueUnitType,
4375									startValueUnitType,
4376									operator = false;
4377
4378							/* Separates a property value into its numeric value and its unit type. */
4379							var separateValue = function(property, value) {
4380								var unitType,
4381										numericValue;
4382
4383								numericValue = (value || "0")
4384										.toString()
4385										.toLowerCase()
4386										/* Match the unit type at the end of the value. */
4387										.replace(/[%A-z]+$/, function(match) {
4388											/* Grab the unit type. */
4389											unitType = match;
4390
4391											/* Strip the unit type off of value. */
4392											return "";
4393										});
4394
4395								/* If no unit type was supplied, assign one that is appropriate for this property (e.g. "deg" for rotateZ or "px" for width). */
4396								if (!unitType) {
4397									unitType = CSS.Values.getUnitType(property);
4398								}
4399
4400								return [numericValue, unitType];
4401							};
4402
4403							if (startValue !== endValue && Type.isString(startValue) && Type.isString(endValue)) {
4404								pattern = "";
4405								var iStart = 0, // index in startValue
4406										iEnd = 0, // index in endValue
4407										aStart = [], // array of startValue numbers
4408										aEnd = [], // array of endValue numbers
4409										inCalc = 0, // Keep track of being inside a "calc()" so we don't duplicate it
4410										inRGB = 0, // Keep track of being inside an RGB as we can't use fractional values
4411										inRGBA = 0; // Keep track of being inside an RGBA as we must pass fractional for the alpha channel
4412
4413								startValue = CSS.Hooks.fixColors(startValue);
4414								endValue = CSS.Hooks.fixColors(endValue);
4415								while (iStart < startValue.length && iEnd < endValue.length) {
4416									var cStart = startValue[iStart],
4417											cEnd = endValue[iEnd];
4418
4419									if (/[\d\.-]/.test(cStart) && /[\d\.-]/.test(cEnd)) {
4420										var tStart = cStart, // temporary character buffer
4421												tEnd = cEnd, // temporary character buffer
4422												dotStart = ".", // Make sure we can only ever match a single dot in a decimal
4423												dotEnd = "."; // Make sure we can only ever match a single dot in a decimal
4424
4425										while (++iStart < startValue.length) {
4426											cStart = startValue[iStart];
4427											if (cStart === dotStart) {
4428												dotStart = ".."; // Can never match two characters
4429											} else if (!/\d/.test(cStart)) {
4430												break;
4431											}
4432											tStart += cStart;
4433										}
4434										while (++iEnd < endValue.length) {
4435											cEnd = endValue[iEnd];
4436											if (cEnd === dotEnd) {
4437												dotEnd = ".."; // Can never match two characters
4438											} else if (!/\d/.test(cEnd)) {
4439												break;
4440											}
4441											tEnd += cEnd;
4442										}
4443										var uStart = CSS.Hooks.getUnit(startValue, iStart), // temporary unit type
4444												uEnd = CSS.Hooks.getUnit(endValue, iEnd); // temporary unit type
4445
4446										iStart += uStart.length;
4447										iEnd += uEnd.length;
4448										if (uStart === uEnd) {
4449											// Same units
4450											if (tStart === tEnd) {
4451												// Same numbers, so just copy over
4452												pattern += tStart + uStart;
4453											} else {
4454												// Different numbers, so store them
4455												pattern += "{" + aStart.length + (inRGB ? "!" : "") + "}" + uStart;
4456												aStart.push(parseFloat(tStart));
4457												aEnd.push(parseFloat(tEnd));
4458											}
4459										} else {
4460											// Different units, so put into a "calc(from + to)" and animate each side to/from zero
4461											var nStart = parseFloat(tStart),
4462													nEnd = parseFloat(tEnd);
4463
4464											pattern += (inCalc < 5 ? "calc" : "") + "("
4465													+ (nStart ? "{" + aStart.length + (inRGB ? "!" : "") + "}" : "0") + uStart
4466													+ " + "
4467													+ (nEnd ? "{" + (aStart.length + (nStart ? 1 : 0)) + (inRGB ? "!" : "") + "}" : "0") + uEnd
4468													+ ")";
4469											if (nStart) {
4470												aStart.push(nStart);
4471												aEnd.push(0);
4472											}
4473											if (nEnd) {
4474												aStart.push(0);
4475												aEnd.push(nEnd);
4476											}
4477										}
4478									} else if (cStart === cEnd) {
4479										pattern += cStart;
4480										iStart++;
4481										iEnd++;
4482										// Keep track of being inside a calc()
4483										if (inCalc === 0 && cStart === "c"
4484												|| inCalc === 1 && cStart === "a"
4485												|| inCalc === 2 && cStart === "l"
4486												|| inCalc === 3 && cStart === "c"
4487												|| inCalc >= 4 && cStart === "("
4488												) {
4489											inCalc++;
4490										} else if ((inCalc && inCalc < 5)
4491												|| inCalc >= 4 && cStart === ")" && --inCalc < 5) {
4492											inCalc = 0;
4493										}
4494										// Keep track of being inside an rgb() / rgba()
4495										if (inRGB === 0 && cStart === "r"
4496												|| inRGB === 1 && cStart === "g"
4497												|| inRGB === 2 && cStart === "b"
4498												|| inRGB === 3 && cStart === "a"
4499												|| inRGB >= 3 && cStart === "("
4500												) {
4501											if (inRGB === 3 && cStart === "a") {
4502												inRGBA = 1;
4503											}
4504											inRGB++;
4505										} else if (inRGBA && cStart === ",") {
4506											if (++inRGBA > 3) {
4507												inRGB = inRGBA = 0;
4508											}
4509										} else if ((inRGBA && inRGB < (inRGBA ? 5 : 4))
4510												|| inRGB >= (inRGBA ? 4 : 3) && cStart === ")" && --inRGB < (inRGBA ? 5 : 4)) {
4511											inRGB = inRGBA = 0;
4512										}
4513									} else {
4514										inCalc = 0;
4515										// TODO: changing units, fixing colours
4516										break;
4517									}
4518								}
4519								if (iStart !== startValue.length || iEnd !== endValue.length) {
4520									if (Velocity.debug) {
4521										console.error("Trying to pattern match mis-matched strings [\"" + endValue + "\", \"" + startValue + "\"]");
4522									}
4523									pattern = undefined;
4524								}
4525								if (pattern) {
4526									if (aStart.length) {
4527										if (Velocity.debug) {
4528											console.log("Pattern found \"" + pattern + "\" -> ", aStart, aEnd, "[" + startValue + "," + endValue + "]");
4529										}
4530										startValue = aStart;
4531										endValue = aEnd;
4532										endValueUnitType = startValueUnitType = "";
4533									} else {
4534										pattern = undefined;
4535									}
4536								}
4537							}
4538
4539							if (!pattern) {
4540								/* Separate startValue. */
4541								separatedValue = separateValue(property, startValue);
4542								startValue = separatedValue[0];
4543								startValueUnitType = separatedValue[1];
4544
4545								/* Separate endValue, and extract a value operator (e.g. "+=", "-=") if one exists. */
4546								separatedValue = separateValue(property, endValue);
4547								endValue = separatedValue[0].replace(/^([+-\/*])=/, function(match, subMatch) {
4548									operator = subMatch;
4549
4550									/* Strip the operator off of the value. */
4551									return "";
4552								});
4553								endValueUnitType = separatedValue[1];
4554
4555								/* Parse float values from endValue and startValue. Default to 0 if NaN is returned. */
4556								startValue = parseFloat(startValue) || 0;
4557								endValue = parseFloat(endValue) || 0;
4558
4559								/***************************************
4560								 Property-Specific Value Conversion
4561								 ***************************************/
4562
4563								/* Custom support for properties that don't actually accept the % unit type, but where pollyfilling is trivial and relatively foolproof. */
4564								if (endValueUnitType === "%") {
4565									/* A %-value fontSize/lineHeight is relative to the parent's fontSize (as opposed to the parent's dimensions),
4566									 which is identical to the em unit's behavior, so we piggyback off of that. */
4567									if (/^(fontSize|lineHeight)$/.test(property)) {
4568										/* Convert % into an em decimal value. */
4569										endValue = endValue / 100;
4570										endValueUnitType = "em";
4571										/* For scaleX and scaleY, convert the value into its decimal format and strip off the unit type. */
4572									} else if (/^scale/.test(property)) {
4573										endValue = endValue / 100;
4574										endValueUnitType = "";
4575										/* For RGB components, take the defined percentage of 255 and strip off the unit type. */
4576									} else if (/(Red|Green|Blue)$/i.test(property)) {
4577										endValue = (endValue / 100) * 255;
4578										endValueUnitType = "";
4579									}
4580								}
4581							}
4582
4583							/***************************
4584							 Unit Ratio Calculation
4585							 ***************************/
4586
4587							/* When queried, the browser returns (most) CSS property values in pixels. Therefore, if an endValue with a unit type of
4588							 %, em, or rem is animated toward, startValue must be converted from pixels into the same unit type as endValue in order
4589							 for value manipulation logic (increment/decrement) to proceed. Further, if the startValue was forcefed or transferred
4590							 from a previous call, startValue may also not be in pixels. Unit conversion logic therefore consists of two steps:
4591							 1) Calculating the ratio of %/em/rem/vh/vw relative to pixels
4592							 2) Converting startValue into the same unit of measurement as endValue based on these ratios. */
4593							/* Unit conversion ratios are calculated by inserting a sibling node next to the target node, copying over its position property,
4594							 setting values with the target unit type then comparing the returned pixel value. */
4595							/* Note: Even if only one of these unit types is being animated, all unit ratios are calculated at once since the overhead
4596							 of batching the SETs and GETs together upfront outweights the potential overhead
4597							 of layout thrashing caused by re-querying for uncalculated ratios for subsequently-processed properties. */
4598							/* Todo: Shift this logic into the calls' first tick instance so that it's synced with RAF. */
4599							var calculateUnitRatios = function() {
4600
4601								/************************
4602								 Same Ratio Checks
4603								 ************************/
4604
4605								/* The properties below are used to determine whether the element differs sufficiently from this call's
4606								 previously iterated element to also differ in its unit conversion ratios. If the properties match up with those
4607								 of the prior element, the prior element's conversion ratios are used. Like most optimizations in Velocity,
4608								 this is done to minimize DOM querying. */
4609								var sameRatioIndicators = {
4610									myParent: element.parentNode || document.body, /* GET */
4611									position: CSS.getPropertyValue(element, "position"), /* GET */
4612									fontSize: CSS.getPropertyValue(element, "fontSize") /* GET */
4613								},
4614										/* Determine if the same % ratio can be used. % is based on the element's position value and its parent's width and height dimensions. */
4615										samePercentRatio = ((sameRatioIndicators.position === callUnitConversionData.lastPosition) && (sameRatioIndicators.myParent === callUnitConversionData.lastParent)),
4616										/* Determine if the same em ratio can be used. em is relative to the element's fontSize. */
4617										sameEmRatio = (sameRatioIndicators.fontSize === callUnitConversionData.lastFontSize);
4618
4619								/* Store these ratio indicators call-wide for the next element to compare against. */
4620								callUnitConversionData.lastParent = sameRatioIndicators.myParent;
4621								callUnitConversionData.lastPosition = sameRatioIndicators.position;
4622								callUnitConversionData.lastFontSize = sameRatioIndicators.fontSize;
4623
4624								/***************************
4625								 Element-Specific Units
4626								 ***************************/
4627
4628								/* Note: IE8 rounds to the nearest pixel when returning CSS values, thus we perform conversions using a measurement
4629								 of 100 (instead of 1) to give our ratios a precision of at least 2 decimal values. */
4630								var measurement = 100,
4631										unitRatios = {};
4632
4633								if (!sameEmRatio || !samePercentRatio) {
4634									var dummy = data && data.isSVG ? document.createElementNS("http://www.w3.org/2000/svg", "rect") : document.createElement("div");
4635
4636									Velocity.init(dummy);
4637									sameRatioIndicators.myParent.appendChild(dummy);
4638
4639									/* To accurately and consistently calculate conversion ratios, the element's cascaded overflow and box-sizing are stripped.
4640									 Similarly, since width/height can be artificially constrained by their min-/max- equivalents, these are controlled for as well. */
4641									/* Note: Overflow must be also be controlled for per-axis since the overflow property overwrites its per-axis values. */
4642									$.each(["overflow", "overflowX", "overflowY"], function(i, property) {
4643										Velocity.CSS.setPropertyValue(dummy, property, "hidden");
4644									});
4645									Velocity.CSS.setPropertyValue(dummy, "position", sameRatioIndicators.position);
4646									Velocity.CSS.setPropertyValue(dummy, "fontSize", sameRatioIndicators.fontSize);
4647									Velocity.CSS.setPropertyValue(dummy, "boxSizing", "content-box");
4648
4649									/* width and height act as our proxy properties for measuring the horizontal and vertical % ratios. */
4650									$.each(["minWidth", "maxWidth", "width", "minHeight", "maxHeight", "height"], function(i, property) {
4651										Velocity.CSS.setPropertyValue(dummy, property, measurement + "%");
4652									});
4653									/* paddingLeft arbitrarily acts as our proxy property for the em ratio. */
4654									Velocity.CSS.setPropertyValue(dummy, "paddingLeft", measurement + "em");
4655
4656									/* Divide the returned value by the measurement to get the ratio between 1% and 1px. Default to 1 since working with 0 can produce Infinite. */
4657									unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth = (parseFloat(CSS.getPropertyValue(dummy, "width", null, true)) || 1) / measurement; /* GET */
4658									unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight = (parseFloat(CSS.getPropertyValue(dummy, "height", null, true)) || 1) / measurement; /* GET */
4659									unitRatios.emToPx = callUnitConversionData.lastEmToPx = (parseFloat(CSS.getPropertyValue(dummy, "paddingLeft")) || 1) / measurement; /* GET */
4660
4661									sameRatioIndicators.myParent.removeChild(dummy);
4662								} else {
4663									unitRatios.emToPx = callUnitConversionData.lastEmToPx;
4664									unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth;
4665									unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight;
4666								}
4667
4668								/***************************
4669								 Element-Agnostic Units
4670								 ***************************/
4671
4672								/* Whereas % and em ratios are determined on a per-element basis, the rem unit only needs to be checked
4673								 once per call since it's exclusively dependant upon document.body's fontSize. If this is the first time
4674								 that calculateUnitRatios() is being run during this call, remToPx will still be set to its default value of null,
4675								 so we calculate it now. */
4676								if (callUnitConversionData.remToPx === null) {
4677									/* Default to browsers' default fontSize of 16px in the case of 0. */
4678									callUnitConversionData.remToPx = parseFloat(CSS.getPropertyValue(document.body, "fontSize")) || 16; /* GET */
4679								}
4680
4681								/* Similarly, viewport units are %-relative to the window's inner dimensions. */
4682								if (callUnitConversionData.vwToPx === null) {
4683									callUnitConversionData.vwToPx = parseFloat(window.innerWidth) / 100; /* GET */
4684									callUnitConversionData.vhToPx = parseFloat(window.innerHeight) / 100; /* GET */
4685								}
4686
4687								unitRatios.remToPx = callUnitConversionData.remToPx;
4688								unitRatios.vwToPx = callUnitConversionData.vwToPx;
4689								unitRatios.vhToPx = callUnitConversionData.vhToPx;
4690
4691								if (Velocity.debug >= 1) {
4692									console.log("Unit ratios: " + JSON.stringify(unitRatios), element);
4693								}
4694								return unitRatios;
4695							};
4696
4697							/********************
4698							 Unit Conversion
4699							 ********************/
4700
4701							/* The * and / operators, which are not passed in with an associated unit, inherently use startValue's unit. Skip value and unit conversion. */
4702							if (/[\/*]/.test(operator)) {
4703								endValueUnitType = startValueUnitType;
4704								/* If startValue and endValue differ in unit type, convert startValue into the same unit type as endValue so that if endValueUnitType
4705								 is a relative unit (%, em, rem), the values set during tweening will continue to be accurately relative even if the metrics they depend
4706								 on are dynamically changing during the course of the animation. Conversely, if we always normalized into px and used px for setting values, the px ratio
4707								 would become stale if the original unit being animated toward was relative and the underlying metrics change during the animation. */
4708								/* Since 0 is 0 in any unit type, no conversion is necessary when startValue is 0 -- we just start at 0 with endValueUnitType. */
4709							} else if ((startValueUnitType !== endValueUnitType) && startValue !== 0) {
4710								/* Unit conversion is also skipped when endValue is 0, but *startValueUnitType* must be used for tween values to remain accurate. */
4711								/* Note: Skipping unit conversion here means that if endValueUnitType was originally a relative unit, the animation won't relatively
4712								 match the underlying metrics if they change, but this is acceptable since we're animating toward invisibility instead of toward visibility,
4713								 which remains past the point of the animation's completion. */
4714								if (endValue === 0) {
4715									endValueUnitType = startValueUnitType;
4716								} else {
4717									/* By this point, we cannot avoid unit conversion (it's undesirable since it causes layout thrashing).
4718									 If we haven't already, we trigger calculateUnitRatios(), which runs once per element per call. */
4719									elementUnitConversionData = elementUnitConversionData || calculateUnitRatios();
4720
4721									/* The following RegEx matches CSS properties that have their % values measured relative to the x-axis. */
4722									/* Note: W3C spec mandates that all of margin and padding's properties (even top and bottom) are %-relative to the *width* of the parent element. */
4723									var axis = (/margin|padding|left|right|width|text|word|letter/i.test(property) || /X$/.test(property) || property === "x") ? "x" : "y";
4724
4725									/* In order to avoid generating n^2 bespoke conversion functions, unit conversion is a two-step process:
4726									 1) Convert startValue into pixels. 2) Convert this new pixel value into endValue's unit type. */
4727									switch (startValueUnitType) {
4728										case "%":
4729											/* Note: translateX and translateY are the only properties that are %-relative to an element's own dimensions -- not its parent's dimensions.
4730											 Velocity does not include a special conversion process to account for this behavior. Therefore, animating translateX/Y from a % value
4731											 to a non-% value will produce an incorrect start value. Fortunately, this sort of cross-unit conversion is rarely done by users in practice. */
4732											startValue *= (axis === "x" ? elementUnitConversionData.percentToPxWidth : elementUnitConversionData.percentToPxHeight);
4733											break;
4734
4735										case "px":
4736											/* px acts as our midpoint in the unit conversion process; do nothing. */
4737											break;
4738
4739										default:
4740											startValue *= elementUnitConversionData[startValueUnitType + "ToPx"];
4741									}
4742
4743									/* Invert the px ratios to convert into to the target unit. */
4744									switch (endValueUnitType) {
4745										case "%":
4746											startValue *= 1 / (axis === "x" ? elementUnitConversionData.percentToPxWidth : elementUnitConversionData.percentToPxHeight);
4747											break;
4748
4749										case "px":
4750											/* startValue is already in px, do nothing; we're done. */
4751											break;
4752
4753										default:
4754											startValue *= 1 / elementUnitConversionData[endValueUnitType + "ToPx"];
4755									}
4756								}
4757							}
4758
4759							/*********************
4760							 Relative Values
4761							 *********************/
4762
4763							/* Operator logic must be performed last since it requires unit-normalized start and end values. */
4764							/* Note: Relative *percent values* do not behave how most people think; while one would expect "+=50%"
4765							 to increase the property 1.5x its current value, it in fact increases the percent units in absolute terms:
4766							 50 points is added on top of the current % value. */
4767							switch (operator) {
4768								case "+":
4769									endValue = startValue + endValue;
4770									break;
4771
4772								case "-":
4773									endValue = startValue - endValue;
4774									break;
4775
4776								case "*":
4777									endValue = startValue * endValue;
4778									break;
4779
4780								case "/":
4781									endValue = startValue / endValue;
4782									break;
4783							}
4784
4785							/**************************
4786							 tweensContainer Push
4787							 **************************/
4788
4789							/* Construct the per-property tween object, and push it to the element's tweensContainer. */
4790							tweensContainer[property] = {
4791								rootPropertyValue: rootPropertyValue,
4792								startValue: startValue,
4793								currentValue: startValue,
4794								endValue: endValue,
4795								unitType: endValueUnitType,
4796								easing: easing
4797							};
4798							if (pattern) {
4799								tweensContainer[property].pattern = pattern;
4800							}
4801
4802							if (Velocity.debug) {
4803								console.log("tweensContainer (" + property + "): " + JSON.stringify(tweensContainer[property]), element);
4804							}
4805						};
4806
4807						/* Create a tween out of each property, and append its associated data to tweensContainer. */
4808						for (var property in propertiesMap) {
4809
4810							if (!propertiesMap.hasOwnProperty(property)) {
4811								continue;
4812							}
4813							/* The original property name's format must be used for the parsePropertyValue() lookup,
4814							 but we then use its camelCase styling to normalize it for manipulation. */
4815							var propertyName = CSS.Names.camelCase(property),
4816									valueData = parsePropertyValue(propertiesMap[property]);
4817
4818							/* Find shorthand color properties that have been passed a hex string. */
4819							/* Would be quicker to use CSS.Lists.colors.includes() if possible */
4820							if (_inArray(CSS.Lists.colors, propertyName)) {
4821								/* Parse the value data for each shorthand. */
4822								var endValue = valueData[0],
4823										easing = valueData[1],
4824										startValue = valueData[2];
4825
4826								if (CSS.RegEx.isHex.test(endValue)) {
4827									/* Convert the hex strings into their RGB component arrays. */
4828									var colorComponents = ["Red", "Green", "Blue"],
4829											endValueRGB = CSS.Values.hexToRgb(endValue),
4830											startValueRGB = startValue ? CSS.Values.hexToRgb(startValue) : undefined;
4831
4832									/* Inject the RGB component tweens into propertiesMap. */
4833									for (var i = 0; i < colorComponents.length; i++) {
4834										var dataArray = [endValueRGB[i]];
4835
4836										if (easing) {
4837											dataArray.push(easing);
4838										}
4839
4840										if (startValueRGB !== undefined) {
4841											dataArray.push(startValueRGB[i]);
4842										}
4843
4844										fixPropertyValue(propertyName + colorComponents[i], dataArray);
4845									}
4846									/* If we have replaced a shortcut color value then don't update the standard property name */
4847									continue;
4848								}
4849							}
4850							fixPropertyValue(propertyName, valueData);
4851						}
4852
4853						/* Along with its property data, store a reference to the element itself onto tweensContainer. */
4854						tweensContainer.element = element;
4855					}
4856
4857					/*****************
4858					 Call Push
4859					 *****************/
4860
4861					/* Note: tweensContainer can be empty if all of the properties in this call's property map were skipped due to not
4862					 being supported by the browser. The element property is used for checking that the tweensContainer has been appended to. */
4863					if (tweensContainer.element) {
4864						/* Apply the "velocity-animating" indicator class. */
4865						CSS.Values.addClass(element, "velocity-animating");
4866
4867						/* The call array houses the tweensContainers for each element being animated in the current call. */
4868						call.push(tweensContainer);
4869
4870						data = Data(element);
4871
4872						if (data) {
4873							/* Store the tweensContainer and options if we're working on the default effects queue, so that they can be used by the reverse command. */
4874							if (opts.queue === "") {
4875
4876								data.tweensContainer = tweensContainer;
4877								data.opts = opts;
4878							}
4879
4880							/* Switch on the element's animating flag. */
4881							data.isAnimating = true;
4882						}
4883
4884						/* Once the final element in this call's element set has been processed, push the call array onto
4885						 Velocity.State.calls for the animation tick to immediately begin processing. */
4886						if (elementsIndex === elementsLength - 1) {
4887							/* Add the current call plus its associated metadata (the element set and the call's options) onto the global call container.
4888							 Anything on this call container is subjected to tick() processing. */
4889							Velocity.State.calls.push([call, elements, opts, null, promiseData.resolver, null, 0]);
4890
4891							/* If the animation tick isn't running, start it. (Velocity shuts it off when there are no active calls to process.) */
4892							if (Velocity.State.isTicking === false) {
4893								Velocity.State.isTicking = true;
4894
4895								/* Start the tick loop. */
4896								tick();
4897							}
4898						} else {
4899							elementsIndex++;
4900						}
4901					}
4902				}
4903
4904				/* When the queue option is set to false, the call skips the element's queue and fires immediately. */
4905				if (opts.queue === false) {
4906					/* Since this buildQueue call doesn't respect the element's existing queue (which is where a delay option would have been appended),
4907					 we manually inject the delay property here with an explicit setTimeout. */
4908					if (opts.delay) {
4909
4910						/* Temporarily store delayed elements to facilitate access for global pause/resume */
4911						var callIndex = Velocity.State.delayedElements.count++;
4912						Velocity.State.delayedElements[callIndex] = element;
4913
4914						var delayComplete = (function(index) {
4915							return function() {
4916								/* Clear the temporary element */
4917								Velocity.State.delayedElements[index] = false;
4918
4919								/* Finally, issue the call */
4920								buildQueue();
4921							};
4922						})(callIndex);
4923
4924						Data(element).delayBegin = (new Date()).getTime();
4925						Data(element).delay = parseFloat(opts.delay);
4926						Data(element).delayTimer = {
4927							setTimeout: setTimeout(buildQueue, parseFloat(opts.delay)),
4928							next: delayComplete
4929						};
4930					} else {
4931						buildQueue();
4932					}
4933					/* Otherwise, the call undergoes element queueing as normal. */
4934					/* Note: To interoperate with jQuery, Velocity uses jQuery's own $.queue() stack for queuing logic. */
4935				} else {
4936					$.queue(element, opts.queue, function(next, clearQueue) {
4937						/* If the clearQueue flag was passed in by the stop command, resolve this call's promise. (Promises can only be resolved once,
4938						 so it's fine if this is repeatedly triggered for each element in the associated call.) */
4939						if (clearQueue === true) {
4940							if (promiseData.promise) {
4941								promiseData.resolver(elements);
4942							}
4943
4944							/* Do not continue with animation queueing. */
4945							return true;
4946						}
4947
4948						/* This flag indicates to the upcoming completeCall() function that this queue entry was initiated by Velocity.
4949						 See completeCall() for further details. */
4950						Velocity.velocityQueueEntryFlag = true;
4951
4952						buildQueue(next);
4953					});
4954				}
4955
4956				/*********************
4957				 Auto-Dequeuing
4958				 *********************/
4959
4960				/* As per jQuery's $.queue() behavior, to fire the first non-custom-queue entry on an element, the element
4961				 must be dequeued if its queue stack consists *solely* of the current call. (This can be determined by checking
4962				 for the "inprogress" item that jQuery prepends to active queue stack arrays.) Regardless, whenever the element's
4963				 queue is further appended with additional items -- including $.delay()'s or even $.animate() calls, the queue's
4964				 first entry is automatically fired. This behavior contrasts that of custom queues, which never auto-fire. */
4965				/* Note: When an element set is being subjected to a non-parallel Velocity call, the animation will not begin until
4966				 each one of the elements in the set has reached the end of its individually pre-existing queue chain. */
4967				/* Note: Unfortunately, most people don't fully grasp jQuery's powerful, yet quirky, $.queue() function.
4968				 Lean more here: http://stackoverflow.com/questions/1058158/can-somebody-explain-jquery-queue-to-me */
4969				if ((opts.queue === "" || opts.queue === "fx") && $.queue(element)[0] !== "inprogress") {
4970					$.dequeue(element);
4971				}
4972			}
4973
4974			/**************************
4975			 Element Set Iteration
4976			 **************************/
4977
4978			/* If the "nodeType" property exists on the elements variable, we're animating a single element.
4979			 Place it in an array so that $.each() can iterate over it. */
4980			$.each(elements, function(i, element) {
4981				/* Ensure each element in a set has a nodeType (is a real element) to avoid throwing errors. */
4982				if (Type.isNode(element)) {
4983					processElement(element, i);
4984				}
4985			});
4986
4987			/******************
4988			 Option: Loop
4989			 ******************/
4990
4991			/* The loop option accepts an integer indicating how many times the element should loop between the values in the
4992			 current call's properties map and the element's property values prior to this call. */
4993			/* Note: The loop option's logic is performed here -- after element processing -- because the current call needs
4994			 to undergo its queue insertion prior to the loop option generating its series of constituent "reverse" calls,
4995			 which chain after the current call. Two reverse calls (two "alternations") constitute one loop. */
4996			opts = $.extend({}, Velocity.defaults, options);
4997			opts.loop = parseInt(opts.loop, 10);
4998			var reverseCallsCount = (opts.loop * 2) - 1;
4999
5000			if (opts.loop) {
5001				/* Double the loop count to convert it into its appropriate number of "reverse" calls.
5002				 Subtract 1 from the resulting value since the current call is included in the total alternation count. */
5003				for (var x = 0; x < reverseCallsCount; x++) {
5004					/* Since the logic for the reverse action occurs inside Queueing and therefore this call's options object
5005					 isn't parsed until then as well, the current call's delay option must be explicitly passed into the reverse
5006					 call so that the delay logic that occurs inside *Pre-Queueing* can process it. */
5007					var reverseOptions = {
5008						delay: opts.delay,
5009						progress: opts.progress
5010					};
5011
5012					/* If a complete callback was passed into this call, transfer it to the loop redirect's final "reverse" call
5013					 so that it's triggered when the entire redirect is complete (and not when the very first animation is complete). */
5014					if (x === reverseCallsCount - 1) {
5015						reverseOptions.display = opts.display;
5016						reverseOptions.visibility = opts.visibility;
5017						reverseOptions.complete = opts.complete;
5018					}
5019
5020					animate(elements, "reverse", reverseOptions);
5021				}
5022			}
5023
5024			/***************
5025			 Chaining
5026			 ***************/
5027
5028			/* Return the elements back to the call chain, with wrapped elements taking precedence in case Velocity was called via the $.fn. extension. */
5029			return getChain();
5030		};
5031
5032		/* Turn Velocity into the animation function, extended with the pre-existing Velocity object. */
5033		Velocity = $.extend(animate, Velocity);
5034		/* For legacy support, also expose the literal animate method. */
5035		Velocity.animate = animate;
5036
5037		/**************
5038		 Timing
5039		 **************/
5040
5041		/* Ticker function. */
5042		var ticker = window.requestAnimationFrame || rAFShim;
5043
5044		/* Inactive browser tabs pause rAF, which results in all active animations immediately sprinting to their completion states when the tab refocuses.
5045		 To get around this, we dynamically switch rAF to setTimeout (which the browser *doesn't* pause) when the tab loses focus. We skip this for mobile
5046		 devices to avoid wasting battery power on inactive tabs. */
5047		/* Note: Tab focus detection doesn't work on older versions of IE, but that's okay since they don't support rAF to begin with. */
5048		if (!Velocity.State.isMobile && document.hidden !== undefined) {
5049			var updateTicker = function() {
5050				/* Reassign the rAF function (which the global tick() function uses) based on the tab's focus state. */
5051				if (document.hidden) {
5052					ticker = function(callback) {
5053						/* The tick function needs a truthy first argument in order to pass its internal timestamp check. */
5054						return setTimeout(function() {
5055							callback(true);
5056						}, 16);
5057					};
5058
5059					/* The rAF loop has been paused by the browser, so we manually restart the tick. */
5060					tick();
5061				} else {
5062					ticker = window.requestAnimationFrame || rAFShim;
5063				}
5064			};
5065
5066			/* Page could be sitting in the background at this time (i.e. opened as new tab) so making sure we use correct ticker from the start */
5067			updateTicker();
5068
5069			/* And then run check again every time visibility changes */
5070			document.addEventListener("visibilitychange", updateTicker);
5071		}
5072
5073		/************
5074		 Tick
5075		 ************/
5076
5077		/* Note: All calls to Velocity are pushed to the Velocity.State.calls array, which is fully iterated through upon each tick. */
5078		function tick(timestamp) {
5079			/* An empty timestamp argument indicates that this is the first tick occurence since ticking was turned on.
5080			 We leverage this metadata to fully ignore the first tick pass since RAF's initial pass is fired whenever
5081			 the browser's next tick sync time occurs, which results in the first elements subjected to Velocity
5082			 calls being animated out of sync with any elements animated immediately thereafter. In short, we ignore
5083			 the first RAF tick pass so that elements being immediately consecutively animated -- instead of simultaneously animated
5084			 by the same Velocity call -- are properly batched into the same initial RAF tick and consequently remain in sync thereafter. */
5085			if (timestamp) {
5086				/* We normally use RAF's high resolution timestamp but as it can be significantly offset when the browser is
5087				 under high stress we give the option for choppiness over allowing the browser to drop huge chunks of frames.
5088				 We use performance.now() and shim it if it doesn't exist for when the tab is hidden. */
5089				var timeCurrent = Velocity.timestamp && timestamp !== true ? timestamp : performance.now();
5090
5091				/********************
5092				 Call Iteration
5093				 ********************/
5094
5095				var callsLength = Velocity.State.calls.length;
5096
5097				/* To speed up iterating over this array, it is compacted (falsey items -- calls that have completed -- are removed)
5098				 when its length has ballooned to a point that can impact tick performance. This only becomes necessary when animation
5099				 has been continuous with many elements over a long period of time; whenever all active calls are completed, completeCall() clears Velocity.State.calls. */
5100				if (callsLength > 10000) {
5101					Velocity.State.calls = compactSparseArray(Velocity.State.calls);
5102					callsLength = Velocity.State.calls.length;
5103				}
5104
5105				/* Iterate through each active call. */
5106				for (var i = 0; i < callsLength; i++) {
5107					/* When a Velocity call is completed, its Velocity.State.calls entry is set to false. Continue on to the next call. */
5108					if (!Velocity.State.calls[i]) {
5109						continue;
5110					}
5111
5112					/************************
5113					 Call-Wide Variables
5114					 ************************/
5115
5116					var callContainer = Velocity.State.calls[i],
5117							call = callContainer[0],
5118							opts = callContainer[2],
5119							timeStart = callContainer[3],
5120							firstTick = !timeStart,
5121							tweenDummyValue = null,
5122							pauseObject = callContainer[5],
5123							millisecondsEllapsed = callContainer[6];
5124
5125
5126
5127					/* If timeStart is undefined, then this is the first time that this call has been processed by tick().
5128					 We assign timeStart now so that its value is as close to the real animation start time as possible.
5129					 (Conversely, had timeStart been defined when this call was added to Velocity.State.calls, the delay
5130					 between that time and now would cause the first few frames of the tween to be skipped since
5131					 percentComplete is calculated relative to timeStart.) */
5132					/* Further, subtract 16ms (the approximate resolution of RAF) from the current time value so that the
5133					 first tick iteration isn't wasted by animating at 0% tween completion, which would produce the
5134					 same style value as the element's current value. */
5135					if (!timeStart) {
5136						timeStart = Velocity.State.calls[i][3] = timeCurrent - 16;
5137					}
5138
5139					/* If a pause object is present, skip processing unless it has been set to resume */
5140					if (pauseObject) {
5141						if (pauseObject.resume === true) {
5142							/* Update the time start to accomodate the paused completion amount */
5143							timeStart = callContainer[3] = Math.round(timeCurrent - millisecondsEllapsed - 16);
5144
5145							/* Remove pause object after processing */
5146							callContainer[5] = null;
5147						} else {
5148							continue;
5149						}
5150					}
5151
5152					millisecondsEllapsed = callContainer[6] = timeCurrent - timeStart;
5153
5154					/* The tween's completion percentage is relative to the tween's start time, not the tween's start value
5155					 (which would result in unpredictable tween durations since JavaScript's timers are not particularly accurate).
5156					 Accordingly, we ensure that percentComplete does not exceed 1. */
5157					var percentComplete = Math.min((millisecondsEllapsed) / opts.duration, 1);
5158
5159					/**********************
5160					 Element Iteration
5161					 **********************/
5162
5163					/* For every call, iterate through each of the elements in its set. */
5164					for (var j = 0, callLength = call.length; j < callLength; j++) {
5165						var tweensContainer = call[j],
5166								element = tweensContainer.element;
5167
5168						/* Check to see if this element has been deleted midway through the animation by checking for the
5169						 continued existence of its data cache. If it's gone, or the element is currently paused, skip animating this element. */
5170						if (!Data(element)) {
5171							continue;
5172						}
5173
5174						var transformPropertyExists = false;
5175
5176						/**********************************
5177						 Display & Visibility Toggling
5178						 **********************************/
5179
5180						/* If the display option is set to non-"none", set it upfront so that the element can become visible before tweening begins.
5181						 (Otherwise, display's "none" value is set in completeCall() once the animation has completed.) */
5182						if (opts.display !== undefined && opts.display !== null && opts.display !== "none") {
5183							if (opts.display === "flex") {
5184								var flexValues = ["-webkit-box", "-moz-box", "-ms-flexbox", "-webkit-flex"];
5185
5186								$.each(flexValues, function(i, flexValue) {
5187									CSS.setPropertyValue(element, "display", flexValue);
5188								});
5189							}
5190
5191							CSS.setPropertyValue(element, "display", opts.display);
5192						}
5193
5194						/* Same goes with the visibility option, but its "none" equivalent is "hidden". */
5195						if (opts.visibility !== undefined && opts.visibility !== "hidden") {
5196							CSS.setPropertyValue(element, "visibility", opts.visibility);
5197						}
5198
5199						/************************
5200						 Property Iteration
5201						 ************************/
5202
5203						/* For every element, iterate through each property. */
5204						for (var property in tweensContainer) {
5205							/* Note: In addition to property tween data, tweensContainer contains a reference to its associated element. */
5206							if (tweensContainer.hasOwnProperty(property) && property !== "element") {
5207								var tween = tweensContainer[property],
5208										currentValue,
5209										/* Easing can either be a pre-genereated function or a string that references a pre-registered easing
5210										 on the Velocity.Easings object. In either case, return the appropriate easing *function*. */
5211										easing = Type.isString(tween.easing) ? Velocity.Easings[tween.easing] : tween.easing;
5212
5213								/******************************
5214								 Current Value Calculation
5215								 ******************************/
5216
5217								if (Type.isString(tween.pattern)) {
5218									var patternReplace = percentComplete === 1 ?
5219											function($0, index, round) {
5220												var result = tween.endValue[index];
5221
5222												return round ? Math.round(result) : result;
5223											} :
5224											function($0, index, round) {
5225												var startValue = tween.startValue[index],
5226														tweenDelta = tween.endValue[index] - startValue,
5227														result = startValue + (tweenDelta * easing(percentComplete, opts, tweenDelta));
5228
5229												return round ? Math.round(result) : result;
5230											};
5231
5232									currentValue = tween.pattern.replace(/{(\d+)(!)?}/g, patternReplace);
5233								} else if (percentComplete === 1) {
5234									/* If this is the last tick pass (if we've reached 100% completion for this tween),
5235									 ensure that currentValue is explicitly set to its target endValue so that it's not subjected to any rounding. */
5236									currentValue = tween.endValue;
5237								} else {
5238									/* Otherwise, calculate currentValue based on the current delta from startValue. */
5239									var tweenDelta = tween.endValue - tween.startValue;
5240
5241									currentValue = tween.startValue + (tweenDelta * easing(percentComplete, opts, tweenDelta));
5242									/* If no value change is occurring, don't proceed with DOM updating. */
5243								}
5244								if (!firstTick && (currentValue === tween.currentValue)) {
5245									continue;
5246								}
5247
5248								tween.currentValue = currentValue;
5249
5250								/* If we're tweening a fake 'tween' property in order to log transition values, update the one-per-call variable so that
5251								 it can be passed into the progress callback. */
5252								if (property === "tween") {
5253									tweenDummyValue = currentValue;
5254								} else {
5255									/******************
5256									 Hooks: Part I
5257									 ******************/
5258									var hookRoot;
5259
5260									/* For hooked properties, the newly-updated rootPropertyValueCache is cached onto the element so that it can be used
5261									 for subsequent hooks in this call that are associated with the same root property. If we didn't cache the updated
5262									 rootPropertyValue, each subsequent update to the root property in this tick pass would reset the previous hook's
5263									 updates to rootPropertyValue prior to injection. A nice performance byproduct of rootPropertyValue caching is that
5264									 subsequently chained animations using the same hookRoot but a different hook can use this cached rootPropertyValue. */
5265									if (CSS.Hooks.registered[property]) {
5266										hookRoot = CSS.Hooks.getRoot(property);
5267
5268										var rootPropertyValueCache = Data(element).rootPropertyValueCache[hookRoot];
5269
5270										if (rootPropertyValueCache) {
5271											tween.rootPropertyValue = rootPropertyValueCache;
5272										}
5273									}
5274
5275									/*****************
5276									 DOM Update
5277									 *****************/
5278
5279									/* setPropertyValue() returns an array of the property name and property value post any normalization that may have been performed. */
5280									/* Note: To solve an IE<=8 positioning bug, the unit type is dropped when setting a property value of 0. */
5281									var adjustedSetData = CSS.setPropertyValue(element, /* SET */
5282											property,
5283											tween.currentValue + (IE < 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),
5284											tween.rootPropertyValue,
5285											tween.scrollData);
5286
5287									/*******************
5288									 Hooks: Part II
5289									 *******************/
5290
5291									/* Now that we have the hook's updated rootPropertyValue (the post-processed value provided by adjustedSetData), cache it onto the element. */
5292									if (CSS.Hooks.registered[property]) {
5293										/* Since adjustedSetData contains normalized data ready for DOM updating, the rootPropertyValue needs to be re-extracted from its normalized form. ?? */
5294										if (CSS.Normalizations.registered[hookRoot]) {
5295											Data(element).rootPropertyValueCache[hookRoot] = CSS.Normalizations.registered[hookRoot]("extract", null, adjustedSetData[1]);
5296										} else {
5297											Data(element).rootPropertyValueCache[hookRoot] = adjustedSetData[1];
5298										}
5299									}
5300
5301									/***************
5302									 Transforms
5303									 ***************/
5304
5305									/* Flag whether a transform property is being animated so that flushTransformCache() can be triggered once this tick pass is complete. */
5306									if (adjustedSetData[0] === "transform") {
5307										transformPropertyExists = true;
5308									}
5309
5310								}
5311							}
5312						}
5313
5314						/****************
5315						 mobileHA
5316						 ****************/
5317
5318						/* If mobileHA is enabled, set the translate3d transform to null to force hardware acceleration.
5319						 It's safe to override this property since Velocity doesn't actually support its animation (hooks are used in its place). */
5320						if (opts.mobileHA) {
5321							/* Don't set the null transform hack if we've already done so. */
5322							if (Data(element).transformCache.translate3d === undefined) {
5323								/* All entries on the transformCache object are later concatenated into a single transform string via flushTransformCache(). */
5324								Data(element).transformCache.translate3d = "(0px, 0px, 0px)";
5325
5326								transformPropertyExists = true;
5327							}
5328						}
5329
5330						if (transformPropertyExists) {
5331							CSS.flushTransformCache(element);
5332						}
5333					}
5334
5335					/* The non-"none" display value is only applied to an element once -- when its associated call is first ticked through.
5336					 Accordingly, it's set to false so that it isn't re-processed by this call in the next tick. */
5337					if (opts.display !== undefined && opts.display !== "none") {
5338						Velocity.State.calls[i][2].display = false;
5339					}
5340					if (opts.visibility !== undefined && opts.visibility !== "hidden") {
5341						Velocity.State.calls[i][2].visibility = false;
5342					}
5343
5344					/* Pass the elements and the timing data (percentComplete, msRemaining, timeStart, tweenDummyValue) into the progress callback. */
5345					if (opts.progress) {
5346						opts.progress.call(callContainer[1],
5347								callContainer[1],
5348								percentComplete,
5349								Math.max(0, (timeStart + opts.duration) - timeCurrent),
5350								timeStart,
5351								tweenDummyValue);
5352					}
5353
5354					/* If this call has finished tweening, pass its index to completeCall() to handle call cleanup. */
5355					if (percentComplete === 1) {
5356						completeCall(i);
5357					}
5358				}
5359			}
5360
5361			/* Note: completeCall() sets the isTicking flag to false when the last call on Velocity.State.calls has completed. */
5362			if (Velocity.State.isTicking) {
5363				ticker(tick);
5364			}
5365		}
5366
5367		/**********************
5368		 Call Completion
5369		 **********************/
5370
5371		/* Note: Unlike tick(), which processes all active calls at once, call completion is handled on a per-call basis. */
5372		function completeCall(callIndex, isStopped) {
5373			/* Ensure the call exists. */
5374			if (!Velocity.State.calls[callIndex]) {
5375				return false;
5376			}
5377
5378			/* Pull the metadata from the call. */
5379			var call = Velocity.State.calls[callIndex][0],
5380					elements = Velocity.State.calls[callIndex][1],
5381					opts = Velocity.State.calls[callIndex][2],
5382					resolver = Velocity.State.calls[callIndex][4];
5383
5384			var remainingCallsExist = false;
5385
5386			/*************************
5387			 Element Finalization
5388			 *************************/
5389
5390			for (var i = 0, callLength = call.length; i < callLength; i++) {
5391				var element = call[i].element;
5392
5393				/* If the user set display to "none" (intending to hide the element), set it now that the animation has completed. */
5394				/* Note: display:none isn't set when calls are manually stopped (via Velocity("stop"). */
5395				/* Note: Display gets ignored with "reverse" calls and infinite loops, since this behavior would be undesirable. */
5396				if (!isStopped && !opts.loop) {
5397					if (opts.display === "none") {
5398						CSS.setPropertyValue(element, "display", opts.display);
5399					}
5400
5401					if (opts.visibility === "hidden") {
5402						CSS.setPropertyValue(element, "visibility", opts.visibility);
5403					}
5404				}
5405
5406				/* If the element's queue is empty (if only the "inprogress" item is left at position 0) or if its queue is about to run
5407				 a non-Velocity-initiated entry, turn off the isAnimating flag. A non-Velocity-initiatied queue entry's logic might alter
5408				 an element's CSS values and thereby cause Velocity's cached value data to go stale. To detect if a queue entry was initiated by Velocity,
5409				 we check for the existence of our special Velocity.queueEntryFlag declaration, which minifiers won't rename since the flag
5410				 is assigned to jQuery's global $ object and thus exists out of Velocity's own scope. */
5411				var data = Data(element);
5412
5413				if (opts.loop !== true && ($.queue(element)[1] === undefined || !/\.velocityQueueEntryFlag/i.test($.queue(element)[1]))) {
5414					/* The element may have been deleted. Ensure that its data cache still exists before acting on it. */
5415					if (data) {
5416						data.isAnimating = false;
5417						/* Clear the element's rootPropertyValueCache, which will become stale. */
5418						data.rootPropertyValueCache = {};
5419
5420						var transformHAPropertyExists = false;
5421						/* If any 3D transform subproperty is at its default value (regardless of unit type), remove it. */
5422						$.each(CSS.Lists.transforms3D, function(i, transformName) {
5423							var defaultValue = /^scale/.test(transformName) ? 1 : 0,
5424									currentValue = data.transformCache[transformName];
5425
5426							if (data.transformCache[transformName] !== undefined && new RegExp("^\\(" + defaultValue + "[^.]").test(currentValue)) {
5427								transformHAPropertyExists = true;
5428
5429								delete data.transformCache[transformName];
5430							}
5431						});
5432
5433						/* Mobile devices have hardware acceleration removed at the end of the animation in order to avoid hogging the GPU's memory. */
5434						if (opts.mobileHA) {
5435							transformHAPropertyExists = true;
5436							delete data.transformCache.translate3d;
5437						}
5438
5439						/* Flush the subproperty removals to the DOM. */
5440						if (transformHAPropertyExists) {
5441							CSS.flushTransformCache(element);
5442						}
5443
5444						/* Remove the "velocity-animating" indicator class. */
5445						CSS.Values.removeClass(element, "velocity-animating");
5446					}
5447				}
5448
5449				/*********************
5450				 Option: Complete
5451				 *********************/
5452
5453				/* Complete is fired once per call (not once per element) and is passed the full raw DOM element set as both its context and its first argument. */
5454				/* Note: Callbacks aren't fired when calls are manually stopped (via Velocity("stop"). */
5455				if (!isStopped && opts.complete && !opts.loop && (i === callLength - 1)) {
5456					/* We throw callbacks in a setTimeout so that thrown errors don't halt the execution of Velocity itself. */
5457					try {
5458						opts.complete.call(elements, elements);
5459					} catch (error) {
5460						setTimeout(function() {
5461							throw error;
5462						}, 1);
5463					}
5464				}
5465
5466				/**********************
5467				 Promise Resolving
5468				 **********************/
5469
5470				/* Note: Infinite loops don't return promises. */
5471				if (resolver && opts.loop !== true) {
5472					resolver(elements);
5473				}
5474
5475				/****************************
5476				 Option: Loop (Infinite)
5477				 ****************************/
5478
5479				if (data && opts.loop === true && !isStopped) {
5480					/* If a rotateX/Y/Z property is being animated by 360 deg with loop:true, swap tween start/end values to enable
5481					 continuous iterative rotation looping. (Otherise, the element would just rotate back and forth.) */
5482					$.each(data.tweensContainer, function(propertyName, tweenContainer) {
5483						if (/^rotate/.test(propertyName) && ((parseFloat(tweenContainer.startValue) - parseFloat(tweenContainer.endValue)) % 360 === 0)) {
5484							var oldStartValue = tweenContainer.startValue;
5485
5486							tweenContainer.startValue = tweenContainer.endValue;
5487							tweenContainer.endValue = oldStartValue;
5488						}
5489
5490						if (/^backgroundPosition/.test(propertyName) && parseFloat(tweenContainer.endValue) === 100 && tweenContainer.unitType === "%") {
5491							tweenContainer.endValue = 0;
5492							tweenContainer.startValue = 100;
5493						}
5494					});
5495
5496					Velocity(element, "reverse", {loop: true, delay: opts.delay});
5497				}
5498
5499				/***************
5500				 Dequeueing
5501				 ***************/
5502
5503				/* Fire the next call in the queue so long as this call's queue wasn't set to false (to trigger a parallel animation),
5504				 which would have already caused the next call to fire. Note: Even if the end of the animation queue has been reached,
5505				 $.dequeue() must still be called in order to completely clear jQuery's animation queue. */
5506				if (opts.queue !== false) {
5507					$.dequeue(element, opts.queue);
5508				}
5509			}
5510
5511			/************************
5512			 Calls Array Cleanup
5513			 ************************/
5514
5515			/* Since this call is complete, set it to false so that the rAF tick skips it. This array is later compacted via compactSparseArray().
5516			 (For performance reasons, the call is set to false instead of being deleted from the array: http://www.html5rocks.com/en/tutorials/speed/v8/) */
5517			Velocity.State.calls[callIndex] = false;
5518
5519			/* Iterate through the calls array to determine if this was the final in-progress animation.
5520			 If so, set a flag to end ticking and clear the calls array. */
5521			for (var j = 0, callsLength = Velocity.State.calls.length; j < callsLength; j++) {
5522				if (Velocity.State.calls[j] !== false) {
5523					remainingCallsExist = true;
5524
5525					break;
5526				}
5527			}
5528
5529			if (remainingCallsExist === false) {
5530				/* tick() will detect this flag upon its next iteration and subsequently turn itself off. */
5531				Velocity.State.isTicking = false;
5532
5533				/* Clear the calls array so that its length is reset. */
5534				delete Velocity.State.calls;
5535				Velocity.State.calls = [];
5536			}
5537		}
5538
5539		/******************
5540		 Frameworks
5541		 ******************/
5542
5543		/* Both jQuery and Zepto allow their $.fn object to be extended to allow wrapped elements to be subjected to plugin calls.
5544		 If either framework is loaded, register a "velocity" extension pointing to Velocity's core animate() method.  Velocity
5545		 also registers itself onto a global container (window.jQuery || window.Zepto || window) so that certain features are
5546		 accessible beyond just a per-element scope. This master object contains an .animate() method, which is later assigned to $.fn
5547		 (if jQuery or Zepto are present). Accordingly, Velocity can both act on wrapped DOM elements and stand alone for targeting raw DOM elements. */
5548		global.Velocity = Velocity;
5549
5550		if (global !== window) {
5551			/* Assign the element function to Velocity's core animate() method. */
5552			global.fn.velocity = animate;
5553			/* Assign the object function's defaults to Velocity's global defaults object. */
5554			global.fn.velocity.defaults = Velocity.defaults;
5555		}
5556
5557		/***********************
5558		 Packaged Redirects
5559		 ***********************/
5560
5561		/* slideUp, slideDown */
5562		$.each(["Down", "Up"], function(i, direction) {
5563			Velocity.Redirects["slide" + direction] = function(element, options, elementsIndex, elementsSize, elements, promiseData) {
5564				var opts = $.extend({}, options),
5565						begin = opts.begin,
5566						complete = opts.complete,
5567						inlineValues = {},
5568						computedValues = {height: "", marginTop: "", marginBottom: "", paddingTop: "", paddingBottom: ""};
5569
5570				if (opts.display === undefined) {
5571					/* Show the element before slideDown begins and hide the element after slideUp completes. */
5572					/* Note: Inline elements cannot have dimensions animated, so they're reverted to inline-block. */
5573					opts.display = (direction === "Down" ? (Velocity.CSS.Values.getDisplayType(element) === "inline" ? "inline-block" : "block") : "none");
5574				}
5575
5576				opts.begin = function() {
5577					/* If the user passed in a begin callback, fire it now. */
5578					if (elementsIndex === 0 && begin) {
5579						begin.call(elements, elements);
5580					}
5581
5582					/* Cache the elements' original vertical dimensional property values so that we can animate back to them. */
5583					for (var property in computedValues) {
5584						if (!computedValues.hasOwnProperty(property)) {
5585							continue;
5586						}
5587						inlineValues[property] = element.style[property];
5588
5589						/* For slideDown, use forcefeeding to animate all vertical properties from 0. For slideUp,
5590						 use forcefeeding to start from computed values and animate down to 0. */
5591						var propertyValue = CSS.getPropertyValue(element, property);
5592						computedValues[property] = (direction === "Down") ? [propertyValue, 0] : [0, propertyValue];
5593					}
5594
5595					/* Force vertical overflow content to clip so that sliding works as expected. */
5596					inlineValues.overflow = element.style.overflow;
5597					element.style.overflow = "hidden";
5598				};
5599
5600				opts.complete = function() {
5601					/* Reset element to its pre-slide inline values once its slide animation is complete. */
5602					for (var property in inlineValues) {
5603						if (inlineValues.hasOwnProperty(property)) {
5604							element.style[property] = inlineValues[property];
5605						}
5606					}
5607
5608					/* If the user passed in a complete callback, fire it now. */
5609					if (elementsIndex === elementsSize - 1) {
5610						if (complete) {
5611							complete.call(elements, elements);
5612						}
5613						if (promiseData) {
5614							promiseData.resolver(elements);
5615						}
5616					}
5617				};
5618
5619				Velocity(element, computedValues, opts);
5620			};
5621		});
5622
5623		/* fadeIn, fadeOut */
5624		$.each(["In", "Out"], function(i, direction) {
5625			Velocity.Redirects["fade" + direction] = function(element, options, elementsIndex, elementsSize, elements, promiseData) {
5626				var opts = $.extend({}, options),
5627						complete = opts.complete,
5628						propertiesMap = {opacity: (direction === "In") ? 1 : 0};
5629
5630				/* Since redirects are triggered individually for each element in the animated set, avoid repeatedly triggering
5631				 callbacks by firing them only when the final element has been reached. */
5632				if (elementsIndex !== 0) {
5633					opts.begin = null;
5634				}
5635				if (elementsIndex !== elementsSize - 1) {
5636					opts.complete = null;
5637				} else {
5638					opts.complete = function() {
5639						if (complete) {
5640							complete.call(elements, elements);
5641						}
5642						if (promiseData) {
5643							promiseData.resolver(elements);
5644						}
5645					};
5646				}
5647
5648				/* If a display was passed in, use it. Otherwise, default to "none" for fadeOut or the element-specific default for fadeIn. */
5649				/* Note: We allow users to pass in "null" to skip display setting altogether. */
5650				if (opts.display === undefined) {
5651					opts.display = (direction === "In" ? "auto" : "none");
5652				}
5653
5654				Velocity(this, propertiesMap, opts);
5655			};
5656		});
5657
5658		return Velocity;
5659	}((window.jQuery || window.Zepto || window), window, (window ? window.document : undefined));
5660}));
5661
5662/******************
5663 Known Issues
5664 ******************/
5665
5666/* The CSS spec mandates that the translateX/Y/Z transforms are %-relative to the element itself -- not its parent.
5667 Velocity, however, doesn't make this distinction. Thus, converting to or from the % unit with these subproperties
5668 will produce an inaccurate conversion value. The same issue exists with the cx/cy attributes of SVG circles and ellipses. */
5669
5670
5671/***/ }),
5672