Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

scratch – Blame information for rev 77

Rev	Author	Line No.	Line
77	office	1	/*! VelocityJS.org (1.4.3). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License */
		2
		3	/*************************
		4	Velocity jQuery Shim
		5	*************************/
		6
		7	/*! VelocityJS.org jQuery Shim (1.0.1). (C) 2014 The jQuery Foundation. MIT @license: en.wikipedia.org/wiki/MIT_License. */
		8
		9	/* 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. */
		10	/* These shimmed functions are only used if jQuery isn't present. If both this shim and jQuery are loaded, Velocity defaults to jQuery proper. */
		11	/* Browser support: Using this shim instead of jQuery proper removes support for IE8. */
		12
		13	(function(window) {
		14	"use strict";
		15	/***************
		16	Setup
		17	***************/
		18
		19	/* If jQuery is already loaded, there's no point in loading this shim. */
		20	if (window.jQuery) {
		21	return;
		22	}
		23
		24	/* jQuery base. */
		25	var $ = function(selector, context) {
		26	return new $.fn.init(selector, context);
		27	};
		28
		29	/********************
		30	Private Methods
		31	********************/
		32
		33	/* jQuery */
		34	$.isWindow = function(obj) {
		35	/* jshint eqeqeq: false */
		36	return obj && obj === obj.window;
		37	};
		38
		39	/* jQuery */
		40	$.type = function(obj) {
		41	if (!obj) {
		42	return obj + "";
		43	}
		44
		45	return typeof obj === "object" || typeof obj === "function" ?
		46	class2type[toString.call(obj)] || "object" :
		47	typeof obj;
		48	};
		49
		50	/* jQuery */
		51	$.isArray = Array.isArray || function(obj) {
		52	return $.type(obj) === "array";
		53	};
		54
		55	/* jQuery */
		56	function isArraylike(obj) {
		57	var length = obj.length,
		58	type = $.type(obj);
		59
		60	if (type === "function" || $.isWindow(obj)) {
		61	return false;
		62	}
		63
		64	if (obj.nodeType === 1 && length) {
		65	return true;
		66	}
		67
		68	return type === "array" || length === 0 || typeof length === "number" && length > 0 && (length - 1) in obj;
		69	}
		70
		71	/***************
		72	$ Methods
		73	***************/
		74
		75	/* jQuery: Support removed for IE<9. */
		76	$.isPlainObject = function(obj) {
		77	var key;
		78
		79	if (!obj || $.type(obj) !== "object" || obj.nodeType || $.isWindow(obj)) {
		80	return false;
		81	}
		82
		83	try {
		84	if (obj.constructor &&
		85	!hasOwn.call(obj, "constructor") &&
		86	!hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
		87	return false;
		88	}
		89	} catch (e) {
		90	return false;
		91	}
		92
		93	for (key in obj) {
		94	}
		95
		96	return key === undefined || hasOwn.call(obj, key);
		97	};
		98
		99	/* jQuery */
		100	$.each = function(obj, callback, args) {
		101	var value,
		102	i = 0,
		103	length = obj.length,
		104	isArray = isArraylike(obj);
		105
		106	if (args) {
		107	if (isArray) {
		108	for (; i < length; i++) {
		109	value = callback.apply(obj[i], args);
		110
		111	if (value === false) {
		112	break;
		113	}
		114	}
		115	} else {
		116	for (i in obj) {
		117	if (!obj.hasOwnProperty(i)) {
		118	continue;
		119	}
		120	value = callback.apply(obj[i], args);
		121
		122	if (value === false) {
		123	break;
		124	}
		125	}
		126	}
		127
		128	} else {
		129	if (isArray) {
		130	for (; i < length; i++) {
		131	value = callback.call(obj[i], i, obj[i]);
		132
		133	if (value === false) {
		134	break;
		135	}
		136	}
		137	} else {
		138	for (i in obj) {
		139	if (!obj.hasOwnProperty(i)) {
		140	continue;
		141	}
		142	value = callback.call(obj[i], i, obj[i]);
		143
		144	if (value === false) {
		145	break;
		146	}
		147	}
		148	}
		149	}
		150
		151	return obj;
		152	};
		153
		154	/* Custom */
		155	$.data = function(node, key, value) {
		156	/* $.getData() */
		157	if (value === undefined) {
		158	var getId = node[$.expando],
		159	store = getId && cache[getId];
		160
		161	if (key === undefined) {
		162	return store;
		163	} else if (store) {
		164	if (key in store) {
		165	return store[key];
		166	}
		167	}
		168	/* $.setData() */
		169	} else if (key !== undefined) {
		170	var setId = node[$.expando] || (node[$.expando] = ++$.uuid);
		171
		172	cache[setId] = cache[setId] || {};
		173	cache[setId][key] = value;
		174
		175	return value;
		176	}
		177	};
		178
		179	/* Custom */
		180	$.removeData = function(node, keys) {
		181	var id = node[$.expando],
		182	store = id && cache[id];
		183
		184	if (store) {
		185	// Cleanup the entire store if no keys are provided.
		186	if (!keys) {
		187	delete cache[id];
		188	} else {
		189	$.each(keys, function(_, key) {
		190	delete store[key];
		191	});
		192	}
		193	}
		194	};
		195
		196	/* jQuery */
		197	$.extend = function() {
		198	var src, copyIsArray, copy, name, options, clone,
		199	target = arguments[0] || {},
		200	i = 1,
		201	length = arguments.length,
		202	deep = false;
		203
		204	if (typeof target === "boolean") {
		205	deep = target;
		206
		207	target = arguments[i] || {};
		208	i++;
		209	}
		210
		211	if (typeof target !== "object" && $.type(target) !== "function") {
		212	target = {};
		213	}
		214
		215	if (i === length) {
		216	target = this;
		217	i--;
		218	}
		219
		220	for (; i < length; i++) {
		221	if ((options = arguments[i])) {
		222	for (name in options) {
		223	if (!options.hasOwnProperty(name)) {
		224	continue;
		225	}
		226	src = target[name];
		227	copy = options[name];
		228
		229	if (target === copy) {
		230	continue;
		231	}
		232
		233	if (deep && copy && ($.isPlainObject(copy) || (copyIsArray = $.isArray(copy)))) {
		234	if (copyIsArray) {
		235	copyIsArray = false;
		236	clone = src && $.isArray(src) ? src : [];
		237
		238	} else {
		239	clone = src && $.isPlainObject(src) ? src : {};
		240	}
		241
		242	target[name] = $.extend(deep, clone, copy);
		243
		244	} else if (copy !== undefined) {
		245	target[name] = copy;
		246	}
		247	}
		248	}
		249	}
		250
		251	return target;
		252	};
		253
		254	/* jQuery 1.4.3 */
		255	$.queue = function(elem, type, data) {
		256	function $makeArray(arr, results) {
		257	var ret = results || [];
		258
		259	if (arr) {
		260	if (isArraylike(Object(arr))) {
		261	/* $.merge */
		262	(function(first, second) {
		263	var len = +second.length,
		264	j = 0,
		265	i = first.length;
		266
		267	while (j < len) {
		268	first[i++] = second[j++];
		269	}
		270
		271	if (len !== len) {
		272	while (second[j] !== undefined) {
		273	first[i++] = second[j++];
		274	}
		275	}
		276
		277	first.length = i;
		278
		279	return first;
		280	})(ret, typeof arr === "string" ? [arr] : arr);
		281	} else {
		282	[].push.call(ret, arr);
		283	}
		284	}
		285
		286	return ret;
		287	}
		288
		289	if (!elem) {
		290	return;
		291	}
		292
		293	type = (type || "fx") + "queue";
		294
		295	var q = $.data(elem, type);
		296
		297	if (!data) {
		298	return q || [];
		299	}
		300
		301	if (!q || $.isArray(data)) {
		302	q = $.data(elem, type, $makeArray(data));
		303	} else {
		304	q.push(data);
		305	}
		306
		307	return q;
		308	};
		309
		310	/* jQuery 1.4.3 */
		311	$.dequeue = function(elems, type) {
		312	/* Custom: Embed element iteration. */
		313	$.each(elems.nodeType ? [elems] : elems, function(i, elem) {
		314	type = type || "fx";
		315
		316	var queue = $.queue(elem, type),
		317	fn = queue.shift();
		318
		319	if (fn === "inprogress") {
		320	fn = queue.shift();
		321	}
		322
		323	if (fn) {
		324	if (type === "fx") {
		325	queue.unshift("inprogress");
		326	}
		327
		328	fn.call(elem, function() {
		329	$.dequeue(elem, type);
		330	});
		331	}
		332	});
		333	};
		334
		335	/******************
		336	$.fn Methods
		337	******************/
		338
		339	/* jQuery */
		340	$.fn = $.prototype = {
		341	init: function(selector) {
		342	/* Just return the element wrapped inside an array; don't proceed with the actual jQuery node wrapping process. */
		343	if (selector.nodeType) {
		344	this[0] = selector;
		345
		346	return this;
		347	} else {
		348	throw new Error("Not a DOM node.");
		349	}
		350	},
		351	offset: function() {
		352	/* jQuery altered code: Dropped disconnected DOM node checking. */
		353	var box = this[0].getBoundingClientRect ? this[0].getBoundingClientRect() : {top: 0, left: 0};
		354
		355	return {
		356	top: box.top + (window.pageYOffset || document.scrollTop || 0) - (document.clientTop || 0),
		357	left: box.left + (window.pageXOffset || document.scrollLeft || 0) - (document.clientLeft || 0)
		358	};
		359	},
		360	position: function() {
		361	/* jQuery */
		362	function offsetParentFn(elem) {
		363	var offsetParent = elem.offsetParent;
		364
		365	while (offsetParent && offsetParent.nodeName.toLowerCase() !== "html" && offsetParent.style && offsetParent.style.position === "static") {
		366	offsetParent = offsetParent.offsetParent;
		367	}
		368
		369	return offsetParent || document;
		370	}
		371
		372	/* Zepto */
		373	var elem = this[0],
		374	offsetParent = offsetParentFn(elem),
		375	offset = this.offset(),
		376	parentOffset = /^(?:body|html)$/i.test(offsetParent.nodeName) ? {top: 0, left: 0} : $(offsetParent).offset();
		377
		378	offset.top -= parseFloat(elem.style.marginTop) || 0;
		379	offset.left -= parseFloat(elem.style.marginLeft) || 0;
		380
		381	if (offsetParent.style) {
		382	parentOffset.top += parseFloat(offsetParent.style.borderTopWidth) || 0;
		383	parentOffset.left += parseFloat(offsetParent.style.borderLeftWidth) || 0;
		384	}
		385
		386	return {
		387	top: offset.top - parentOffset.top,
		388	left: offset.left - parentOffset.left
		389	};
		390	}
		391	};
		392
		393	/**********************
		394	Private Variables
		395	**********************/
		396
		397	/* For $.data() */
		398	var cache = {};
		399	$.expando = "velocity" + (new Date().getTime());
		400	$.uuid = 0;
		401
		402	/* For $.queue() */
		403	var class2type = {},
		404	hasOwn = class2type.hasOwnProperty,
		405	toString = class2type.toString;
		406
		407	var types = "Boolean Number String Function Array Date RegExp Object Error".split(" ");
		408	for (var i = 0; i < types.length; i++) {
		409	class2type["[object " + types[i] + "]"] = types[i].toLowerCase();
		410	}
		411
		412	/* Makes $(node) possible, without having to call init. */
		413	$.fn.init.prototype = $.fn;
		414
		415	/* Globalize Velocity onto the window, and assign its Utilities property. */
		416	window.Velocity = {Utilities: $};
		417	})(window);
		418
		419	/******************
		420	Velocity.js
		421	******************/
		422
		423	(function(factory) {
		424	"use strict";
		425	/* CommonJS module. */
		426	if (typeof module === "object" && typeof module.exports === "object") {
		427	module.exports = factory();
		428	/* AMD module. */
		429	} else if (typeof define === "function" && define.amd) {
		430	define(factory);
		431	/* Browser globals. */
		432	} else {
		433	factory();
		434	}
		435	}(function() {
		436	"use strict";
		437	return function(global, window, document, undefined) {
		438
		439	/***************
		440	Summary
		441	***************/
		442
		443	/*
		444	- CSS: CSS stack that works independently from the rest of Velocity.
		445	- animate(): Core animation method that iterates over the targeted elements and queues the incoming call onto each element individually.
		446	- Pre-Queueing: Prepare the element for animation by instantiating its data cache and processing the call's options.
		447	- Queueing: The logic that runs once the call has reached its point of execution in the element's $.queue() stack.
		448	Most logic is placed here to avoid risking it becoming stale (if the element's properties have changed).
		449	- Pushing: Consolidation of the tween data followed by its push onto the global in-progress calls container.
		450	- tick(): The single requestAnimationFrame loop responsible for tweening all in-progress calls.
		451	- completeCall(): Handles the cleanup process for each Velocity call.
		452	*/
		453
		454	/*********************
		455	Helper Functions
		456	*********************/
		457
		458	/* IE detection. Gist: https://gist.github.com/julianshapiro/9098609 */
		459	var IE = (function() {
		460	if (document.documentMode) {
		461	return document.documentMode;
		462	} else {
		463	for (var i = 7; i > 4; i--) {
		464	var div = document.createElement("div");
		465
		466	div.innerHTML = "<!--[if IE " + i + "]><span></span><![endif]-->";
		467
		468	if (div.getElementsByTagName("span").length) {
		469	div = null;
		470
		471	return i;
		472	}
		473	}
		474	}
		475
		476	return undefined;
		477	})();
		478
		479	/* rAF shim. Gist: https://gist.github.com/julianshapiro/9497513 */
		480	var rAFShim = (function() {
		481	var timeLast = 0;
		482
		483	return window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function(callback) {
		484	var timeCurrent = (new Date()).getTime(),
		485	timeDelta;
		486
		487	/* Dynamically set delay on a per-tick basis to match 60fps. */
		488	/* Technique by Erik Moller. MIT license: https://gist.github.com/paulirish/1579671 */
		489	timeDelta = Math.max(0, 16 - (timeCurrent - timeLast));
		490	timeLast = timeCurrent + timeDelta;
		491
		492	return setTimeout(function() {
		493	callback(timeCurrent + timeDelta);
		494	}, timeDelta);
		495	};
		496	})();
		497
		498	var performance = (function() {
		499	var perf = window.performance || {};
		500
		501	if (!Object.prototype.hasOwnProperty.call(perf, "now")) {
		502	var nowOffset = perf.timing && perf.timing.domComplete ? perf.timing.domComplete : (new Date()).getTime();
		503
		504	perf.now = function() {
		505	return (new Date()).getTime() - nowOffset;
		506	};
		507	}
		508	return perf;
		509	})();
		510
		511	/* Array compacting. Copyright Lo-Dash. MIT License: https://github.com/lodash/lodash/blob/master/LICENSE.txt */
		512	function compactSparseArray(array) {
		513	var index = -1,
		514	length = array ? array.length : 0,
		515	result = [];
		516
		517	while (++index < length) {
		518	var value = array[index];
		519
		520	if (value) {
		521	result.push(value);
		522	}
		523	}
		524
		525	return result;
		526	}
		527
		528	var _slice = (function() {
		529	var slice = Array.prototype.slice;
		530
		531	try {
		532	// Can't be used with DOM elements in IE < 9
		533	slice.call(document.documentElement);
		534	} catch (e) { // Fails in IE < 9
		535	// This will work for genuine arrays, array-like objects,
		536	// NamedNodeMap (attributes, entities, notations),
		537	// NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes),
		538	// and will not fail on other DOM objects (as do DOM elements in IE < 9)
		539	slice = function() {
		540	var i = this.length,
		541	clone = [];
		542
		543	while (--i > 0) {
		544	clone[i] = this[i];
		545	}
		546	return clone;
		547	};
		548	}
		549	return slice;
		550	})(); // TODO: IE8, Cache of Array.prototype.slice that works on IE8
		551
		552	function sanitizeElements(elements) {
		553	/* Unwrap jQuery/Zepto objects. */
		554	if (Type.isWrapped(elements)) {
		555	elements = _slice.call(elements);
		556	/* Wrap a single element in an array so that $.each() can iterate with the element instead of its node's children. */
		557	} else if (Type.isNode(elements)) {
		558	elements = [elements];
		559	}
		560
		561	return elements;
		562	}
		563
		564	var Type = {
		565	isNumber: function(variable) {
		566	return (typeof variable === "number");
		567	},
		568	isString: function(variable) {
		569	return (typeof variable === "string");
		570	},
		571	isArray: Array.isArray || function(variable) {
		572	return Object.prototype.toString.call(variable) === "[object Array]";
		573	},
		574	isFunction: function(variable) {
		575	return Object.prototype.toString.call(variable) === "[object Function]";
		576	},
		577	isNode: function(variable) {
		578	return variable && variable.nodeType;
		579	},
		580	/* Determine if variable is an array-like wrapped jQuery, Zepto or similar element, or even a NodeList etc. */
		581	/* NOTE: HTMLFormElements also have a length. */
		582	isWrapped: function(variable) {
		583	return variable
		584	&& Type.isNumber(variable.length)
		585	&& !Type.isString(variable)
		586	&& !Type.isFunction(variable)
		587	&& !Type.isNode(variable)
		588	&& (variable.length === 0 || Type.isNode(variable[0]));
		589	},
		590	isSVG: function(variable) {
		591	return window.SVGElement && (variable instanceof window.SVGElement);
		592	},
		593	isEmptyObject: function(variable) {
		594	for (var name in variable) {
		595	if (variable.hasOwnProperty(name)) {
		596	return false;
		597	}
		598	}
		599
		600	return true;
		601	}
		602	};
		603
		604	/*****************
		605	Dependencies
		606	*****************/
		607
		608	var $,
		609	isJQuery = false;
		610
		611	if (global.fn && global.fn.jquery) {
		612	$ = global;
		613	isJQuery = true;
		614	} else {
		615	$ = window.Velocity.Utilities;
		616	}
		617
		618	if (IE <= 8 && !isJQuery) {
		619	throw new Error("Velocity: IE8 and below require jQuery to be loaded before Velocity.");
		620	} else if (IE <= 7) {
		621	/* Revert to jQuery's $.animate(), and lose Velocity's extra features. */
		622	jQuery.fn.velocity = jQuery.fn.animate;
		623
		624	/* Now that $.fn.velocity is aliased, abort this Velocity declaration. */
		625	return;
		626	}
		627
		628	/*****************
		629	Constants
		630	*****************/
		631
		632	var DURATION_DEFAULT = 400,
		633	EASING_DEFAULT = "swing";
		634
		635	/*************
		636	State
		637	*************/
		638
		639	var Velocity = {
		640	/* Container for page-wide Velocity state data. */
		641	State: {
		642	/* Detect mobile devices to determine if mobileHA should be turned on. */
		643	isMobile: /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent),
		644	/* The mobileHA option's behavior changes on older Android devices (Gingerbread, versions 2.3.3-2.3.7). */
		645	isAndroid: /Android/i.test(navigator.userAgent),
		646	isGingerbread: /Android 2\.3\.[3-7]/i.test(navigator.userAgent),
		647	isChrome: window.chrome,
		648	isFirefox: /Firefox/i.test(navigator.userAgent),
		649	/* Create a cached element for re-use when checking for CSS property prefixes. */
		650	prefixElement: document.createElement("div"),
		651	/* Cache every prefix match to avoid repeating lookups. */
		652	prefixMatches: {},
		653	/* Cache the anchor used for animating window scrolling. */
		654	scrollAnchor: null,
		655	/* Cache the browser-specific property names associated with the scroll anchor. */
		656	scrollPropertyLeft: null,
		657	scrollPropertyTop: null,
		658	/* Keep track of whether our RAF tick is running. */
		659	isTicking: false,
		660	/* Container for every in-progress call to Velocity. */
		661	calls: [],
		662	delayedElements: {
		663	count: 0
		664	}
		665	},
		666	/* Velocity's custom CSS stack. Made global for unit testing. */
		667	CSS: {/* Defined below. */},
		668	/* A shim of the jQuery utility functions used by Velocity -- provided by Velocity's optional jQuery shim. */
		669	Utilities: $,
		670	/* Container for the user's custom animation redirects that are referenced by name in place of the properties map argument. */
		671	Redirects: {/* Manually registered by the user. */},
		672	Easings: {/* Defined below. */},
		673	/* Attempt to use ES6 Promises by default. Users can override this with a third-party promises library. */
		674	Promise: window.Promise,
		675	/* Velocity option defaults, which can be overriden by the user. */
		676	defaults: {
		677	queue: "",
		678	duration: DURATION_DEFAULT,
		679	easing: EASING_DEFAULT,
		680	begin: undefined,
		681	complete: undefined,
		682	progress: undefined,
		683	display: undefined,
		684	visibility: undefined,
		685	loop: false,
		686	delay: false,
		687	mobileHA: true,
		688	/* Advanced: Set to false to prevent property values from being cached between consecutive Velocity-initiated chain calls. */
		689	_cacheValues: true,
		690	/* Advanced: Set to false if the promise should always resolve on empty element lists. */
		691	promiseRejectEmpty: true
		692	},
		693	/* A design goal of Velocity is to cache data wherever possible in order to avoid DOM requerying. Accordingly, each element has a data cache. */
		694	init: function(element) {
		695	$.data(element, "velocity", {
		696	/* Store whether this is an SVG element, since its properties are retrieved and updated differently than standard HTML elements. */
		697	isSVG: Type.isSVG(element),
		698	/* Keep track of whether the element is currently being animated by Velocity.
		699	This is used to ensure that property values are not transferred between non-consecutive (stale) calls. */
		700	isAnimating: false,
		701	/* A reference to the element's live computedStyle object. Learn more here: https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle */
		702	computedStyle: null,
		703	/* Tween data is cached for each animation on the element so that data can be passed across calls --
		704	in particular, end values are used as subsequent start values in consecutive Velocity calls. */
		705	tweensContainer: null,
		706	/* The full root property values of each CSS hook being animated on this element are cached so that:
		707	1) Concurrently-animating hooks sharing the same root can have their root values' merged into one while tweening.
		708	2) Post-hook-injection root values can be transferred over to consecutively chained Velocity calls as starting root values. */
		709	rootPropertyValueCache: {},
		710	/* A cache for transform updates, which must be manually flushed via CSS.flushTransformCache(). */
		711	transformCache: {}
		712	});
		713	},
		714	/* A parallel to jQuery's $.css(), used for getting/setting Velocity's hooked CSS properties. */
		715	hook: null, /* Defined below. */
		716	/* Velocity-wide animation time remapping for testing purposes. */
		717	mock: false,
		718	version: {major: 1, minor: 4, patch: 3},
		719	/* Set to 1 or 2 (most verbose) to output debug info to console. */
		720	debug: false,
		721	/* Use rAF high resolution timestamp when available */
		722	timestamp: true,
		723	/* Pause all animations */
		724	pauseAll: function(queueName) {
		725	var currentTime = (new Date()).getTime();
		726
		727	$.each(Velocity.State.calls, function(i, activeCall) {
		728
		729	if (activeCall) {
		730
		731	/* If we have a queueName and this call is not on that queue, skip */
		732	if (queueName !== undefined && ((activeCall[2].queue !== queueName) || (activeCall[2].queue === false))) {
		733	return true;
		734	}
		735
		736	/* Set call to paused */
		737	activeCall[5] = {
		738	resume: false
		739	};
		740	}
		741	});
		742
		743	/* Pause timers on any currently delayed calls */
		744	$.each(Velocity.State.delayedElements, function(k, element) {
		745	if (!element) {
		746	return;
		747	}
		748	pauseDelayOnElement(element, currentTime);
		749	});
		750	},
		751	/* Resume all animations */
		752	resumeAll: function(queueName) {
		753	var currentTime = (new Date()).getTime();
		754
		755	$.each(Velocity.State.calls, function(i, activeCall) {
		756
		757	if (activeCall) {
		758
		759	/* If we have a queueName and this call is not on that queue, skip */
		760	if (queueName !== undefined && ((activeCall[2].queue !== queueName) || (activeCall[2].queue === false))) {
		761	return true;
		762	}
		763
		764	/* Set call to resumed if it was paused */
		765	if (activeCall[5]) {
		766	activeCall[5].resume = true;
		767	}
		768	}
		769	});
		770	/* Resume timers on any currently delayed calls */
		771	$.each(Velocity.State.delayedElements, function(k, element) {
		772	if (!element) {
		773	return;
		774	}
		775	resumeDelayOnElement(element, currentTime);
		776	});
		777	}
		778	};
		779
		780	/* Retrieve the appropriate scroll anchor and property name for the browser: https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY */
		781	if (window.pageYOffset !== undefined) {
		782	Velocity.State.scrollAnchor = window;
		783	Velocity.State.scrollPropertyLeft = "pageXOffset";
		784	Velocity.State.scrollPropertyTop = "pageYOffset";
		785	} else {
		786	Velocity.State.scrollAnchor = document.documentElement || document.body.parentNode || document.body;
		787	Velocity.State.scrollPropertyLeft = "scrollLeft";
		788	Velocity.State.scrollPropertyTop = "scrollTop";
		789	}
		790
		791	/* Shorthand alias for jQuery's $.data() utility. */
		792	function Data(element) {
		793	/* Hardcode a reference to the plugin name. */
		794	var response = $.data(element, "velocity");
		795
		796	/* jQuery <=1.4.2 returns null instead of undefined when no match is found. We normalize this behavior. */
		797	return response === null ? undefined : response;
		798	}
		799
		800	/**************
		801	Delay Timer
		802	**************/
		803
		804	function pauseDelayOnElement(element, currentTime) {
		805	/* Check for any delay timers, and pause the set timeouts (while preserving time data)
		806	to be resumed when the "resume" command is issued */
		807	var data = Data(element);
		808	if (data && data.delayTimer && !data.delayPaused) {
		809	data.delayRemaining = data.delay - currentTime + data.delayBegin;
		810	data.delayPaused = true;
		811	clearTimeout(data.delayTimer.setTimeout);
		812	}
		813	}
		814
		815	function resumeDelayOnElement(element, currentTime) {
		816	/* Check for any paused timers and resume */
		817	var data = Data(element);
		818	if (data && data.delayTimer && data.delayPaused) {
		819	/* If the element was mid-delay, re initiate the timeout with the remaining delay */
		820	data.delayPaused = false;
		821	data.delayTimer.setTimeout = setTimeout(data.delayTimer.next, data.delayRemaining);
		822	}
		823	}
		824
		825
		826
		827	/**************
		828	Easing
		829	**************/
		830
		831	/* Step easing generator. */
		832	function generateStep(steps) {
		833	return function(p) {
		834	return Math.round(p * steps) * (1 / steps);
		835	};
		836	}
		837
		838	/* Bezier curve function generator. Copyright Gaetan Renaudeau. MIT License: http://en.wikipedia.org/wiki/MIT_License */
		839	function generateBezier(mX1, mY1, mX2, mY2) {
		840	var NEWTON_ITERATIONS = 4,
		841	NEWTON_MIN_SLOPE = 0.001,
		842	SUBDIVISION_PRECISION = 0.0000001,
		843	SUBDIVISION_MAX_ITERATIONS = 10,
		844	kSplineTableSize = 11,
		845	kSampleStepSize = 1.0 / (kSplineTableSize - 1.0),
		846	float32ArraySupported = "Float32Array" in window;
		847
		848	/* Must contain four arguments. */
		849	if (arguments.length !== 4) {
		850	return false;
		851	}
		852
		853	/* Arguments must be numbers. */
		854	for (var i = 0; i < 4; ++i) {
		855	< 4; ++i) { if (typeof arguments[i] !== "number" || isNaN(arguments[i]) || !isFinite(arguments[i])) {
		856	< 4; ++i) { return false;
		857	< 4; ++i) { }
		858	< 4; ++i) { }
		859
		860	< 4; ++i) { /* X values must be in the [0, 1] range. */
		861	< 4; ++i) { mX1 = Math.min(mX1, 1);
		862	< 4; ++i) { mX2 = Math.min(mX2, 1);
		863	< 4; ++i) { mX1 = Math.max(mX1, 0);
		864	< 4; ++i) { mX2 = Math.max(mX2, 0);
		865
		866	< 4; ++i) { var mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
		867
		868	< 4; ++i) { function A(aA1, aA2) {
		869	< 4; ++i) { return 1.0 - 3.0 * aA2 + 3.0 * aA1;
		870	< 4; ++i) { }
		871	< 4; ++i) { function B(aA1, aA2) {
		872	< 4; ++i) { return 3.0 * aA2 - 6.0 * aA1;
		873	< 4; ++i) { }
		874	< 4; ++i) { function C(aA1) {
		875	< 4; ++i) { return 3.0 * aA1;
		876	< 4; ++i) { }
		877
		878	< 4; ++i) { function calcBezier(aT, aA1, aA2) {
		879	< 4; ++i) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
		880	< 4; ++i) { }
		881
		882	< 4; ++i) { function getSlope(aT, aA1, aA2) {
		883	< 4; ++i) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
		884	< 4; ++i) { }
		885
		886	< 4; ++i) { function newtonRaphsonIterate(aX, aGuessT) {
		887	< 4; ++i) { for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
		888	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { var currentSlope = getSlope(aGuessT, mX1, mX2);
		889
		890	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { if (currentSlope === 0.0) {
		891	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { return aGuessT;
		892	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
		893
		894	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
		895	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { aGuessT -= currentX / currentSlope;
		896	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
		897
		898	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { return aGuessT;
		899	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
		900
		901	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { function calcSampleValues() {
		902	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { for (var i = 0; i < kSplineTableSize; ++i) {
		903	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
		904	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
		905	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
		906
		907	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { function binarySubdivide(aX, aA, aB) {
		908	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { var currentX, currentT, i = 0;
		909
		910	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { do {
		911	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { currentT = aA + (aB - aA) / 2.0;
		912	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { currentX = calcBezier(currentT, mX1, mX2) - aX;
		913	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { if (currentX > 0.0) {
		914	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { aB = currentT;
		915	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { } else {
		916	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { aA = currentT;
		917	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
		918	< 4; ++i) {< NEWTON_ITERATIONS; ++i) { } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
		919
		920	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); return currentT;
		921	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); }
		922
		923	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); function getTForX(aX) {
		924	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); var intervalStart = 0.0,
		925	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); currentSample = 1,
		926	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); lastSample = kSplineTableSize - 1;
		927
		928	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
		929	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { intervalStart += kSampleStepSize;
		930	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		931
		932	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { --currentSample;
		933
		934	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]),
		935	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { guessForT = intervalStart + dist * kSampleStepSize,
		936	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { initialSlope = getSlope(guessForT, mX1, mX2);
		937
		938	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (initialSlope >= NEWTON_MIN_SLOPE) {
		939	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return newtonRaphsonIterate(aX, guessForT);
		940	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (initialSlope === 0.0) {
		941	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return guessForT;
		942	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		943	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize);
		944	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		945	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		946
		947	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var _precomputed = false;
		948
		949	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function precompute() {
		950	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { _precomputed = true;
		951	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (mX1 !== mY1 || mX2 !== mY2) {
		952	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { calcSampleValues();
		953	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		954	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		955
		956	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var f = function(aX) {
		957	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!_precomputed) {
		958	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { precompute();
		959	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		960	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (mX1 === mY1 && mX2 === mY2) {
		961	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return aX;
		962	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		963	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (aX === 0) {
		964	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 0;
		965	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		966	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (aX === 1) {
		967	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 1;
		968	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		969
		970	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return calcBezier(getTForX(aX), mY1, mY2);
		971	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		972
		973	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { f.getControlPoints = function() {
		974	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return [{x: mX1, y: mY1}, {x: mX2, y: mY2}];
		975	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		976
		977	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var str = "generateBezier(" + [mX1, mY1, mX2, mY2] + ")";
		978	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { f.toString = function() {
		979	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return str;
		980	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		981
		982	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return f;
		983	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		984
		985	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Runge-Kutta spring physics function generator. Adapted from Framer.js, copyright Koen Bok. MIT License: http://en.wikipedia.org/wiki/MIT_License */
		986	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* 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
		987	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { then adjusts the time delta -- using the relation between actual time and duration -- to calculate the path for the duration-constrained animation. */
		988	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var generateSpringRK4 = (function() {
		989	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function springAccelerationForState(state) {
		990	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return (-state.tension * state.x) - (state.friction * state.v);
		991	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		992
		993	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function springEvaluateStateWithDerivative(initialState, dt, derivative) {
		994	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var state = {
		995	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { x: initialState.x + derivative.dx * dt,
		996	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { v: initialState.v + derivative.dv * dt,
		997	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tension: initialState.tension,
		998	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { friction: initialState.friction
		999	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		1000
		1001	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return {dx: state.v, dv: springAccelerationForState(state)};
		1002	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1003
		1004	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function springIntegrateState(state, dt) {
		1005	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var a = {
		1006	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dx: state.v,
		1007	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dv: springAccelerationForState(state)
		1008	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1009	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { b = springEvaluateStateWithDerivative(state, dt * 0.5, a),
		1010	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { c = springEvaluateStateWithDerivative(state, dt * 0.5, b),
		1011	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { d = springEvaluateStateWithDerivative(state, dt, c),
		1012	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dxdt = 1.0 / 6.0 * (a.dx + 2.0 * (b.dx + c.dx) + d.dx),
		1013	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dvdt = 1.0 / 6.0 * (a.dv + 2.0 * (b.dv + c.dv) + d.dv);
		1014
		1015	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { state.x = state.x + dxdt * dt;
		1016	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { state.v = state.v + dvdt * dt;
		1017
		1018	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return state;
		1019	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1020
		1021	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return function springRK4Factory(tension, friction, duration) {
		1022
		1023	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var initState = {
		1024	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { x: -1,
		1025	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { v: 0,
		1026	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tension: null,
		1027	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { friction: null
		1028	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1029	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { path = [0],
		1030	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { time_lapsed = 0,
		1031	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tolerance = 1 / 10000,
		1032	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { DT = 16 / 1000,
		1033	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { have_duration, dt, last_state;
		1034
		1035	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tension = parseFloat(tension) || 500;
		1036	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { friction = parseFloat(friction) || 20;
		1037	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { duration = duration || null;
		1038
		1039	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { initState.tension = tension;
		1040	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { initState.friction = friction;
		1041
		1042	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { have_duration = duration !== null;
		1043
		1044	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Calculate the actual time it takes for this animation to complete with the provided conditions. */
		1045	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (have_duration) {
		1046	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Run the simulation without a duration. */
		1047	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { time_lapsed = springRK4Factory(tension, friction);
		1048	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Compute the adjusted time delta. */
		1049	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dt = time_lapsed / duration * DT;
		1050	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1051	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dt = DT;
		1052	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1053
		1054	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { while (true) {
		1055	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Next/step function .*/
		1056	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { last_state = springIntegrateState(last_state || initState, dt);
		1057	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Store the position. */
		1058	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { path.push(1 + last_state.x);
		1059	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { time_lapsed += 16;
		1060	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the change threshold is reached, break. */
		1061	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!(Math.abs(last_state.x) > tolerance && Math.abs(last_state.v) > tolerance)) {
		1062	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { break;
		1063	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1064	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1065
		1066	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If duration is not defined, return the actual time required for completing this animation. Otherwise, return a closure that holds the
		1067	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { computed path and returns a snapshot of the position according to a given percentComplete. */
		1068	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return !have_duration ? time_lapsed : function(percentComplete) {
		1069	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return path[ (percentComplete * (path.length - 1)) | 0 ];
		1070	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		1071	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		1072	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }());
		1073
		1074	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* jQuery easings. */
		1075	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Velocity.Easings = {
		1076	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { linear: function(p) {
		1077	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return p;
		1078	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1079	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { swing: function(p) {
		1080	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 0.5 - Math.cos(p * Math.PI) / 2;
		1081	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1082	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Bonus "spring" easing, which is a less exaggerated version of easeInOutElastic. */
		1083	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { spring: function(p) {
		1084	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 1 - (Math.cos(p * 4.5 * Math.PI) * Math.exp(-p * 6));
		1085	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1086	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
		1087
		1088	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* CSS3 and Robert Penner easings. */
		1089	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { $.each(
		1090	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { [
		1091	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease", [0.25, 0.1, 0.25, 1.0]],
		1092	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease-in", [0.42, 0.0, 1.00, 1.0]],
		1093	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease-out", [0.00, 0.0, 0.58, 1.0]],
		1094	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease-in-out", [0.42, 0.0, 0.58, 1.0]],
		1095	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInSine", [0.47, 0, 0.745, 0.715]],
		1096	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutSine", [0.39, 0.575, 0.565, 1]],
		1097	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutSine", [0.445, 0.05, 0.55, 0.95]],
		1098	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInQuad", [0.55, 0.085, 0.68, 0.53]],
		1099	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutQuad", [0.25, 0.46, 0.45, 0.94]],
		1100	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutQuad", [0.455, 0.03, 0.515, 0.955]],
		1101	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInCubic", [0.55, 0.055, 0.675, 0.19]],
		1102	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutCubic", [0.215, 0.61, 0.355, 1]],
		1103	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutCubic", [0.645, 0.045, 0.355, 1]],
		1104	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInQuart", [0.895, 0.03, 0.685, 0.22]],
		1105	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutQuart", [0.165, 0.84, 0.44, 1]],
		1106	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutQuart", [0.77, 0, 0.175, 1]],
		1107	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInQuint", [0.755, 0.05, 0.855, 0.06]],
		1108	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutQuint", [0.23, 1, 0.32, 1]],
		1109	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutQuint", [0.86, 0, 0.07, 1]],
		1110	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInExpo", [0.95, 0.05, 0.795, 0.035]],
		1111	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutExpo", [0.19, 1, 0.22, 1]],
		1112	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutExpo", [1, 0, 0, 1]],
		1113	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInCirc", [0.6, 0.04, 0.98, 0.335]],
		1114	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutCirc", [0.075, 0.82, 0.165, 1]],
		1115	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutCirc", [0.785, 0.135, 0.15, 0.86]]
		1116	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ], function(i, easingArray) {
		1117	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Velocity.Easings[easingArray[0]] = generateBezier.apply(null, easingArray[1]);
		1118	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { });
		1119
		1120	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Determine the appropriate easing type given an easing input. */
		1121	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function getEasing(value, duration) {
		1122	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var easing = value;
		1123
		1124	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* The easing option can either be a string that references a pre-registered easing,
		1125	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { or it can be a two-/four-item array of integers to be converted into a bezier/spring function. */
		1126	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (Type.isString(value)) {
		1127	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Ensure that the easing has been assigned to jQuery's Velocity.Easings object. */
		1128	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!Velocity.Easings[value]) {
		1129	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = false;
		1130	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1131	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (Type.isArray(value) && value.length === 1) {
		1132	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = generateStep.apply(null, value);
		1133	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (Type.isArray(value) && value.length === 2) {
		1134	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* springRK4 must be passed the animation's duration. */
		1135	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: If the springRK4 array contains non-numbers, generateSpringRK4() returns an easing
		1136	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function generated with default tension and friction values. */
		1137	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = generateSpringRK4.apply(null, value.concat([duration]));
		1138	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (Type.isArray(value) && value.length === 4) {
		1139	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: If the bezier array contains non-numbers, generateBezier() returns false. */
		1140	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = generateBezier.apply(null, value);
		1141	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1142	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = false;
		1143	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1144
		1145	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Revert to the Velocity-wide default easing type, or fall back to "swing" (which is also jQuery's default)
		1146	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if the Velocity-wide default has been incorrectly modified. */
		1147	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (easing === false) {
		1148	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (Velocity.Easings[Velocity.defaults.easing]) {
		1149	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = Velocity.defaults.easing;
		1150	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1151	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = EASING_DEFAULT;
		1152	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1153	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1154
		1155	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return easing;
		1156	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1157
		1158	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*****************
		1159	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS Stack
		1160	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *****************/
		1161
		1162	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* The CSS object is a highly condensed and performant CSS stack that fully replaces jQuery's.
		1163	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { It handles the validation, getting, and setting of both standard CSS properties and CSS property hooks. */
		1164	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: A "CSS" shorthand is aliased so that our code is easier to read. */
		1165	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var CSS = Velocity.CSS = {
		1166	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*************
		1167	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { RegEx
		1168	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *************/
		1169
		1170	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { RegEx: {
		1171	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { isHex: /^#([A-f\d]{3}){1,2}$/i,
		1172	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* 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". */
		1173	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { valueUnwrap: /^[A-z]+\((.*)\)$/i,
		1174	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { wrappedValueAlreadyExtracted: /[0-9.]+ [0-9.]+ [0-9.]+( [0-9.]+)?/,
		1175	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* 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" ]. */
		1176	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { valueSplit: /([A-z]+\(.+\))|(([A-z0-9#-.]+?)(?=\s|$))/ig
		1177	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1178	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /************
		1179	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Lists
		1180	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ************/
		1181
		1182	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Lists: {
		1183	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { colors: ["fill", "stroke", "stopColor", "color", "backgroundColor", "borderColor", "borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor", "outlineColor"],
		1184	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { transformsBase: ["translateX", "translateY", "scale", "scaleX", "scaleY", "skewX", "skewY", "rotateZ"],
		1185	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { transforms3D: ["transformPerspective", "translateZ", "scaleZ", "rotateX", "rotateY"],
		1186	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { units: [
		1187	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "%", // relative
		1188	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "em", "ex", "ch", "rem", // font relative
		1189	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "vw", "vh", "vmin", "vmax", // viewport relative
		1190	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cm", "mm", "Q", "in", "pc", "pt", "px", // absolute lengths
		1191	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "deg", "grad", "rad", "turn", // angles
		1192	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "s", "ms" // time
		1193	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ],
		1194	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { colorNames: {
		1195	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "aliceblue": "240,248,255",
		1196	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "antiquewhite": "250,235,215",
		1197	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "aquamarine": "127,255,212",
		1198	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "aqua": "0,255,255",
		1199	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "azure": "240,255,255",
		1200	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "beige": "245,245,220",
		1201	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "bisque": "255,228,196",
		1202	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "black": "0,0,0",
		1203	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "blanchedalmond": "255,235,205",
		1204	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "blueviolet": "138,43,226",
		1205	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "blue": "0,0,255",
		1206	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "brown": "165,42,42",
		1207	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "burlywood": "222,184,135",
		1208	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cadetblue": "95,158,160",
		1209	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "chartreuse": "127,255,0",
		1210	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "chocolate": "210,105,30",
		1211	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "coral": "255,127,80",
		1212	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cornflowerblue": "100,149,237",
		1213	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cornsilk": "255,248,220",
		1214	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "crimson": "220,20,60",
		1215	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cyan": "0,255,255",
		1216	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkblue": "0,0,139",
		1217	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkcyan": "0,139,139",
		1218	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgoldenrod": "184,134,11",
		1219	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgray": "169,169,169",
		1220	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgrey": "169,169,169",
		1221	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgreen": "0,100,0",
		1222	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkkhaki": "189,183,107",
		1223	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkmagenta": "139,0,139",
		1224	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkolivegreen": "85,107,47",
		1225	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkorange": "255,140,0",
		1226	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkorchid": "153,50,204",
		1227	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkred": "139,0,0",
		1228	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darksalmon": "233,150,122",
		1229	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkseagreen": "143,188,143",
		1230	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkslateblue": "72,61,139",
		1231	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkslategray": "47,79,79",
		1232	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkturquoise": "0,206,209",
		1233	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkviolet": "148,0,211",
		1234	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "deeppink": "255,20,147",
		1235	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "deepskyblue": "0,191,255",
		1236	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "dimgray": "105,105,105",
		1237	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "dimgrey": "105,105,105",
		1238	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "dodgerblue": "30,144,255",
		1239	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "firebrick": "178,34,34",
		1240	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "floralwhite": "255,250,240",
		1241	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "forestgreen": "34,139,34",
		1242	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "fuchsia": "255,0,255",
		1243	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "gainsboro": "220,220,220",
		1244	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "ghostwhite": "248,248,255",
		1245	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "gold": "255,215,0",
		1246	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "goldenrod": "218,165,32",
		1247	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "gray": "128,128,128",
		1248	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "grey": "128,128,128",
		1249	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "greenyellow": "173,255,47",
		1250	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "green": "0,128,0",
		1251	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "honeydew": "240,255,240",
		1252	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "hotpink": "255,105,180",
		1253	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "indianred": "205,92,92",
		1254	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "indigo": "75,0,130",
		1255	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "ivory": "255,255,240",
		1256	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "khaki": "240,230,140",
		1257	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lavenderblush": "255,240,245",
		1258	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lavender": "230,230,250",
		1259	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lawngreen": "124,252,0",
		1260	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lemonchiffon": "255,250,205",
		1261	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightblue": "173,216,230",
		1262	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightcoral": "240,128,128",
		1263	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightcyan": "224,255,255",
		1264	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgoldenrodyellow": "250,250,210",
		1265	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgray": "211,211,211",
		1266	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgrey": "211,211,211",
		1267	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgreen": "144,238,144",
		1268	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightpink": "255,182,193",
		1269	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightsalmon": "255,160,122",
		1270	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightseagreen": "32,178,170",
		1271	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightskyblue": "135,206,250",
		1272	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightslategray": "119,136,153",
		1273	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightsteelblue": "176,196,222",
		1274	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightyellow": "255,255,224",
		1275	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "limegreen": "50,205,50",
		1276	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lime": "0,255,0",
		1277	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "linen": "250,240,230",
		1278	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "magenta": "255,0,255",
		1279	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "maroon": "128,0,0",
		1280	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumaquamarine": "102,205,170",
		1281	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumblue": "0,0,205",
		1282	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumorchid": "186,85,211",
		1283	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumpurple": "147,112,219",
		1284	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumseagreen": "60,179,113",
		1285	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumslateblue": "123,104,238",
		1286	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumspringgreen": "0,250,154",
		1287	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumturquoise": "72,209,204",
		1288	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumvioletred": "199,21,133",
		1289	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "midnightblue": "25,25,112",
		1290	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mintcream": "245,255,250",
		1291	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mistyrose": "255,228,225",
		1292	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "moccasin": "255,228,181",
		1293	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "navajowhite": "255,222,173",
		1294	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "navy": "0,0,128",
		1295	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "oldlace": "253,245,230",
		1296	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "olivedrab": "107,142,35",
		1297	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "olive": "128,128,0",
		1298	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "orangered": "255,69,0",
		1299	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "orange": "255,165,0",
		1300	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "orchid": "218,112,214",
		1301	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "palegoldenrod": "238,232,170",
		1302	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "palegreen": "152,251,152",
		1303	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "paleturquoise": "175,238,238",
		1304	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "palevioletred": "219,112,147",
		1305	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "papayawhip": "255,239,213",
		1306	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "peachpuff": "255,218,185",
		1307	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "peru": "205,133,63",
		1308	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "pink": "255,192,203",
		1309	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "plum": "221,160,221",
		1310	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "powderblue": "176,224,230",
		1311	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "purple": "128,0,128",
		1312	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "red": "255,0,0",
		1313	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "rosybrown": "188,143,143",
		1314	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "royalblue": "65,105,225",
		1315	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "saddlebrown": "139,69,19",
		1316	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "salmon": "250,128,114",
		1317	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "sandybrown": "244,164,96",
		1318	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "seagreen": "46,139,87",
		1319	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "seashell": "255,245,238",
		1320	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "sienna": "160,82,45",
		1321	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "silver": "192,192,192",
		1322	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "skyblue": "135,206,235",
		1323	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "slateblue": "106,90,205",
		1324	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "slategray": "112,128,144",
		1325	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "snow": "255,250,250",
		1326	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "springgreen": "0,255,127",
		1327	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "steelblue": "70,130,180",
		1328	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "tan": "210,180,140",
		1329	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "teal": "0,128,128",
		1330	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "thistle": "216,191,216",
		1331	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "tomato": "255,99,71",
		1332	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "turquoise": "64,224,208",
		1333	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "violet": "238,130,238",
		1334	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "wheat": "245,222,179",
		1335	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "whitesmoke": "245,245,245",
		1336	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "white": "255,255,255",
		1337	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "yellowgreen": "154,205,50",
		1338	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "yellow": "255,255,0"
		1339	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1340	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1341	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /************
		1342	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Hooks
		1343	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ************/
		1344
		1345	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Hooks allow a subproperty (e.g. "boxShadowBlur") of a compound-value CSS property
		1346	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { (e.g. "boxShadow: X Y Blur Spread Color") to be animated as if it were a discrete property. */
		1347	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: Beyond enabling fine-grained property animation, hooking is necessary since Velocity only
		1348	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tweens properties with single numeric values; unlike CSS transitions, Velocity does not interpolate compound-values. */
		1349	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Hooks: {
		1350	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /********************
		1351	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Registration
		1352	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ********************/
		1353
		1354	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Templates are a concise way of indicating which subproperties must be individually registered for each compound-value CSS property. */
		1355	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Each template consists of the compound-value's base name, its constituent subproperty names, and those subproperties' default values. */
		1356	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { templates: {
		1357	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "textShadow": ["Color X Y Blur", "black 0px 0px 0px"],
		1358	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "boxShadow": ["Color X Y Blur Spread", "black 0px 0px 0px 0px"],
		1359	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "clip": ["Top Right Bottom Left", "0px 0px 0px 0px"],
		1360	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "backgroundPosition": ["X Y", "0% 0%"],
		1361	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "transformOrigin": ["X Y Z", "50% 50% 0px"],
		1362	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "perspectiveOrigin": ["X Y", "50% 50%"]
		1363	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1364	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* A "registered" hook is one that has been converted from its template form into a live,
		1365	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tweenable property. It contains data to associate it with its root property. */
		1366	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { registered: {
		1367	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: A registered hook looks like this ==> textShadowBlur: [ "textShadow", 3 ],
		1368	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { which consists of the subproperty's name, the associated root property's name,
		1369	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and the subproperty's position in the root's value. */
		1370	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1371	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Convert the templates into individual hooks then append them to the registered object above. */
		1372	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { register: function() {
		1373	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Color hooks registration: Colors are defaulted to white -- as opposed to black -- since colors that are
		1374	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { currently set to "transparent" default to their respective template below when color-animated,
		1375	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and white is typically a closer match to transparent than black is. An exception is made for text ("color"),
		1376	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { which is almost always set closer to black than white. */
		1377	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (var i = 0; i < CSS.Lists.colors.length; i++) {
		1378	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var rgbComponents = (CSS.Lists.colors[i] === "color") ? "0 0 0 1" : "255 255 255 1";
		1379	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS.Hooks.templates[CSS.Lists.colors[i]] = ["Red Green Blue Alpha", rgbComponents];
		1380	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1381
		1382	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var rootProperty,
		1383	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookTemplate,
		1384	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames;
		1385
		1386	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* In IE, color values inside compound-value properties are positioned at the end the value instead of at the beginning.
		1387	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Thus, we re-arrange the templates accordingly. */
		1388	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (IE) {
		1389	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (rootProperty in CSS.Hooks.templates) {
		1390	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!CSS.Hooks.templates.hasOwnProperty(rootProperty)) {
		1391	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { continue;
		1392	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1393	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookTemplate = CSS.Hooks.templates[rootProperty];
		1394	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames = hookTemplate[0].split(" ");
		1395
		1396	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var defaultValues = hookTemplate[1].match(CSS.RegEx.valueSplit);
		1397
		1398	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookNames[0] === "Color") {
		1399	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Reposition both the hook's name and its default value to the end of their respective strings. */
		1400	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames.push(hookNames.shift());
		1401	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { defaultValues.push(defaultValues.shift());
		1402
		1403	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Replace the existing template for the hook's root property. */
		1404	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS.Hooks.templates[rootProperty] = [hookNames.join(" "), defaultValues.join(" ")];
		1405	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1406	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1407	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1408
		1409	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Hook registration. */
		1410	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (rootProperty in CSS.Hooks.templates) {
		1411	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!CSS.Hooks.templates.hasOwnProperty(rootProperty)) {
		1412	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { continue;
		1413	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1414	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookTemplate = CSS.Hooks.templates[rootProperty];
		1415	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames = hookTemplate[0].split(" ");
		1416
		1417	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (var j in hookNames) {
		1418	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!hookNames.hasOwnProperty(j)) {
		1419	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { continue;
		1420	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1421	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var fullHookName = rootProperty + hookNames[j],
		1422	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookPosition = j;
		1423
		1424	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* For each hook, register its full name (e.g. textShadowBlur) with its root property (e.g. textShadow)
		1425	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and the hook's position in its template's default value string. */
		1426	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS.Hooks.registered[fullHookName] = [rootProperty, hookPosition];
		1427	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1428	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1429	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1430	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*****************************
		1431	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Injection and Extraction
		1432	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *****************************/
		1433
		1434	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Look up the root property associated with the hook (e.g. return "textShadow" for "textShadowBlur"). */
		1435	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* 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. */
		1436	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { getRoot: function(property) {
		1437	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookData = CSS.Hooks.registered[property];
		1438
		1439	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookData) {
		1440	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return hookData[0];
		1441	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1442	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If there was no hook match, return the property name untouched. */
		1443	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return property;
		1444	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1445	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1446	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { getUnit: function(str, start) {
		1447	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var unit = (str.substr(start || 0, 5).match(/^[a-z%]+/) || [])[0] || "";
		1448
		1449	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (unit && CSS.Lists.units.indexOf(unit) >= 0) {
		1450	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return unit;
		1451	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1452	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "";
		1453	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1454	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { fixColors: function(str) {
		1455	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return str.replace(/(rgba?\(\s*)?(\b[a-z]+\b)/g, function($0, $1, $2) {
		1456	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.Lists.colorNames.hasOwnProperty($2)) {
		1457	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return ($1 ? $1 : "rgba(") + CSS.Lists.colorNames[$2] + ($1 ? "" : ",1)");
		1458	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1459	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return $1 + $2;
		1460	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { });
		1461	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1462	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Convert any rootPropertyValue, null or otherwise, into a space-delimited list of hook values so that
		1463	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { the targeted hook can be injected or extracted at its standard position. */
		1464	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { cleanRootPropertyValue: function(rootProperty, rootPropertyValue) {
		1465	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the rootPropertyValue is wrapped with "rgb()", "clip()", etc., remove the wrapping to normalize the value before manipulation. */
		1466	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.RegEx.valueUnwrap.test(rootPropertyValue)) {
		1467	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = rootPropertyValue.match(CSS.RegEx.valueUnwrap)[1];
		1468	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1469
		1470	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If rootPropertyValue is a CSS null-value (from which there's inherently no hook value to extract),
		1471	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { default to the root's default value as defined in CSS.Hooks.templates. */
		1472	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: CSS null-values include "none", "auto", and "transparent". They must be converted into their
		1473	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { zero-values (e.g. textShadow: "none" ==> textShadow: "0px 0px 0px black") for hook manipulation to proceed. */
		1474	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.Values.isCSSNullValue(rootPropertyValue)) {
		1475	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = CSS.Hooks.templates[rootProperty][1];
		1476	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1477
		1478	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue;
		1479	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1480	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Extracted the hook's value from its root property's value. This is used to get the starting value of an animating hook. */
		1481	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extractValue: function(fullHookName, rootPropertyValue) {
		1482	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookData = CSS.Hooks.registered[fullHookName];
		1483
		1484	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookData) {
		1485	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookRoot = hookData[0],
		1486	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookPosition = hookData[1];
		1487
		1488	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = CSS.Hooks.cleanRootPropertyValue(hookRoot, rootPropertyValue);
		1489
		1490	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Split rootPropertyValue into its constituent hook values then grab the desired hook at its standard position. */
		1491	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue.toString().match(CSS.RegEx.valueSplit)[hookPosition];
		1492	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1493	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the provided fullHookName isn't a registered hook, return the rootPropertyValue that was passed in. */
		1494	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue;
		1495	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1496	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1497	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Inject the hook's value into its root property's value. This is used to piece back together the root property
		1498	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { once Velocity has updated one of its individually hooked values through tweening. */
		1499	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { injectValue: function(fullHookName, hookValue, rootPropertyValue) {
		1500	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookData = CSS.Hooks.registered[fullHookName];
		1501
		1502	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookData) {
		1503	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookRoot = hookData[0],
		1504	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookPosition = hookData[1],
		1505	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueParts,
		1506	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueUpdated;
		1507
		1508	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = CSS.Hooks.cleanRootPropertyValue(hookRoot, rootPropertyValue);
		1509
		1510	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Split rootPropertyValue into its individual hook values, replace the targeted value with hookValue,
		1511	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { then reconstruct the rootPropertyValue string. */
		1512	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueParts = rootPropertyValue.toString().match(CSS.RegEx.valueSplit);
		1513	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueParts[hookPosition] = hookValue;
		1514	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueUpdated = rootPropertyValueParts.join(" ");
		1515
		1516	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValueUpdated;
		1517	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1518	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the provided fullHookName isn't a registered hook, return the rootPropertyValue that was passed in. */
		1519	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue;
		1520	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1521	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1522	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1523	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*******************
		1524	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Normalizations
		1525	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *******************/
		1526
		1527	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Normalizations standardize CSS property manipulation by pollyfilling browser-specific implementations (e.g. opacity)
		1528	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and reformatting special properties (e.g. clip, rgba) to look like standard ones. */
		1529	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Normalizations: {
		1530	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Normalizations are passed a normalization target (either the property's name, its extracted value, or its injected value),
		1531	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { the targeted element (which may need to be queried), and the targeted property value. */
		1532	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { registered: {
		1533	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { clip: function(type, element, propertyValue) {
		1534	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { switch (type) {
		1535	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "name":
		1536	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "clip";
		1537	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Clip needs to be unwrapped and stripped of its commas during extraction. */
		1538	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "extract":
		1539	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var extracted;
		1540
		1541	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If Velocity also extracted this value, skip extraction. */
		1542	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.RegEx.wrappedValueAlreadyExtracted.test(propertyValue)) {
		1543	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = propertyValue;
		1544	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1545	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Remove the "rect()" wrapper. */
		1546	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = propertyValue.toString().match(CSS.RegEx.valueUnwrap);
		1547
		1548	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Strip off commas. */
		1549	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = extracted ? extracted[1].replace(/,(\s+)?/g, " ") : propertyValue;
		1550	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1551
		1552	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return extracted;
		1553	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Clip needs to be re-wrapped during injection. */
		1554	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "inject":
		1555	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "rect(" + propertyValue + ")";
		1556	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1557	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1558	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { blur: function(type, element, propertyValue) {
		1559	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { switch (type) {
		1560	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "name":
		1561	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return Velocity.State.isFirefox ? "filter" : "-webkit-filter";
		1562	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "extract":
		1563	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var extracted = parseFloat(propertyValue);
		1564
		1565	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If extracted is NaN, meaning the value isn't already extracted. */
		1566	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!(extracted || extracted === 0)) {
		1567	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var blurComponent = propertyValue.toString().match(/blur\(([0-9]+[A-z]+)\)/i);
		1568
		1569	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the filter string had a blur component, return just the blur value and unit type. */
		1570	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (blurComponent) {
		1571	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = blurComponent[1];
		1572	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the component doesn't exist, default blur to 0. */
		1573	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1574	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = 0;
		1575	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1576	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1577
		1578	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return extracted;
		1579	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Blur needs to be re-wrapped during injection. */
		1580	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "inject":
		1581	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* For the blur effect to be fully de-applied, it needs to be set to "none" instead of 0. */
		1582	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!parseFloat(propertyValue)) {
		1583	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "none";
		1584	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
		1585	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "blur(" + propertyValue + ")";
		1586	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1587	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
		1588	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
		1589	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* <=IE8 do not support the standard opacity property. They use filter:alpha(opacity=INT) instead. */
		1590	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { opacity: function(type, element, propertyValue) {
		1591	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (IE <= 8) {
		1592	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { switch (type) {
		1593	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "name":
		1594	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "filter";
		1595	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "extract":
		1596	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* <=IE8 return a "filter" value of "alpha(opacity=\d{1,3})".
		1597	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { Extract the value and convert it to a decimal value to match the standard CSS opacity property's formatting. */
		1598	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { var extracted = propertyValue.toString().match(/alpha\(opacity=(.*)\)/i);
		1599
		1600	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { if (extracted) {
		1601	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Convert to decimal value. */
		1602	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { propertyValue = extracted[1] / 100;
		1603	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { } else {
		1604	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* When extracting opacity, default to 1 since a null value means opacity hasn't been set. */
		1605	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { propertyValue = 1;
		1606	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1607
		1608	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return propertyValue;
		1609	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "inject":
		1610	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Opacified elements are required to have their zoom property set to a non-zero value. */
		1611	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { element.style.zoom = 1;
		1612
		1613	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Setting the filter property on elements with certain font property combinations can result in a
		1614	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { highly unappealing ultra-bolding effect. There's no way to remedy this throughout a tween, but dropping the
		1615	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { value altogether (when opacity hits 1) at leasts ensures that the glitch is gone post-tweening. */
		1616	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { if (parseFloat(propertyValue) >= 1) {
		1617	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "";
		1618	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { } else {
		1619	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* As per the filter property's spec, convert the decimal value to a whole number and wrap the value. */
		1620	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "alpha(opacity=" + parseInt(parseFloat(propertyValue) * 100, 10) + ")";
		1621	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1622	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1623	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* With all other browsers, normalization is not required; return the same values that were passed in. */
		1624	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { } else {
		1625	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { switch (type) {
		1626	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "name":
		1627	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "opacity";
		1628	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "extract":
		1629	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return propertyValue;
		1630	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "inject":
		1631	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return propertyValue;
		1632	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1633	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1634	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1635	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { },
		1636	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /*****************************
		1637	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { Batched Registrations
		1638	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { *****************************/
		1639
		1640	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Note: Batched normalizations extend the CSS.Normalizations.registered object. */
		1641	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { register: function() {
		1642
		1643	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /*****************
		1644	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { Transforms
		1645	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { *****************/
		1646
		1647	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Transforms are the subproperties contained by the CSS "transform" property. Transforms must undergo normalization
		1648	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { so that they can be referenced in a properties map by their individual names. */
		1649	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Note: When transforms are "set", they are actually assigned to a per-element transformCache. When all transform
		1650	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { setting is complete complete, CSS.flushTransformCache() must be manually called to flush the values to the DOM.
		1651	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { Transform setting is batched in this way to improve performance: the transform style only needs to be updated
		1652	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { once when multiple transform subproperties are being animated simultaneously. */
		1653	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Note: IE9 and Android Gingerbread have support for 2D -- but not 3D -- transforms. Since animating unsupported
		1654	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { transform properties results in the browser ignoring the *entire* transform string, we prevent these 3D values
		1655	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { from being normalized for these browsers so that tweening skips these properties altogether
		1656	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { (since it will ignore them as being unsupported by the browser.) */
		1657	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { if ((!IE || IE > 9) && !Velocity.State.isGingerbread) {
		1658	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Note: Since the standalone CSS "perspective" property and the CSS transform "perspective" subproperty
		1659	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { share the same name, the latter is given a unique token within Velocity: "transformPerspective". */
		1660	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { CSS.Lists.transformsBase = CSS.Lists.transformsBase.concat(CSS.Lists.transforms3D);
		1661	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
		1662
		1663	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { for (var i = 0; i < CSS.Lists.transformsBase.length; i++) {
		1664	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Wrap the dynamically generated normalization function in a new scope so that transformName's value is
		1665	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { paired with its respective function. (Otherwise, all functions would take the final for loop's transformName.) */
		1666	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { (function() {
		1667	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var transformName = CSS.Lists.transformsBase[i];
		1668
		1669	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { CSS.Normalizations.registered[transformName] = function(type, element, propertyValue) {
		1670	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { switch (type) {
		1671	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* The normalized property name is the parent "transform" property -- the property that is actually set in CSS. */
		1672	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "name":
		1673	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return "transform";
		1674	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Transform values are cached onto a per-element transformCache object. */
		1675	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "extract":
		1676	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If this transform has yet to be assigned a value, return its null value. */
		1677	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (Data(element) === undefined || Data(element).transformCache[transformName] === undefined) {
		1678	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Scale CSS.Lists.transformsBase default to 1 whereas all other transform properties default to 0. */
		1679	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return /^scale/i.test(transformName) ? 1 : 0;
		1680	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* When transform values are set, they are wrapped in parentheses as per the CSS spec.
		1681	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { Thus, when extracting their values (for tween calculations), we strip off the parentheses. */
		1682	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1683	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return Data(element).transformCache[transformName].replace(/[()]/g, "");
		1684	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "inject":
		1685	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var invalid = false;
		1686
		1687	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If an individual transform property contains an unsupported unit type, the browser ignores the *entire* transform property.
		1688	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { Thus, protect users from themselves by skipping setting for transform values supplied with invalid unit types. */
		1689	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Switch on the base transform type; ignore the axis by removing the last letter from the transform's name. */
		1690	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { switch (transformName.substr(0, transformName.length - 1)) {
		1691	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Whitelist unit types for each transform. */
		1692	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "translate":
		1693	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(%|px|em|rem|vw|vh|\d)$/i.test(propertyValue);
		1694	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
		1695	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* 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. */
		1696	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "scal":
		1697	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "scale":
		1698	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Chrome on Android has a bug in which scaled elements blur if their initial scale
		1699	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { value is below 1 (which can happen with forcefeeding). Thus, we detect a yet-unset scale property
		1700	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { 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 */
		1701	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (Velocity.State.isAndroid && Data(element).transformCache[transformName] === undefined && propertyValue < 1) {
		1702	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { propertyValue = 1;
		1703	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1704
		1705	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(\d)$/i.test(propertyValue);
		1706	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
		1707	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "skew":
		1708	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(deg|\d)$/i.test(propertyValue);
		1709	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
		1710	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "rotate":
		1711	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(deg|\d)$/i.test(propertyValue);
		1712	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
		1713	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1714
		1715	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (!invalid) {
		1716	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* As per the CSS spec, wrap the value in parentheses. */
		1717	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { Data(element).transformCache[transformName] = "(" + propertyValue + ")";
		1718	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1719
		1720	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Although the value is set on the transformCache object, return the newly-updated value for the calling code to process as normal. */
		1721	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return Data(element).transformCache[transformName];
		1722	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1723	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { };
		1724	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { })();
		1725	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1726
		1727	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /*************
		1728	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { Colors
		1729	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { *************/
		1730
		1731	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Since Velocity only animates a single numeric value per property, color animation is achieved by hooking the individual RGBA components of CSS color properties.
		1732	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { 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. */
		1733	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { for (var j = 0; j < CSS.Lists.colors.length; j++) {
		1734	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Wrap the dynamically generated normalization function in a new scope so that colorName's value is paired with its respective function.
		1735	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { (Otherwise, all functions would take the final for loop's colorName.) */
		1736	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { (function() {
		1737	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var colorName = CSS.Lists.colors[j];
		1738
		1739	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Note: In IE<=8, which support rgb but not rgba, color properties are reverted to rgb by stripping off the alpha component. */
		1740	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { CSS.Normalizations.registered[colorName] = function(type, element, propertyValue) {
		1741	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { switch (type) {
		1742	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "name":
		1743	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return colorName;
		1744	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Convert all color values into the rgb format. (Old IE can return hex values and color names instead of rgb/rgba.) */
		1745	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "extract":
		1746	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var extracted;
		1747
		1748	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If the color is already in its hookable form (e.g. "255 255 255 1") due to having been previously extracted, skip extraction. */
		1749	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (CSS.RegEx.wrappedValueAlreadyExtracted.test(propertyValue)) {
		1750	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { extracted = propertyValue;
		1751	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else {
		1752	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var converted,
		1753	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { colorNames = {
		1754	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { black: "rgb(0, 0, 0)",
		1755	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { blue: "rgb(0, 0, 255)",
		1756	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { gray: "rgb(128, 128, 128)",
		1757	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { green: "rgb(0, 128, 0)",
		1758	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { red: "rgb(255, 0, 0)",
		1759	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { white: "rgb(255, 255, 255)"
		1760	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { };
		1761
		1762	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Convert color names to rgb. */
		1763	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (/^[A-z]+$/i.test(propertyValue)) {
		1764	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (colorNames[propertyValue] !== undefined) {
		1765	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = colorNames[propertyValue];
		1766	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else {
		1767	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If an unmatched color name is provided, default to black. */
		1768	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = colorNames.black;
		1769	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1770	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Convert hex values to rgb. */
		1771	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else if (CSS.RegEx.isHex.test(propertyValue)) {
		1772	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = "rgb(" + CSS.Values.hexToRgb(propertyValue).join(" ") + ")";
		1773	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If the provided color doesn't match any of the accepted color formats, default to black. */
		1774	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else if (!(/^rgba?\(/i.test(propertyValue))) {
		1775	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = colorNames.black;
		1776	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1777
		1778	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Remove the surrounding "rgb/rgba()" string then replace commas with spaces and strip
		1779	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { repeated spaces (in case the value included spaces to begin with). */
		1780	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { extracted = (converted || propertyValue).toString().match(CSS.RegEx.valueUnwrap)[1].replace(/,(\s+)?/g, " ");
		1781	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1782
		1783	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* So long as this isn't <=IE8, add a fourth (alpha) component if it's missing and default it to 1 (visible). */
		1784	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if ((!IE || IE > 8) && extracted.split(" ").length === 3) {
		1785	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { extracted += " 1";
		1786	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1787
		1788	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return extracted;
		1789	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "inject":
		1790	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If we have a pattern then it might already have the right values */
		1791	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (/^rgb/.test(propertyValue)) {
		1792	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return propertyValue;
		1793	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
		1794
		1795	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* If this is IE<=8 and an alpha component exists, strip it off. */
		1796	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (IE <= 8) {
		1797	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (propertyValue.split(" ").length === 4) {
		1798	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { propertyValue = propertyValue.split(/\s+/).slice(0, 3).join(" ");
		1799	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1800	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* Otherwise, add a fourth (alpha) component if it's missing and default it to 1 (visible). */
		1801	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { } else if (propertyValue.split(" ").length === 3) {
		1802	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { propertyValue += " 1";
		1803	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1804
		1805	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* Re-insert the browser-appropriate wrapper("rgb/rgba()"), insert commas, and strip off decimal units
		1806	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { on all values but the fourth (R, G, and B only accept whole numbers). */
		1807	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return (IE <= 8 ? "rgb" : "rgba") + "(" + propertyValue.replace(/\s+/g, ",").replace(/\.(\d)+(?=,)/g, "") + ")";
		1808	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1809	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { };
		1810	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { })();
		1811	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1812
		1813	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /**************
		1814	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { Dimensions
		1815	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { **************/
		1816	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { function augmentDimension(name, element, wantInner) {
		1817	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { var isBorderBox = CSS.getPropertyValue(element, "boxSizing").toString().toLowerCase() === "border-box";
		1818
		1819	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (isBorderBox === (wantInner || false)) {
		1820	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* in box-sizing mode, the CSS width / height accessors already give the outerWidth / outerHeight. */
		1821	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { var i,
		1822	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { value,
		1823	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { augment = 0,
		1824	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { sides = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"],
		1825	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { fields = ["padding" + sides[0], "padding" + sides[1], "border" + sides[0] + "Width", "border" + sides[1] + "Width"];
		1826
		1827	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { for (i = 0; i < fields.length; i++) {
		1828	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { value = parseFloat(CSS.getPropertyValue(element, fields[i]));
		1829	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (!isNaN(value)) {
		1830	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { augment += value;
		1831	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1832	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1833	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return wantInner ? -augment : augment;
		1834	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1835	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return 0;
		1836	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1837	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { function getDimension(name, wantInner) {
		1838	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return function(type, element, propertyValue) {
		1839	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { switch (type) {
		1840	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { case "name":
		1841	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return name;
		1842	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { case "extract":
		1843	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return parseFloat(propertyValue) + augmentDimension(name, element, wantInner);
		1844	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { case "inject":
		1845	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return (parseFloat(propertyValue) - augmentDimension(name, element, wantInner)) + "px";
		1846	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1847	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { };
		1848	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1849	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.innerWidth = getDimension("width", true);
		1850	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.innerHeight = getDimension("height", true);
		1851	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.outerWidth = getDimension("width");
		1852	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.outerHeight = getDimension("height");
		1853	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1854	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { },
		1855	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /************************
		1856	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS Property Names
		1857	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { ************************/
		1858
		1859	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { Names: {
		1860	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* Camelcase a property name into its JavaScript notation (e.g. "background-color" ==> "backgroundColor").
		1861	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { Camelcasing is used to normalize property names between and across calls. */
		1862	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { camelCase: function(property) {
		1863	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return property.replace(/-(\w)/g, function(match, subMatch) {
		1864	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return subMatch.toUpperCase();
		1865	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { });
		1866	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { },
		1867	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* For SVG elements, some properties (namely, dimensional ones) are GET/SET via the element's HTML attributes (instead of via CSS styles). */
		1868	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { SVGAttribute: function(property) {
		1869	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { var SVGAttributes = "width|height|x|y|cx|cy|r|rx|ry|x1|x2|y1|y2";
		1870
		1871	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* Certain browsers require an SVG transform to be applied as an attribute. (Otherwise, application via CSS is preferable due to 3D support.) */
		1872	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (IE || (Velocity.State.isAndroid && !Velocity.State.isChrome)) {
		1873	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { SVGAttributes += "|transform";
		1874	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
		1875
		1876	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return new RegExp("^(" + SVGAttributes + ")$", "i").test(property);
		1877	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { },
		1878	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* Determine whether a property should be set with a vendor prefix. */
		1879	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* If a prefixed version of the property exists, return it. Otherwise, return the original property name.
		1880	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { If the property is not at all supported by the browser, return a false flag. */
		1881	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { prefixCheck: function(property) {
		1882	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /* If this property has already been checked, return the cached value. */
		1883	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (Velocity.State.prefixMatches[property]) {
		1884	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return [Velocity.State.prefixMatches[property], true];
		1885	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { } else {
		1886	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { var vendors = ["", "Webkit", "Moz", "ms", "O"];
		1887
		1888	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { for (var i = 0, vendorsLength = vendors.length; i < vendorsLength; i++) {
		1889	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyPrefixed;
		1890
		1891	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (i === 0) {
		1892	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyPrefixed = property;
		1893	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		1894	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Capitalize the first letter of the property to conform to JavaScript vendor prefix notation (e.g. webkitFilter). */
		1895	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyPrefixed = vendors[i] + property.replace(/^\w/, function(match) {
		1896	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return match.toUpperCase();
		1897	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		1898	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1899
		1900	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Check if the browser supports this property as prefixed. */
		1901	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isString(Velocity.State.prefixElement.style[propertyPrefixed])) {
		1902	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Cache the match. */
		1903	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.prefixMatches[property] = propertyPrefixed;
		1904
		1905	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [propertyPrefixed, true];
		1906	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1907	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1908
		1909	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the browser doesn't support this property in any form, include a false flag so that the caller can decide how to proceed. */
		1910	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [property, false];
		1911	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1912	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1913	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		1914	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
		1915	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS Property Values
		1916	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
		1917
		1918	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Values: {
		1919	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Hex to RGB conversion. Copyright Tim Down: http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb */
		1920	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hexToRgb: function(hex) {
		1921	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var shortformRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i,
		1922	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { longformRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i,
		1923	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rgbParts;
		1924
		1925	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hex = hex.replace(shortformRegex, function(m, r, g, b) {
		1926	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return r + r + g + g + b + b;
		1927	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		1928
		1929	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rgbParts = longformRegex.exec(hex);
		1930
		1931	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return rgbParts ? [parseInt(rgbParts[1], 16), parseInt(rgbParts[2], 16), parseInt(rgbParts[3], 16)] : [0, 0, 0];
		1932	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		1933	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isCSSNullValue: function(value) {
		1934	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The browser defaults CSS values that have not been set to either 0 or one of several possible null-value strings.
		1935	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Thus, we check for both falsiness and these special strings. */
		1936	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Null-value checking is performed to default the special strings to 0 (for the sake of tweening) or their hook
		1937	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { templates as defined as CSS.Hooks (for the sake of hook injection/extraction). */
		1938	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Chrome returns "rgba(0, 0, 0, 0)" for an undefined color whereas IE returns "transparent". */
		1939	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return (!value || /^(none|auto|transparent|(rgba\(0, ?0, ?0, ?0\)))$/i.test(value));
		1940	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		1941	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Retrieve a property's default unit type. Used for assigning a unit type when one is not supplied by the user. */
		1942	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { getUnitType: function(property) {
		1943	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^(rotate|skew)/i.test(property)) {
		1944	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "deg";
		1945	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/(^(scale|scaleX|scaleY|scaleZ|alpha|flexGrow|flexHeight|zIndex|fontWeight)$)|((opacity|red|green|blue|alpha)$)/i.test(property)) {
		1946	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The above properties are unitless. */
		1947	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "";
		1948	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		1949	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Default to px for all other properties. */
		1950	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "px";
		1951	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1952	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		1953	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* HTML elements default to an associated display type when they're not set to display:none. */
		1954	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: This function is used for correctly setting the non-"none" display value in certain Velocity redirects, such as fadeIn/Out. */
		1955	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { getDisplayType: function(element) {
		1956	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var tagName = element && element.tagName.toString().toLowerCase();
		1957
		1958	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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)) {
		1959	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "inline";
		1960	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^(li)$/i.test(tagName)) {
		1961	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "list-item";
		1962	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^(tr)$/i.test(tagName)) {
		1963	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "table-row";
		1964	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^(table)$/i.test(tagName)) {
		1965	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "table";
		1966	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^(tbody)$/i.test(tagName)) {
		1967	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "table-row-group";
		1968	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Default to "block" when no match is found. */
		1969	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		1970	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "block";
		1971	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1972	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		1973	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The class add/remove functions are used to temporarily apply a "velocity-animating" class to elements while they're animating. */
		1974	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { addClass: function(element, className) {
		1975	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element) {
		1976	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element.classList) {
		1977	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.classList.add(className);
		1978	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (Type.isString(element.className)) {
		1979	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Element.className is around 15% faster then set/getAttribute
		1980	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.className += (element.className.length ? " " : "") + className;
		1981	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		1982	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Work around for IE strict mode animating SVG - and anything else that doesn't behave correctly - the same way jQuery does it
		1983	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var currentClass = element.getAttribute(IE <= 7 ? "className" : "class") || "";
		1984
		1985	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.setAttribute("class", currentClass + (currentClass ? " " : "") + className);
		1986	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1987	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		1988	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		1989	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { removeClass: function(element, className) {
		1990	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element) {
		1991	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element.classList) {
		1992	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.classList.remove(className);
		1993	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (Type.isString(element.className)) {
		1994	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Element.className is around 15% faster then set/getAttribute
		1995	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // TODO: Need some jsperf tests on performance - can we get rid of the regex and maybe use split / array manipulation?
		1996	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.className = element.className.toString().replace(new RegExp("(^|\\s)" + className.split(" ").join("|") + "(\\s|$)", "gi"), " ");
		1997	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		1998	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Work around for IE strict mode animating SVG - and anything else that doesn't behave correctly - the same way jQuery does it
		1999	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var currentClass = element.getAttribute(IE <= 7 ? "className" : "class") || "";
		2000
		2001	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.setAttribute("class", currentClass.replace(new RegExp("(^|\s)" + className.split(" ").join("|") + "(\s|$)", "gi"), " "));
		2002	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2003	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2004	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2005	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		2006	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /****************************
		2007	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Style Getting & Setting
		2008	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ****************************/
		2009
		2010	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The singular getPropertyValue, which routes the logic for all normalizations, hooks, and standard CSS properties. */
		2011	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { getPropertyValue: function(element, property, rootPropertyValue, forceStyleLookup) {
		2012	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Get an element's computed property value. */
		2013	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Retrieving the value of a CSS property cannot simply be performed by checking an element's
		2014	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { style attribute (which only reflects user-defined values). Instead, the browser must be queried for a property's
		2015	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *computed* value. You can read more about getComputedStyle here: https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle */
		2016	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function computePropertyValue(element, property) {
		2017	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When box-sizing isn't set to border-box, height and width style values are incorrectly computed when an
		2018	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element's scrollbars are visible (which expands the element's dimensions). Thus, we defer to the more accurate
		2019	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { offsetHeight/Width property, which includes the total dimensions for interior, border, padding, and scrollbar.
		2020	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { We subtract border and padding to get the sum of interior + scrollbar. */
		2021	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var computedValue = 0;
		2022
		2023	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* IE<=8 doesn't support window.getComputedStyle, thus we defer to jQuery, which has an extensive array
		2024	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { of hacks to accurately retrieve IE8 property values. Re-implementing that logic here is not worth bloating the
		2025	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { codebase for a dying browser. The performance repercussions of using jQuery here are minimal since
		2026	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity is optimized to rarely (and sometimes never) query the DOM. Further, the $.css() codepath isn't that slow. */
		2027	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE <= 8) {
		2028	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = $.css(element, property); /* GET */
		2029	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* All other browsers support getComputedStyle. The returned live object reference is cached onto its
		2030	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { associated element so that it does not need to be refetched upon every GET. */
		2031	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2032	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Browsers do not return height and width values for elements that are set to display:"none". Thus, we temporarily
		2033	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { toggle display to the element type's default value. */
		2034	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var toggleDisplay = false;
		2035
		2036	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^(width|height)$/.test(property) && CSS.getPropertyValue(element, "display") === 0) {
		2037	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { toggleDisplay = true;
		2038	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.setPropertyValue(element, "display", CSS.Values.getDisplayType(element));
		2039	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2040
		2041	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var revertDisplay = function() {
		2042	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (toggleDisplay) {
		2043	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.setPropertyValue(element, "display", "none");
		2044	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2045	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2046
		2047	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!forceStyleLookup) {
		2048	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (property === "height" && CSS.getPropertyValue(element, "boxSizing").toString().toLowerCase() !== "border-box") {
		2049	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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);
		2050	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revertDisplay();
		2051
		2052	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return contentBoxHeight;
		2053	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (property === "width" && CSS.getPropertyValue(element, "boxSizing").toString().toLowerCase() !== "border-box") {
		2054	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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);
		2055	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revertDisplay();
		2056
		2057	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return contentBoxWidth;
		2058	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2059	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2060
		2061	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var computedStyle;
		2062
		2063	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For elements that Velocity hasn't been called on directly (e.g. when Velocity queries the DOM on behalf
		2064	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { of a parent of an element its animating), perform a direct getComputedStyle lookup since the object isn't cached. */
		2065	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) === undefined) {
		2066	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedStyle = window.getComputedStyle(element, null); /* GET */
		2067	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the computedStyle object has yet to be cached, do so now. */
		2068	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (!Data(element).computedStyle) {
		2069	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedStyle = Data(element).computedStyle = window.getComputedStyle(element, null); /* GET */
		2070	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If computedStyle is cached, use it. */
		2071	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2072	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedStyle = Data(element).computedStyle;
		2073	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2074
		2075	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* IE and Firefox do not return a value for the generic borderColor -- they only return individual values for each border side's color.
		2076	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Also, in all browsers, when border colors aren't all the same, a compound value is returned that Velocity isn't setup to parse.
		2077	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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. */
		2078	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (property === "borderColor") {
		2079	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { property = "borderTopColor";
		2080	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2081
		2082	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* IE9 has a bug in which the "filter" property must be accessed from computedStyle using the getPropertyValue method
		2083	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { instead of a direct property lookup. The getPropertyValue method is slower than a direct lookup, which is why we avoid it by default. */
		2084	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE === 9 && property === "filter") {
		2085	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = computedStyle.getPropertyValue(property); /* GET */
		2086	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2087	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = computedStyle[property];
		2088	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2089
		2090	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Fall back to the property's style value (if defined) when computedValue returns nothing,
		2091	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { which can happen when the element hasn't been painted. */
		2092	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (computedValue === "" || computedValue === null) {
		2093	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = element.style[property];
		2094	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2095
		2096	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revertDisplay();
		2097	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2098
		2099	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For top, right, bottom, and left (TRBL) values that are set to "auto" on elements of "fixed" or "absolute" position,
		2100	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { defer to jQuery for converting "auto" to a numeric value. (For elements with a "static" or "relative" position, "auto" has the same
		2101	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { effect as being set to 0, so no conversion is necessary.) */
		2102	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* An example of why numeric conversion is necessary: When an element with "position:absolute" has an untouched "left"
		2103	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { property, which reverts to "auto", left's value is 0 relative to its parent element, but is often non-zero relative
		2104	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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"). */
		2105	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (computedValue === "auto" && /^(top|right|bottom|left)$/i.test(property)) {
		2106	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var position = computePropertyValue(element, "position"); /* GET */
		2107
		2108	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For absolute positioning, jQuery's $.position() only returns values for top and left;
		2109	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { right and bottom will have their "auto" value reverted to 0. */
		2110	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: A jQuery object must be created here since jQuery doesn't have a low-level alias for $.position().
		2111	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Not a big deal since we're currently in a GET batch anyway. */
		2112	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (position === "fixed" || (position === "absolute" && /top|left/i.test(property))) {
		2113	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: jQuery strips the pixel unit from its returned values; we re-add it here to conform with computePropertyValue's behavior. */
		2114	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = $(element).position()[property] + "px"; /* GET */
		2115	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2116	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2117
		2118	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return computedValue;
		2119	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2120
		2121	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyValue;
		2122
		2123	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If this is a hooked property (e.g. "clipLeft" instead of the root property of "clip"),
		2124	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { extract the hook's value from a normalized rootPropertyValue using CSS.Hooks.extractValue(). */
		2125	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Hooks.registered[property]) {
		2126	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var hook = property,
		2127	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hookRoot = CSS.Hooks.getRoot(hook);
		2128
		2129	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If a cached rootPropertyValue wasn't passed in (which Velocity always attempts to do in order to avoid requerying the DOM),
		2130	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { query the DOM for the root property's value. */
		2131	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (rootPropertyValue === undefined) {
		2132	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since the browser is now being directly queried, use the official post-prefixing property name for this lookup. */
		2133	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = CSS.getPropertyValue(element, CSS.Names.prefixCheck(hookRoot)[0]); /* GET */
		2134	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2135
		2136	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If this root has a normalization registered, peform the associated normalization extraction. */
		2137	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Normalizations.registered[hookRoot]) {
		2138	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = CSS.Normalizations.registered[hookRoot]("extract", element, rootPropertyValue);
		2139	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2140
		2141	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Extract the hook's value. */
		2142	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = CSS.Hooks.extractValue(hook, rootPropertyValue);
		2143
		2144	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If this is a normalized property (e.g. "opacity" becomes "filter" in <=IE8) or "translateX" becomes "transform"),
		2145	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { normalize the property's name and value, and handle the special case of transforms. */
		2146	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Normalizing a property is mutually exclusive from hooking a property since hook-extracted values are strictly
		2147	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { numerical and therefore do not require normalization extraction. */
		2148	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (CSS.Normalizations.registered[property]) {
		2149	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var normalizedPropertyName,
		2150	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { normalizedPropertyValue;
		2151
		2152	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { normalizedPropertyName = CSS.Normalizations.registered[property]("name", element);
		2153
		2154	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Transform values are calculated via normalization extraction (see below), which checks against the element's transformCache.
		2155	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { At no point do transform GETs ever actually query the DOM; initial stylesheet values are never processed.
		2156	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { This is because parsing 3D transform matrices is not always accurate and would bloat our codebase;
		2157	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { thus, normalization extraction defaults initial transform values to their zero-values (e.g. 1 for scaleX and 0 for translateX). */
		2158	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (normalizedPropertyName !== "transform") {
		2159	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { normalizedPropertyValue = computePropertyValue(element, CSS.Names.prefixCheck(normalizedPropertyName)[0]); /* GET */
		2160
		2161	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		2162	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Values.isCSSNullValue(normalizedPropertyValue) && CSS.Hooks.templates[property]) {
		2163	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { normalizedPropertyValue = CSS.Hooks.templates[property][1];
		2164	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2165	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2166
		2167	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = CSS.Normalizations.registered[property]("extract", element, normalizedPropertyValue);
		2168	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2169
		2170	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If a (numeric) value wasn't produced via hook extraction or normalization, query the DOM. */
		2171	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!/^[\d-]/.test(propertyValue)) {
		2172	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For SVG elements, dimensional properties (which SVGAttribute() detects) are tweened via
		2173	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { their HTML attribute values instead of their CSS style values. */
		2174	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data = Data(element);
		2175
		2176	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data && data.isSVG && CSS.Names.SVGAttribute(property)) {
		2177	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since the height/width attribute values must be set manually, they don't reflect computed values.
		2178	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Thus, we use use getBBox() to ensure we always get values for elements with undefined height/width attributes. */
		2179	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^(height|width)$/i.test(property)) {
		2180	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Firefox throws an error if .getBBox() is called on an SVG that isn't attached to the DOM. */
		2181	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { try {
		2182	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = element.getBBox()[property];
		2183	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } catch (error) {
		2184	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = 0;
		2185	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2186	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Otherwise, access the attribute value directly. */
		2187	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2188	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = element.getAttribute(property);
		2189	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2190	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2191	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = computePropertyValue(element, CSS.Names.prefixCheck(property)[0]); /* GET */
		2192	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2193	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2194
		2195	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since property lookups are for animation purposes (which entails computing the numeric delta between start and end values),
		2196	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { convert CSS null-values to an integer of value 0. */
		2197	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Values.isCSSNullValue(propertyValue)) {
		2198	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = 0;
		2199	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2200
		2201	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug >= 2) {
		2202	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Get " + property + ": " + propertyValue);
		2203	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2204
		2205	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return propertyValue;
		2206	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		2207	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The singular setPropertyValue, which routes the logic for all normalizations, hooks, and standard CSS properties. */
		2208	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { setPropertyValue: function(element, property, propertyValue, rootPropertyValue, scrollData) {
		2209	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyName = property;
		2210
		2211	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		2212	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (property === "scroll") {
		2213	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If a container option is present, scroll the container instead of the browser window. */
		2214	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (scrollData.container) {
		2215	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollData.container["scroll" + scrollData.direction] = propertyValue;
		2216	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Otherwise, Velocity defaults to scrolling the browser window. */
		2217	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2218	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (scrollData.direction === "Left") {
		2219	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { window.scrollTo(propertyValue, scrollData.alternateValue);
		2220	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2221	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { window.scrollTo(scrollData.alternateValue, propertyValue);
		2222	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2223	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2224	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2225	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Transforms (translateX, rotateZ, etc.) are applied to a per-element transformCache object, which is manually flushed via flushTransformCache().
		2226	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Thus, for now, we merely cache transforms being SET. */
		2227	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Normalizations.registered[property] && CSS.Normalizations.registered[property]("name", element) === "transform") {
		2228	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Perform a normalization injection. */
		2229	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The normalization logic handles the transformCache updating. */
		2230	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.Normalizations.registered[property]("inject", element, propertyValue);
		2231
		2232	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyName = "transform";
		2233	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = Data(element).transformCache[property];
		2234	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2235	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inject hooks. */
		2236	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Hooks.registered[property]) {
		2237	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var hookName = property,
		2238	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hookRoot = CSS.Hooks.getRoot(property);
		2239
		2240	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If a cached rootPropertyValue was not provided, query the DOM for the hookRoot's current value. */
		2241	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = rootPropertyValue || CSS.getPropertyValue(element, hookRoot); /* GET */
		2242
		2243	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = CSS.Hooks.injectValue(hookName, propertyValue, rootPropertyValue);
		2244	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { property = hookRoot;
		2245	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2246
		2247	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Normalize names and values. */
		2248	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Normalizations.registered[property]) {
		2249	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = CSS.Normalizations.registered[property]("inject", element, propertyValue);
		2250	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { property = CSS.Normalizations.registered[property]("name", element);
		2251	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2252
		2253	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Assign the appropriate vendor prefix before performing an official style update. */
		2254	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyName = CSS.Names.prefixCheck(property)[0];
		2255
		2256	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* A try/catch is used for IE<=8, which throws an error when "invalid" CSS values are set, e.g. a negative width.
		2257	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Try/catch is avoided for other browsers since it incurs a performance overhead. */
		2258	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE <= 8) {
		2259	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { try {
		2260	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.style[propertyName] = propertyValue;
		2261	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } catch (error) {
		2262	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		2263	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Browser does not support [" + propertyValue + "] for [" + propertyName + "]");
		2264	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2265	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2266	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* SVG elements have their dimensional properties (width, height, x, y, cx, etc.) applied directly as attributes instead of as styles. */
		2267	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: IE8 does not support SVG elements, so it's okay that we skip it for SVG animation. */
		2268	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2269	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data = Data(element);
		2270
		2271	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data && data.isSVG && CSS.Names.SVGAttribute(property)) {
		2272	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: For SVG attributes, vendor-prefixed property names are never used. */
		2273	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Not all CSS properties can be animated via attributes, but the browser won't throw an error for unsupported properties. */
		2274	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.setAttribute(property, propertyValue);
		2275	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2276	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.style[propertyName] = propertyValue;
		2277	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2278	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2279
		2280	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug >= 2) {
		2281	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Set " + property + " (" + propertyName + "): " + propertyValue);
		2282	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2283	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2284	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2285
		2286	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		2287	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [propertyName, propertyValue];
		2288	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		2289	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* To increase performance by batching transform updates into a single SET, transforms are not directly applied to an element until flushTransformCache() is called. */
		2290	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Velocity applies transform properties in the same order that they are chronogically introduced to the element's CSS styles. */
		2291	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { flushTransformCache: function(element) {
		2292	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var transformString = "",
		2293	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
		2294
		2295	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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
		2296	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (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). */
		2297	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if ((IE || (Velocity.State.isAndroid && !Velocity.State.isChrome)) && data && data.isSVG) {
		2298	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since transform values are stored in their parentheses-wrapped form, we use a helper function to strip out their numeric values.
		2299	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Further, SVG transform properties only take unitless (representing pixels) values, so it's okay that parseFloat() strips the unit suffixed to the float value. */
		2300	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var getTransformFloat = function(transformProperty) {
		2301	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return parseFloat(CSS.getPropertyValue(element, transformProperty));
		2302	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2303
		2304	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Create an object to organize all the transforms that we'll apply to the SVG element. To keep the logic simple,
		2305	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { we process *all* transform properties -- even those that may not be explicitly applied (since they default to their zero-values anyway). */
		2306	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var SVGTransforms = {
		2307	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { translate: [getTransformFloat("translateX"), getTransformFloat("translateY")],
		2308	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { skewX: [getTransformFloat("skewX")], skewY: [getTransformFloat("skewY")],
		2309	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the scale property is set (non-1), use that value for the scaleX and scaleY values
		2310	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (this behavior mimics the result of animating all these properties at once on HTML elements). */
		2311	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scale: getTransformFloat("scale") !== 1 ? [getTransformFloat("scale"), getTransformFloat("scale")] : [getTransformFloat("scaleX"), getTransformFloat("scaleY")],
		2312	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: SVG's rotate transform takes three values: rotation degrees followed by the X and Y values
		2313	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { defining the rotation's origin point. We ignore the origin values (default them to 0). */
		2314	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rotate: [getTransformFloat("rotateZ"), 0, 0]
		2315	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2316
		2317	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the transform properties in the user-defined property map order.
		2318	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (This mimics the behavior of non-SVG transform animation.) */
		2319	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(Data(element).transformCache, function(transformName) {
		2320	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Except for with skewX/Y, revert the axis-specific transform subproperties to their axis-free master
		2321	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { properties so that they match up with SVG's accepted transform properties. */
		2322	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^translate/i.test(transformName)) {
		2323	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "translate";
		2324	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^scale/i.test(transformName)) {
		2325	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "scale";
		2326	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^rotate/i.test(transformName)) {
		2327	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "rotate";
		2328	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2329
		2330	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Check that we haven't yet deleted the property from the SVGTransforms container. */
		2331	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (SVGTransforms[transformName]) {
		2332	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Append the transform property in the SVG-supported transform format. As per the spec, surround the space-delimited values in parentheses. */
		2333	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformString += transformName + "(" + SVGTransforms[transformName].join(" ") + ")" + " ";
		2334
		2335	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* After processing an SVG transform property, delete it from the SVGTransforms container so we don't
		2336	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { re-insert the same master property if we encounter another one of its axis-specific properties. */
		2337	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete SVGTransforms[transformName];
		2338	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2339	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2340	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2341	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var transformValue,
		2342	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { perspective;
		2343
		2344	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Transform properties are stored as members of the transformCache object. Concatenate all the members into a string. */
		2345	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(Data(element).transformCache, function(transformName) {
		2346	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformValue = Data(element).transformCache[transformName];
		2347
		2348	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Transform's perspective subproperty must be set first in order to take effect. Store it temporarily. */
		2349	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (transformName === "transformPerspective") {
		2350	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { perspective = transformValue;
		2351	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
		2352	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2353
		2354	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* IE9 only supports one rotation type, rotateZ, which it refers to as "rotate". */
		2355	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE === 9 && transformName === "rotateZ") {
		2356	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "rotate";
		2357	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2358
		2359	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformString += transformName + transformValue + " ";
		2360	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2361
		2362	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If present, set the perspective subproperty first. */
		2363	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (perspective) {
		2364	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformString = "perspective" + perspective + " " + transformString;
		2365	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2366	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2367
		2368	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.setPropertyValue(element, "transform", transformString);
		2369	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2370	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2371
		2372	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Register hooks and normalizations. */
		2373	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.Hooks.register();
		2374	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.Normalizations.register();
		2375
		2376	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Allow hook setting in the same fashion as jQuery's $.css(). */
		2377	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.hook = function(elements, arg2, arg3) {
		2378	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var value;
		2379
		2380	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = sanitizeElements(elements);
		2381
		2382	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
		2383	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Initialize Velocity's per-element data cache if this element hasn't previously been animated. */
		2384	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) === undefined) {
		2385	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.init(element);
		2386	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2387
		2388	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Get property value. If an element set was passed in, only return the value for the first element. */
		2389	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (arg3 === undefined) {
		2390	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (value === undefined) {
		2391	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { value = CSS.getPropertyValue(element, arg2);
		2392	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2393	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Set property value. */
		2394	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2395	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* sPV returns an array of the normalized propertyName/propertyValue pair used to update the DOM. */
		2396	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var adjustedSet = CSS.setPropertyValue(element, arg2, arg3);
		2397
		2398	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Transform properties don't automatically set. They have to be flushed to the DOM. */
		2399	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (adjustedSet[0] === "transform") {
		2400	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.flushTransformCache(element);
		2401	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2402
		2403	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { value = adjustedSet;
		2404	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2405	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2406
		2407	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return value;
		2408	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2409
		2410	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************
		2411	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Animation
		2412	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************/
		2413
		2414	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var animate = function() {
		2415	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var opts;
		2416
		2417	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
		2418	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call Chain
		2419	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
		2420
		2421	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Logic for determining what to return to the call stack when exiting out of Velocity. */
		2422	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function getChain() {
		2423	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If we are using the utility function, attempt to return this call's promise. If no promise library was detected,
		2424	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default to null instead of returning the targeted elements so that utility function's return value is standardized. */
		2425	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (isUtility) {
		2426	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return promiseData.promise || null;
		2427	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Otherwise, if we're using $.fn, return the jQuery-/Zepto-wrapped element set. */
		2428	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2429	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return elementsWrapped;
		2430	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2431	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2432
		2433	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************
		2434	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Arguments Assignment
		2435	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************/
		2436
		2437	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* To allow for expressive CoffeeScript code, Velocity supports an alternative syntax in which "elements" (or "e"), "properties" (or "p"), and "options" (or "o")
		2438	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { objects are defined on a container object that's passed in as Velocity's sole argument. */
		2439	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Some browsers automatically populate arguments with a "properties" object. We detect it by checking for its default "names" property. */
		2440	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var syntacticSugar = (arguments[0] && (arguments[0].p || (($.isPlainObject(arguments[0].properties) && !arguments[0].properties.names) || Type.isString(arguments[0].properties)))),
		2441	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Whether Velocity was called via the utility function (as opposed to on a jQuery/Zepto object). */
		2442	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isUtility,
		2443	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When Velocity is called via the utility function ($.Velocity()/Velocity()), elements are explicitly
		2444	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { passed in as the first parameter. Thus, argument positioning varies. We normalize them here. */
		2445	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsWrapped,
		2446	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { argumentIndex;
		2447
		2448	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var elements,
		2449	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertiesMap,
		2450	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options;
		2451
		2452	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Detect jQuery/Zepto elements being animated via the $.fn method. */
		2453	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isWrapped(this)) {
		2454	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isUtility = false;
		2455
		2456	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { argumentIndex = 0;
		2457	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = this;
		2458	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsWrapped = this;
		2459	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Otherwise, raw elements are being animated via the utility function. */
		2460	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2461	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isUtility = true;
		2462
		2463	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { argumentIndex = 1;
		2464	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = syntacticSugar ? (arguments[0].elements || arguments[0].e) : arguments[0];
		2465	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2466
		2467	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************
		2468	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Promises
		2469	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************/
		2470
		2471	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var promiseData = {
		2472	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promise: null,
		2473	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { resolver: null,
		2474	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rejecter: null
		2475	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2476
		2477	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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
		2478	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promise support was detected, create a promise object for this call and store references to its resolver and rejecter methods. The resolve
		2479	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { method is used when a call completes naturally or is prematurely stopped by the user. In both cases, completeCall() handles the associated
		2480	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { call cleanup and promise resolving logic. The reject method is used when an invalid set of arguments is passed into a Velocity call. */
		2481	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Velocity employs a call-based queueing architecture, which means that stopping an animating element actually stops the full call that
		2482	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { triggered it -- not that one element exclusively. Similarly, there is one promise per call, and all elements targeted by a Velocity call are
		2483	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { grouped together for the purposes of resolving and rejecting a promise. */
		2484	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (isUtility && Velocity.Promise) {
		2485	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.promise = new Velocity.Promise(function(resolve, reject) {
		2486	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver = resolve;
		2487	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.rejecter = reject;
		2488	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2489	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2490
		2491	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (syntacticSugar) {
		2492	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertiesMap = arguments[0].properties || arguments[0].p;
		2493	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options = arguments[0].options || arguments[0].o;
		2494	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2495	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertiesMap = arguments[argumentIndex];
		2496	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options = arguments[argumentIndex + 1];
		2497	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2498
		2499	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = sanitizeElements(elements);
		2500
		2501	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!elements) {
		2502	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
		2503	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!propertiesMap || !options || options.promiseRejectEmpty !== false) {
		2504	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.rejecter();
		2505	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2506	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver();
		2507	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2508	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2509	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
		2510	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2511
		2512	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The length of the element set (in the form of a nodeList or an array of elements) is defaulted to 1 in case a
		2513	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { single raw DOM element is passed in (which doesn't contain a length property). */
		2514	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var elementsLength = elements.length,
		2515	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsIndex = 0;
		2516
		2517	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
		2518	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Argument Overloading
		2519	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
		2520
		2521	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Support is included for jQuery's argument overloading: $.animate(propertyMap [, duration] [, easing] [, complete]).
		2522	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Overloading is detected by checking for the absence of an object being passed into options. */
		2523	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The stop/finish/pause/resume actions do not accept animation options, and are therefore excluded from this check. */
		2524	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!/^(stop|finish|finishAll|pause|resume)$/i.test(propertiesMap) && !$.isPlainObject(options)) {
		2525	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The utility function shifts all arguments one position to the right, so we adjust for that offset. */
		2526	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var startingArgumentPosition = argumentIndex + 1;
		2527
		2528	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options = {};
		2529
		2530	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through all options arguments */
		2531	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var i = startingArgumentPosition; i < arguments.length; i++) {
		2532	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Treat a number as a duration. Parse it out. */
		2533	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The following RegEx will return true if passed an array with a number as its first item.
		2534	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Thus, arrays are skipped from this check. */
		2535	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!Type.isArray(arguments[i]) && (/^(fast|normal|slow)$/i.test(arguments[i]) || /^\d/.test(arguments[i]))) {
		2536	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options.duration = arguments[i];
		2537	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Treat strings and arrays as easings. */
		2538	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (Type.isString(arguments[i]) || Type.isArray(arguments[i])) {
		2539	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options.easing = arguments[i];
		2540	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Treat a function as a complete callback. */
		2541	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (Type.isFunction(arguments[i])) {
		2542	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options.complete = arguments[i];
		2543	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2544	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2545	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2546
		2547	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
		2548	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action Detection
		2549	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
		2550
		2551	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Velocity's behavior is categorized into "actions": Elements can either be specially scrolled into view,
		2552	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { or they can be started, stopped, paused, resumed, or reversed . If a literal or referenced properties map is passed in as Velocity's
		2553	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { first argument, the associated action is "start". Alternatively, "scroll", "reverse", "pause", "resume" or "stop" can be passed in
		2554	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { instead of a properties map. */
		2555	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var action;
		2556
		2557	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (propertiesMap) {
		2558	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "scroll":
		2559	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { action = "scroll";
		2560	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		2561
		2562	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "reverse":
		2563	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { action = "reverse";
		2564	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		2565
		2566	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "pause":
		2567
		2568	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
		2569	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action: Pause
		2570	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
		2571
		2572	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var currentTime = (new Date()).getTime();
		2573
		2574	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle delay timers */
		2575	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
		2576	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pauseDelayOnElement(element, currentTime);
		2577	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2578
		2579	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Pause and Resume are call-wide (not on a per element basis). Thus, calling pause or resume on a
		2580	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { single element will cause any calls that containt tweens for that element to be paused/resumed
		2581	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { as well. */
		2582
		2583	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through all calls and pause any that contain any of our elements */
		2584	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(Velocity.State.calls, function(i, activeCall) {
		2585
		2586	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var found = false;
		2587	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inactive calls are set to false by the logic inside completeCall(). Skip them. */
		2588	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (activeCall) {
		2589	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the active call's targeted elements. */
		2590	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(activeCall[1], function(k, activeElement) {
		2591	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var queueName = (options === undefined) ? "" : options;
		2592
		2593	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (queueName !== true && (activeCall[2].queue !== queueName) && !(options === undefined && activeCall[2].queue === false)) {
		2594	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
		2595	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2596
		2597	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the calls targeted by the stop command. */
		2598	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(l, element) {
		2599	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Check that this call was applied to the target element. */
		2600	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element === activeElement) {
		2601
		2602	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Set call to paused */
		2603	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeCall[5] = {
		2604	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { resume: false
		2605	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2606
		2607	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Once we match an element, we can bounce out to the next call entirely */
		2608	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { found = true;
		2609	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
		2610	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2611	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2612
		2613	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Proceed to check next call if we have already matched */
		2614	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (found) {
		2615	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
		2616	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2617	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2618	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2619
		2620	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2621
		2622	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since pause creates no new tweens, exit out of Velocity. */
		2623	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
		2624
		2625	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "resume":
		2626
		2627	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
		2628	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action: Resume
		2629	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
		2630
		2631	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle delay timers */
		2632	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
		2633	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { resumeDelayOnElement(element, currentTime);
		2634	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2635
		2636	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Pause and Resume are call-wide (not on a per elemnt basis). Thus, calling pause or resume on a
		2637	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { single element will cause any calls that containt tweens for that element to be paused/resumed
		2638	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { as well. */
		2639
		2640	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through all calls and pause any that contain any of our elements */
		2641	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(Velocity.State.calls, function(i, activeCall) {
		2642	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var found = false;
		2643	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inactive calls are set to false by the logic inside completeCall(). Skip them. */
		2644	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (activeCall) {
		2645	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the active call's targeted elements. */
		2646	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(activeCall[1], function(k, activeElement) {
		2647	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var queueName = (options === undefined) ? "" : options;
		2648
		2649	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (queueName !== true && (activeCall[2].queue !== queueName) && !(options === undefined && activeCall[2].queue === false)) {
		2650	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
		2651	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2652
		2653	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Skip any calls that have never been paused */
		2654	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!activeCall[5]) {
		2655	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
		2656	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2657
		2658	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the calls targeted by the stop command. */
		2659	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(l, element) {
		2660	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Check that this call was applied to the target element. */
		2661	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element === activeElement) {
		2662
		2663	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Flag a pause object to be resumed, which will occur during the next tick. In
		2664	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { addition, the pause object will at that time be deleted */
		2665	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeCall[5].resume = true;
		2666
		2667	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Once we match an element, we can bounce out to the next call entirely */
		2668	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { found = true;
		2669	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
		2670	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2671	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2672
		2673	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Proceed to check next call if we have already matched */
		2674	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (found) {
		2675	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
		2676	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2677	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2678	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2679
		2680	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2681
		2682	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since resume creates no new tweens, exit out of Velocity. */
		2683	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
		2684
		2685	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "finish":
		2686	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "finishAll":
		2687	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "stop":
		2688	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
		2689	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action: Stop
		2690	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
		2691
		2692	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clear the currently-active delay on each targeted element. */
		2693	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
		2694	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) && Data(element).delayTimer) {
		2695	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Stop the timer from triggering its cached next() function. */
		2696	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { clearTimeout(Data(element).delayTimer.setTimeout);
		2697
		2698	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Manually call the next() function so that the subsequent queue items can progress. */
		2699	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element).delayTimer.next) {
		2700	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayTimer.next();
		2701	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2702
		2703	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete Data(element).delayTimer;
		2704	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2705
		2706	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If we want to finish everything in the queue, we have to iterate through it
		2707	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { and call each function. This will make them active calls below, which will
		2708	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cause them to be applied via the duration setting. */
		2709	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (propertiesMap === "finishAll" && (options === true || Type.isString(options))) {
		2710	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the items in the element's queue. */
		2711	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each($.queue(element, Type.isString(options) ? options : ""), function(_, item) {
		2712	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The queue array can contain an "inprogress" string, which we skip. */
		2713	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(item)) {
		2714	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { item();
		2715	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2716	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2717
		2718	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clearing the $.queue() array is achieved by resetting it to []. */
		2719	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.queue(element, Type.isString(options) ? options : "", []);
		2720	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2721	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2722
		2723	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callsToStop = [];
		2724
		2725	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When the stop action is triggered, the elements' currently active call is immediately stopped. The active call might have
		2726	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { been applied to multiple elements, in which case all of the call's elements will be stopped. When an element
		2727	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { is stopped, the next item in its animation queue is immediately triggered. */
		2728	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* An additional argument may be passed in to clear an element's remaining queued calls. Either true (which defaults to the "fx" queue)
		2729	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { or a custom queue string can be passed in. */
		2730	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The stop command runs prior to Velocity's Queueing phase since its behavior is intended to take effect *immediately*,
		2731	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { regardless of the element's current queue state. */
		2732
		2733	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through every active call. */
		2734	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(Velocity.State.calls, function(i, activeCall) {
		2735	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inactive calls are set to false by the logic inside completeCall(). Skip them. */
		2736	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (activeCall) {
		2737	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the active call's targeted elements. */
		2738	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(activeCall[1], function(k, activeElement) {
		2739	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If true was passed in as a secondary argument, clear absolutely all calls on this element. Otherwise, only
		2740	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { clear calls associated with the relevant queue. */
		2741	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Call stopping logic works as follows:
		2742	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { - options === true --> stop current default queue calls (and queue:false calls), including remaining queued ones.
		2743	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { - options === undefined --> stop current queue:"" call and all queue:false calls.
		2744	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { - options === false --> stop only queue:false calls.
		2745	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { - options === "custom" --> stop current queue:"custom" call, including remaining queued ones (there is no functionality to only clear the currently-running queue:"custom" call). */
		2746	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var queueName = (options === undefined) ? "" : options;
		2747
		2748	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (queueName !== true && (activeCall[2].queue !== queueName) && !(options === undefined && activeCall[2].queue === false)) {
		2749	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
		2750	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2751
		2752	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the calls targeted by the stop command. */
		2753	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(l, element) {
		2754	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Check that this call was applied to the target element. */
		2755	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element === activeElement) {
		2756	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Optionally clear the remaining queued calls. If we're doing "finishAll" this won't find anything,
		2757	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { due to the queue-clearing above. */
		2758	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (options === true || Type.isString(options)) {
		2759	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through the items in the element's queue. */
		2760	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each($.queue(element, Type.isString(options) ? options : ""), function(_, item) {
		2761	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The queue array can contain an "inprogress" string, which we skip. */
		2762	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(item)) {
		2763	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Pass the item's callback a flag indicating that we want to abort from the queue call.
		2764	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (Specifically, the queue will resolve the call's associated promise then abort.) */
		2765	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { item(null, true);
		2766	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2767	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2768
		2769	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clearing the $.queue() array is achieved by resetting it to []. */
		2770	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.queue(element, Type.isString(options) ? options : "", []);
		2771	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2772
		2773	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (propertiesMap === "stop") {
		2774	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since "reverse" uses cached start values (the previous call's endValues), these values must be
		2775	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { changed to reflect the final value that the elements were actually tweened to. */
		2776	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: If only queue:false animations are currently running on an element, it won't have a tweensContainer
		2777	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { object. Also, queue:false animations can't be reversed. */
		2778	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data = Data(element);
		2779	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data && data.tweensContainer && queueName !== false) {
		2780	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(data.tweensContainer, function(m, activeTween) {
		2781	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeTween.endValue = activeTween.currentValue;
		2782	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2783	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2784
		2785	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callsToStop.push(i);
		2786	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (propertiesMap === "finish" || propertiesMap === "finishAll") {
		2787	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* To get active tweens to finish immediately, we forcefully shorten their durations to 1ms so that
		2788	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { they finish upon the next rAf tick then proceed with normal call completion logic. */
		2789	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeCall[2].duration = 1;
		2790	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2791	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2792	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2793	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2794	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2795	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2796
		2797	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Prematurely call completeCall() on each matched active call. Pass an additional flag for "stop" to indicate
		2798	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { that the complete callback and display:none setting should be skipped since we're completing prematurely. */
		2799	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (propertiesMap === "stop") {
		2800	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(callsToStop, function(i, j) {
		2801	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { completeCall(j, true);
		2802	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2803
		2804	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
		2805	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Immediately resolve the promise associated with this stop call since stop runs synchronously. */
		2806	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver(elements);
		2807	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2808	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2809
		2810	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since we're stopping, and not proceeding with queueing, exit out of Velocity. */
		2811	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
		2812
		2813	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
		2814	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Treat a non-empty plain object as a literal properties map. */
		2815	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if ($.isPlainObject(propertiesMap) && !Type.isEmptyObject(propertiesMap)) {
		2816	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { action = "start";
		2817
		2818	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /****************
		2819	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Redirects
		2820	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ****************/
		2821
		2822	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Check if a string matches a registered redirect (see Redirects above). */
		2823	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (Type.isString(propertiesMap) && Velocity.Redirects[propertiesMap]) {
		2824	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, options);
		2825
		2826	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var durationOriginal = opts.duration,
		2827	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delayOriginal = opts.delay || 0;
		2828
		2829	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the backwards option was passed in, reverse the element set so that elements animate from the last to the first. */
		2830	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.backwards === true) {
		2831	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = $.extend(true, [], elements).reverse();
		2832	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2833
		2834	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Individually trigger the redirect for each element in the set to prevent users from having to handle iteration logic in their redirect. */
		2835	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(elementIndex, element) {
		2836	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the stagger option was passed in, successively delay each element by the stagger value (in ms). Retain the original delay value. */
		2837	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (parseFloat(opts.stagger)) {
		2838	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.delay = delayOriginal + (parseFloat(opts.stagger) * elementIndex);
		2839	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (Type.isFunction(opts.stagger)) {
		2840	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.delay = delayOriginal + opts.stagger.call(element, elementIndex, elementsLength);
		2841	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2842
		2843	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the drag option was passed in, successively increase/decrease (depending on the presense of opts.backwards)
		2844	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the duration of each element's animation, using floors to prevent producing very short durations. */
		2845	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.drag) {
		2846	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Default the duration of UI pack effects (callouts and transitions) to 1000ms instead of the usual default duration of 400ms. */
		2847	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = parseFloat(durationOriginal) || (/^(callout|transition)/.test(propertiesMap) ? 1000 : DURATION_DEFAULT);
		2848
		2849	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For each element, take the greater duration of: A) animation completion percentage relative to the original duration,
		2850	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { B) 75% of the original duration, or C) a 200ms fallback (in case duration is already set to a low value).
		2851	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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. */
		2852	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = Math.max(opts.duration * (opts.backwards ? 1 - elementIndex / elementsLength : (elementIndex + 1) / elementsLength), opts.duration * 0.75, 200);
		2853	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2854
		2855	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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
		2856	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reduce the opts checking logic required inside the redirect. */
		2857	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.Redirects[propertiesMap].call(element, element, opts || {}, elementIndex, elementsLength, elements, promiseData.promise ? promiseData : undefined);
		2858	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2859
		2860	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since the animation logic resides within the redirect's own code, abort the remainder of this call.
		2861	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (The performance overhead up to this point is virtually non-existant.) */
		2862	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The jQuery call chain is kept intact by returning the complete element set. */
		2863	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
		2864	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2865	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var abortError = "Velocity: First argument (" + propertiesMap + ") was not a property map, a known action, or a registered redirect. Aborting.";
		2866
		2867	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
		2868	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.rejecter(new Error(abortError));
		2869	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		2870	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log(abortError);
		2871	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2872
		2873	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
		2874	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2875	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2876
		2877	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
		2878	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call-Wide Variables
		2879	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
		2880
		2881	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* A container for CSS unit conversion ratios (e.g. %, rem, and em ==> px) that is used to cache ratios across all elements
		2882	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { being animated in a single Velocity call. Calculating unit ratios necessitates DOM querying and updating, and is therefore
		2883	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { avoided (via caching) wherever possible. This container is call-wide instead of page-wide to avoid the risk of using stale
		2884	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { conversion metrics across Velocity animations that are not immediately consecutively chained. */
		2885	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callUnitConversionData = {
		2886	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastParent: null,
		2887	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastPosition: null,
		2888	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastFontSize: null,
		2889	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastPercentToPxWidth: null,
		2890	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastPercentToPxHeight: null,
		2891	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastEmToPx: null,
		2892	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { remToPx: null,
		2893	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { vwToPx: null,
		2894	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { vhToPx: null
		2895	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2896
		2897	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* A container for all the ensuing tween data and metadata associated with this call. This container gets pushed to the page-wide
		2898	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.calls array that is processed during animation ticking. */
		2899	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var call = [];
		2900
		2901	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
		2902	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Processing
		2903	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
		2904
		2905	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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):
		2906	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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.
		2907	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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.
		2908	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 3) Pushing: Consolidation of the tween data followed by its push onto the global in-progress calls container.
		2909	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { `elementArrayIndex` allows passing index of the element in the original array to value functions.
		2910	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { If `elementsIndex` were used instead the index would be determined by the elements' per-element queue.
		2911	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { */
		2912	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function processElement(element, elementArrayIndex) {
		2913
		2914	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************
		2915	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Part I: Pre-Queueing
		2916	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************/
		2917
		2918	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
		2919	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element-Wide Variables
		2920	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
		2921
		2922	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var /* The runtime opts object is the extension of the current call's options and Velocity's page-wide option defaults. */
		2923	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, Velocity.defaults, options),
		2924	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* A container for the processed data associated with each property in the propertyMap.
		2925	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (Each property in the map produces its own "tween".) */
		2926	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer = {},
		2927	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementUnitConversionData;
		2928
		2929	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
		2930	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Init
		2931	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
		2932
		2933	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) === undefined) {
		2934	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.init(element);
		2935	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2936
		2937	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
		2938	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Delay
		2939	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
		2940
		2941	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since queue:false doesn't respect the item's existing queue, we avoid injecting its delay here (it's set later on). */
		2942	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Velocity rolls its own delay function since jQuery doesn't have a utility alias for $.fn.delay()
		2943	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (and thus requires jQuery element creation, which we avoid since its overhead includes DOM querying). */
		2944	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (parseFloat(opts.delay) && opts.queue !== false) {
		2945	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.queue(element, opts.queue, function(next) {
		2946	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		2947	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.velocityQueueEntryFlag = true;
		2948
		2949	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The ensuing queue item (which is assigned to the "next" argument that $.queue() automatically passes in) will be triggered after a setTimeout delay.
		2950	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { The setTimeout is stored so that it can be subjected to clearTimeout() if this animation is prematurely stopped via Velocity's "stop" command, and
		2951	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delayBegin/delayTime is used to ensure we can "pause" and "resume" a tween that is still mid-delay. */
		2952
		2953	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Temporarily store delayed elements to facilite access for global pause/resume */
		2954	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callIndex = Velocity.State.delayedElements.count++;
		2955	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[callIndex] = element;
		2956
		2957	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var delayComplete = (function(index) {
		2958	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return function() {
		2959	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clear the temporary element */
		2960	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[index] = false;
		2961
		2962	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Finally, issue the call */
		2963	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { next();
		2964	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2965	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { })(callIndex);
		2966
		2967
		2968	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayBegin = (new Date()).getTime();
		2969	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delay = parseFloat(opts.delay);
		2970	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayTimer = {
		2971	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { setTimeout: setTimeout(next, parseFloat(opts.delay)),
		2972	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { next: delayComplete
		2973	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		2974	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		2975	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2976
		2977	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
		2978	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Duration
		2979	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
		2980
		2981	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Support for jQuery's named durations. */
		2982	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (opts.duration.toString().toLowerCase()) {
		2983	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "fast":
		2984	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = 200;
		2985	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		2986
		2987	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "normal":
		2988	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = DURATION_DEFAULT;
		2989	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		2990
		2991	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "slow":
		2992	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = 600;
		2993	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		2994
		2995	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
		2996	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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). */
		2997	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = parseFloat(opts.duration) || 1;
		2998	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		2999
		3000	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
		3001	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Global Option: Mock
		3002	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
		3003
		3004	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.mock !== false) {
		3005	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* In mock mode, all animations are forced to 1ms so that they occur immediately upon the next rAF tick.
		3006	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Alternatively, a multiplier can be passed in to time remap all delays and durations. */
		3007	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.mock === true) {
		3008	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = opts.delay = 1;
		3009	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3010	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration *= parseFloat(Velocity.mock) || 1;
		3011	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.delay *= parseFloat(Velocity.mock) || 1;
		3012	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3013	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3014
		3015	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
		3016	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Easing
		3017	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
		3018
		3019	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.easing = getEasing(opts.easing, opts.duration);
		3020
		3021	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**********************
		3022	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Callbacks
		3023	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **********************/
		3024
		3025	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Callbacks must functions. Otherwise, default to null. */
		3026	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.begin && !Type.isFunction(opts.begin)) {
		3027	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.begin = null;
		3028	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3029
		3030	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.progress && !Type.isFunction(opts.progress)) {
		3031	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.progress = null;
		3032	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3033
		3034	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.complete && !Type.isFunction(opts.complete)) {
		3035	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.complete = null;
		3036	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3037
		3038	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************************
		3039	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Display & Visibility
		3040	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************************/
		3041
		3042	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Refer to Velocity's documentation (VelocityJS.org/#displayAndVisibility) for a description of the display and visibility options' behavior. */
		3043	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: We strictly check for undefined instead of falsiness because display accepts an empty string value. */
		3044	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.display !== undefined && opts.display !== null) {
		3045	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.display = opts.display.toString().toLowerCase();
		3046
		3047	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Users can pass in a special "auto" value to instruct Velocity to set the element to its default display value. */
		3048	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.display === "auto") {
		3049	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.display = Velocity.CSS.Values.getDisplayType(element);
		3050	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3051	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3052
		3053	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.visibility !== undefined && opts.visibility !== null) {
		3054	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.visibility = opts.visibility.toString().toLowerCase();
		3055	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3056
		3057	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**********************
		3058	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: mobileHA
		3059	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **********************/
		3060
		3061	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When set to true, and if this is a mobile device, mobileHA automatically enables hardware acceleration (via a null transform hack)
		3062	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { on animating elements. HA is removed from the element at the completion of its animation. */
		3063	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3064	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: You can read more about the use of mobileHA in Velocity's documentation: VelocityJS.org/#mobileHA. */
		3065	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.mobileHA = (opts.mobileHA && Velocity.State.isMobile && !Velocity.State.isGingerbread);
		3066
		3067	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***********************
		3068	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Part II: Queueing
		3069	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***********************/
		3070
		3071	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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.
		3072	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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. */
		3073	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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,
		3074	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the call array is pushed to Velocity.State.calls for live processing by the requestAnimationFrame tick. */
		3075	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function buildQueue(next) {
		3076	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data, lastTweensContainer;
		3077
		3078	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
		3079	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Begin
		3080	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
		3081
		3082	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3083	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.begin && elementsIndex === 0) {
		3084	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* We throw callbacks in a setTimeout so that thrown errors don't halt the execution of Velocity itself. */
		3085	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { try {
		3086	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.begin.call(elements, elements);
		3087	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } catch (error) {
		3088	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { setTimeout(function() {
		3089	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { throw error;
		3090	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }, 1);
		3091	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3092	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3093
		3094	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************************************
		3095	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Construction (for Scroll)
		3096	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************************************/
		3097
		3098	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3099	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (action === "scroll") {
		3100	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The scroll action uniquely takes an optional "offset" option -- specified in pixels -- that offsets the targeted scroll position. */
		3101	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var scrollDirection = (/^x$/i.test(opts.axis) ? "Left" : "Top"),
		3102	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollOffset = parseFloat(opts.offset) || 0,
		3103	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrent,
		3104	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrentAlternate,
		3105	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionEnd;
		3106
		3107	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Scroll also uniquely takes an optional "container" option, which indicates the parent element that should be scrolled --
		3108	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { as opposed to the browser window itself. This is useful for scrolling toward an element that's inside an overflowing parent element. */
		3109	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.container) {
		3110	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Ensure that either a jQuery object or a raw DOM element was passed in. */
		3111	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isWrapped(opts.container) || Type.isNode(opts.container)) {
		3112	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Extract the raw DOM element from the jQuery wrapper. */
		3113	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.container = opts.container[0] || opts.container;
		3114	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Unlike other properties in Velocity, the browser's scroll position is never cached since it so frequently changes
		3115	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (due to the user's natural interaction with the page). */
		3116	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrent = opts.container["scroll" + scrollDirection]; /* GET */
		3117
		3118	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* $.position() values are relative to the container's currently viewable area (without taking into account the container's true dimensions
		3119	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { -- say, for example, if the container was not overflowing). Thus, the scroll end value is the sum of the child element's position *and*
		3120	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the scroll container's current scroll position. */
		3121	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionEnd = (scrollPositionCurrent + $(element).position()[scrollDirection.toLowerCase()]) + scrollOffset; /* GET */
		3122	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3123	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3124	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.container = null;
		3125	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3126	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3127	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the window itself is being scrolled -- not a containing element -- perform a live scroll position lookup using
		3128	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the appropriate cached property names (which differ based on browser type). */
		3129	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrent = Velocity.State.scrollAnchor[Velocity.State["scrollProperty" + scrollDirection]]; /* GET */
		3130	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3131	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrentAlternate = Velocity.State.scrollAnchor[Velocity.State["scrollProperty" + (scrollDirection === "Left" ? "Top" : "Left")]]; /* GET */
		3132
		3133	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Unlike $.position(), $.offset() values are relative to the browser window's true dimensions -- not merely its currently viewable area --
		3134	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { and therefore end values do not need to be compounded onto current values. */
		3135	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionEnd = $(element).offset()[scrollDirection.toLowerCase()] + scrollOffset; /* GET */
		3136	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3137
		3138	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since there's only one format that scroll's associated tweensContainer can take, we create it manually. */
		3139	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer = {
		3140	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scroll: {
		3141	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue: false,
		3142	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue: scrollPositionCurrent,
		3143	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { currentValue: scrollPositionCurrent,
		3144	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue: scrollPositionEnd,
		3145	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType: "",
		3146	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing: opts.easing,
		3147	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollData: {
		3148	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { container: opts.container,
		3149	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { direction: scrollDirection,
		3150	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { alternateValue: scrollPositionCurrentAlternate
		3151	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3152	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		3153	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element: element
		3154	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3155
		3156	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		3157	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("tweensContainer (scroll): ", tweensContainer.scroll, element);
		3158	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3159
		3160	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************************************
		3161	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Construction (for Reverse)
		3162	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************************************/
		3163
		3164	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Reverse acts like a "start" action in that a property map is animated toward. The only difference is
		3165	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { that the property map used for reverse is the inverse of the map used in the previous call. Thus, we manipulate
		3166	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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. */
		3167	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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.) */
		3168	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Reverse calls do not need to be consecutively chained onto a currently-animating element in order to operate on cached values;
		3169	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { there is no harm to reverse being called on a potentially stale data cache since reverse's behavior is simply defined
		3170	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { as reverting to the element's values as they were prior to the previous *Velocity* call. */
		3171	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (action === "reverse") {
		3172	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
		3173
		3174	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Abort if there is no prior animation data to reverse to. */
		3175	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!data) {
		3176	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
		3177	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3178
		3179	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!data.tweensContainer) {
		3180	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Dequeue the element so that this queue entry releases itself immediately, allowing subsequent queue entries to run. */
		3181	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.dequeue(element, opts.queue);
		3182
		3183	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
		3184	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3185	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
		3186	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Options Parsing
		3187	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
		3188
		3189	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the element was hidden via the display option in the previous call,
		3190	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revert display to "auto" prior to reversal so that the element is visible again. */
		3191	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data.opts.display === "none") {
		3192	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.display = "auto";
		3193	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3194
		3195	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data.opts.visibility === "hidden") {
		3196	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.visibility = "visible";
		3197	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3198
		3199	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the loop option was set in the previous call, disable it so that "reverse" calls aren't recursively generated.
		3200	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Further, remove the previous call's callback options; typically, users do not want these to be refired. */
		3201	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.loop = false;
		3202	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.begin = null;
		3203	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.complete = null;
		3204
		3205	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since we're extending an opts object that has already been extended with the defaults options object,
		3206	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { we remove non-explicitly-defined properties that are auto-assigned values. */
		3207	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!options.easing) {
		3208	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete opts.easing;
		3209	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3210
		3211	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!options.duration) {
		3212	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete opts.duration;
		3213	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3214
		3215	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The opts object used for reversal is an extension of the options object optionally passed into this
		3216	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverse call plus the options used in the previous Velocity call. */
		3217	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, data.opts, opts);
		3218
		3219	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************************
		3220	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tweens Container Reconstruction
		3221	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************************/
		3222
		3223	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Create a deepy copy (indicated via the true flag) of the previous call's tweensContainer. */
		3224	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer = $.extend(true, {}, data ? data.tweensContainer : null);
		3225
		3226	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Manipulate the previous tweensContainer by replacing its end values and currentValues with its start values. */
		3227	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var lastTween in lastTweensContainer) {
		3228	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* In addition to tween data, tweensContainers contain an element property that we ignore here. */
		3229	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (lastTweensContainer.hasOwnProperty(lastTween) && lastTween !== "element") {
		3230	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var lastStartValue = lastTweensContainer[lastTween].startValue;
		3231
		3232	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer[lastTween].startValue = lastTweensContainer[lastTween].currentValue = lastTweensContainer[lastTween].endValue;
		3233	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer[lastTween].endValue = lastStartValue;
		3234
		3235	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Easing is the only option that embeds into the individual tween data (since it can be defined on a per-property basis).
		3236	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Accordingly, every property's easing value must be updated when an options object is passed in with a reverse call.
		3237	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { The side effect of this extensibility is that all per-property easing values are forcefully reset to the new value. */
		3238	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!Type.isEmptyObject(options)) {
		3239	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer[lastTween].easing = opts.easing;
		3240	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3241
		3242	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		3243	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("reverse tweensContainer (" + lastTween + "): " + JSON.stringify(lastTweensContainer[lastTween]), element);
		3244	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3245	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3246	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3247
		3248	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer = lastTweensContainer;
		3249	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3250
		3251	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************************************
		3252	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Construction (for Start)
		3253	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************************************/
		3254
		3255	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (action === "start") {
		3256
		3257	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************
		3258	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Value Transferring
		3259	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************/
		3260
		3261	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If this queue entry follows a previous Velocity-initiated queue entry *and* if this entry was created
		3262	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { while the element was in the process of being animated by Velocity, then this current call is safe to use
		3263	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the end values from the prior call as its start values. Velocity attempts to perform this value transfer
		3264	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { process whenever possible in order to avoid requerying the DOM. */
		3265	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If values aren't transferred from a prior call and start values were not forcefed by the user (more on this below),
		3266	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { then the DOM is queried for the element's current values as a last resort. */
		3267	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Conversely, animation reversal (and looping) *always* perform inter-call value transfers; they never requery the DOM. */
		3268
		3269	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
		3270
		3271	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The per-element isAnimating flag is used to indicate whether it's safe (i.e. the data isn't stale)
		3272	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { to transfer over end values to use as start values. If it's set to true and there is a previous
		3273	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity call to pull values from, do so. */
		3274	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data && data.tweensContainer && data.isAnimating === true) {
		3275	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer = data.tweensContainer;
		3276	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3277
		3278	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
		3279	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Calculation
		3280	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
		3281
		3282	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* This function parses property data and defaults endValue, easing, and startValue as appropriate. */
		3283	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Property map values can either take the form of 1) a single value representing the end value,
		3284	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { or 2) an array in the form of [ endValue, [, easing] [, startValue] ].
		3285	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { The optional third parameter is a forcefed startValue to be used instead of querying the DOM for
		3286	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the element's current value. Read Velocity's docmentation to learn more about forcefeeding: VelocityJS.org/#forcefeeding */
		3287	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var parsePropertyValue = function(valueData, skipResolvingEasing) {
		3288	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var endValue, easing, startValue;
		3289
		3290	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If we have a function as the main argument then resolve it first, in case it returns an array that needs to be split */
		3291	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(valueData)) {
		3292	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { valueData = valueData.call(element, elementArrayIndex, elementsLength);
		3293	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3294
		3295	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle the array format, which can be structured as one of three potential overloads:
		3296	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { A) [ endValue, easing, startValue ], B) [ endValue, easing ], or C) [ endValue, startValue ] */
		3297	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isArray(valueData)) {
		3298	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* endValue is always the first item in the array. Don't bother validating endValue's value now
		3299	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { since the ensuing property cycling logic does that. */
		3300	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = valueData[0];
		3301
		3302	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Two-item array format: If the second item is a number, function, or hex string, treat it as a
		3303	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { start value since easings can only be non-hex strings or arrays. */
		3304	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if ((!Type.isArray(valueData[1]) && /^[\d-]/.test(valueData[1])) || Type.isFunction(valueData[1]) || CSS.RegEx.isHex.test(valueData[1])) {
		3305	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[1];
		3306	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Two or three-item array: If the second item is a non-hex string easing name or an array, treat it as an easing. */
		3307	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if ((Type.isString(valueData[1]) && !CSS.RegEx.isHex.test(valueData[1]) && Velocity.Easings[valueData[1]]) || Type.isArray(valueData[1])) {
		3308	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = skipResolvingEasing ? valueData[1] : getEasing(valueData[1], opts.duration);
		3309
		3310	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Don't bother validating startValue's value now since the ensuing property cycling logic inherently does that. */
		3311	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[2];
		3312	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3313	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[1] || valueData[2];
		3314	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3315	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle the single-value format. */
		3316	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3317	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = valueData;
		3318	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3319
		3320	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Default to the call's easing if a per-property easing type was not defined. */
		3321	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!skipResolvingEasing) {
		3322	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = easing || opts.easing;
		3323	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3324
		3325	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If functions were passed in as values, pass the function the current element as its context,
		3326	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { plus the element's index and the element set's size as arguments. Then, assign the returned value. */
		3327	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(endValue)) {
		3328	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = endValue.call(element, elementArrayIndex, elementsLength);
		3329	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3330
		3331	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(startValue)) {
		3332	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = startValue.call(element, elementArrayIndex, elementsLength);
		3333	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3334
		3335	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Allow startValue to be left as undefined to indicate to the ensuing code that its value was not forcefed. */
		3336	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [endValue || 0, easing, startValue];
		3337	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3338
		3339	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var fixPropertyValue = function(property, valueData) {
		3340	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3341	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var rootProperty = CSS.Hooks.getRoot(property),
		3342	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = false,
		3343	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Parse out endValue, easing, and startValue from the property's data. */
		3344	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = valueData[0],
		3345	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = valueData[1],
		3346	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[2],
		3347	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern;
		3348
		3349	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
		3350	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Start Value Sourcing
		3351	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
		3352
		3353	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Other than for the dummy tween property, properties that are not supported by the browser (and do not have an associated normalization) will
		3354	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inherently produce no style changes when set, so they are skipped in order to decrease animation tick overhead.
		3355	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Property support is determined via prefixCheck(), which returns a false flag when no supported is detected. */
		3356	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Since SVG elements have some of their properties directly applied as HTML attributes,
		3357	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { there is no way to check for their explicit browser support, and so we skip skip this check for them. */
		3358	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if ((!data || !data.isSVG) && rootProperty !== "tween" && CSS.Names.prefixCheck(rootProperty)[1] === false && CSS.Normalizations.registered[rootProperty] === undefined) {
		3359	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		3360	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Skipping [" + rootProperty + "] due to a lack of browser support.");
		3361	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3362	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
		3363	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3364
		3365	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the display option is being set to a non-"none" (e.g. "block") and opacity (filter on IE<=8) is being
		3366	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { animated to an endValue of non-zero, the user's intention is to fade in from invisible, thus we forcefeed opacity
		3367	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { a startValue of 0 if its startValue hasn't already been sourced by value transferring or prior forcefeeding. */
		3368	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (((opts.display !== undefined && opts.display !== null && opts.display !== "none") || (opts.visibility !== undefined && opts.visibility !== "hidden")) && /opacity|filter/.test(property) && !startValue && endValue !== 0) {
		3369	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = 0;
		3370	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3371
		3372	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If values have been transferred from the previous Velocity call, extract the endValue and rootPropertyValue
		3373	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for all of the current call's properties that were *also* animated in the previous call. */
		3374	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Value transferring can optionally be disabled by the user via the _cacheValues option. */
		3375	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts._cacheValues && lastTweensContainer && lastTweensContainer[property]) {
		3376	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValue === undefined) {
		3377	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = lastTweensContainer[property].endValue + lastTweensContainer[property].unitType;
		3378	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3379
		3380	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The previous call's rootPropertyValue is extracted from the element's data cache since that's the
		3381	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { instance of rootPropertyValue that gets freshly updated by the tweening process, whereas the rootPropertyValue
		3382	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { attached to the incoming lastTweensContainer is equal to the root property's value prior to any tweening. */
		3383	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = data.rootPropertyValueCache[rootProperty];
		3384	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If values were not transferred from a previous Velocity call, query the DOM as needed. */
		3385	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3386	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle hooked properties. */
		3387	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Hooks.registered[property]) {
		3388	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValue === undefined) {
		3389	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = CSS.getPropertyValue(element, rootProperty); /* GET */
		3390	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The following getPropertyValue() call does not actually trigger a DOM query;
		3391	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { getPropertyValue() will extract the hook from rootPropertyValue. */
		3392	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = CSS.getPropertyValue(element, property, rootPropertyValue);
		3393	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If startValue is already defined via forcefeeding, do not query the DOM for the root property's value;
		3394	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { just grab rootProperty's zero-value template from CSS.Hooks. This overwrites the element's actual
		3395	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { root property value (if one is set), but this is acceptable since the primary reason users forcefeed is
		3396	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { to avoid DOM queries, and thus we likewise avoid querying the DOM for the root property's value. */
		3397	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3398	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Grab this hook's zero-value template, e.g. "0px 0px 0px black". */
		3399	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = CSS.Hooks.templates[rootProperty][1];
		3400	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3401	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle non-hooked properties that haven't already been defined via forcefeeding. */
		3402	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (startValue === undefined) {
		3403	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = CSS.getPropertyValue(element, property); /* GET */
		3404	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3405	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3406
		3407	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
		3408	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Value Data Extraction
		3409	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
		3410
		3411	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var separatedValue,
		3412	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType,
		3413	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValueUnitType,
		3414	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { operator = false;
		3415
		3416	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Separates a property value into its numeric value and its unit type. */
		3417	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var separateValue = function(property, value) {
		3418	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var unitType,
		3419	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { numericValue;
		3420
		3421	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { numericValue = (value || "0")
		3422	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { .toString()
		3423	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { .toLowerCase()
		3424	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Match the unit type at the end of the value. */
		3425	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { .replace(/[%A-z]+$/, function(match) {
		3426	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Grab the unit type. */
		3427	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType = match;
		3428
		3429	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Strip the unit type off of value. */
		3430	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "";
		3431	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		3432
		3433	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If no unit type was supplied, assign one that is appropriate for this property (e.g. "deg" for rotateZ or "px" for width). */
		3434	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!unitType) {
		3435	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType = CSS.Values.getUnitType(property);
		3436	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3437
		3438	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [numericValue, unitType];
		3439	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3440
		3441	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValue !== endValue && Type.isString(startValue) && Type.isString(endValue)) {
		3442	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern = "";
		3443	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var iStart = 0, // index in startValue
		3444	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iEnd = 0, // index in endValue
		3445	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart = [], // array of startValue numbers
		3446	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd = [], // array of endValue numbers
		3447	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc = 0, // Keep track of being inside a "calc()" so we don't duplicate it
		3448	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB = 0, // Keep track of being inside an RGB as we can't use fractional values
		3449	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGBA = 0; // Keep track of being inside an RGBA as we must pass fractional for the alpha channel
		3450
		3451	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = CSS.Hooks.fixColors(startValue);
		3452	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = CSS.Hooks.fixColors(endValue);
		3453	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { while (iStart < startValue.length && iEnd < endValue.length) {
		3454	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var cStart = startValue[iStart],
		3455	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cEnd = endValue[iEnd];
		3456
		3457	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/[\d\.-]/.test(cStart) && /[\d\.-]/.test(cEnd)) {
		3458	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var tStart = cStart, // temporary character buffer
		3459	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tEnd = cEnd, // temporary character buffer
		3460	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dotStart = ".", // Make sure we can only ever match a single dot in a decimal
		3461	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dotEnd = "."; // Make sure we can only ever match a single dot in a decimal
		3462
		3463	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { while (++iStart < startValue.length) {
		3464	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cStart = startValue[iStart];
		3465	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (cStart === dotStart) {
		3466	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dotStart = ".."; // Can never match two characters
		3467	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (!/\d/.test(cStart)) {
		3468	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3469	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3470	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tStart += cStart;
		3471	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3472	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { while (++iEnd < endValue.length) {
		3473	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cEnd = endValue[iEnd];
		3474	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (cEnd === dotEnd) {
		3475	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dotEnd = ".."; // Can never match two characters
		3476	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (!/\d/.test(cEnd)) {
		3477	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3478	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3479	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tEnd += cEnd;
		3480	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3481	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var uStart = CSS.Hooks.getUnit(startValue, iStart), // temporary unit type
		3482	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { uEnd = CSS.Hooks.getUnit(endValue, iEnd); // temporary unit type
		3483
		3484	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iStart += uStart.length;
		3485	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iEnd += uEnd.length;
		3486	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (uStart === uEnd) {
		3487	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Same units
		3488	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (tStart === tEnd) {
		3489	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Same numbers, so just copy over
		3490	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += tStart + uStart;
		3491	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3492	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Different numbers, so store them
		3493	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += "{" + aStart.length + (inRGB ? "!" : "") + "}" + uStart;
		3494	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart.push(parseFloat(tStart));
		3495	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd.push(parseFloat(tEnd));
		3496	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3497	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3498	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Different units, so put into a "calc(from + to)" and animate each side to/from zero
		3499	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var nStart = parseFloat(tStart),
		3500	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { nEnd = parseFloat(tEnd);
		3501
		3502	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += (inCalc < 5 ? "calc" : "") + "("
		3503	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { + (nStart ? "{" + aStart.length + (inRGB ? "!" : "") + "}" : "0") + uStart
		3504	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { + " + "
		3505	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { + (nEnd ? "{" + (aStart.length + (nStart ? 1 : 0)) + (inRGB ? "!" : "") + "}" : "0") + uEnd
		3506	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { + ")";
		3507	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (nStart) {
		3508	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart.push(nStart);
		3509	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd.push(0);
		3510	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3511	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (nEnd) {
		3512	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart.push(0);
		3513	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd.push(nEnd);
		3514	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3515	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3516	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (cStart === cEnd) {
		3517	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += cStart;
		3518	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iStart++;
		3519	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iEnd++;
		3520	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Keep track of being inside a calc()
		3521	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (inCalc === 0 && cStart === "c"
		3522	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc === 1 && cStart === "a"
		3523	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc === 2 && cStart === "l"
		3524	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc === 3 && cStart === "c"
		3525	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc >= 4 && cStart === "("
		3526	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ) {
		3527	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc++;
		3528	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if ((inCalc && inCalc < 5)
		3529	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc >= 4 && cStart === ")" && --inCalc < 5) {
		3530	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc = 0;
		3531	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3532	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Keep track of being inside an rgb() / rgba()
		3533	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (inRGB === 0 && cStart === "r"
		3534	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB === 1 && cStart === "g"
		3535	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB === 2 && cStart === "b"
		3536	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB === 3 && cStart === "a"
		3537	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB >= 3 && cStart === "("
		3538	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ) {
		3539	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (inRGB === 3 && cStart === "a") {
		3540	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGBA = 1;
		3541	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3542	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB++;
		3543	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (inRGBA && cStart === ",") {
		3544	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (++inRGBA > 3) {
		3545	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB = inRGBA = 0;
		3546	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3547	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if ((inRGBA && inRGB < (inRGBA ? 5 : 4))
		3548	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB >= (inRGBA ? 4 : 3) && cStart === ")" && --inRGB < (inRGBA ? 5 : 4)) {
		3549	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB = inRGBA = 0;
		3550	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3551	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3552	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc = 0;
		3553	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // TODO: changing units, fixing colours
		3554	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3555	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3556	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3557	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (iStart !== startValue.length || iEnd !== endValue.length) {
		3558	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		3559	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.error("Trying to pattern match mis-matched strings [\"" + endValue + "\", \"" + startValue + "\"]");
		3560	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3561	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern = undefined;
		3562	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3563	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pattern) {
		3564	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (aStart.length) {
		3565	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		3566	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Pattern found \"" + pattern + "\" -> ", aStart, aEnd, "[" + startValue + "," + endValue + "]");
		3567	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3568	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = aStart;
		3569	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = aEnd;
		3570	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = startValueUnitType = "";
		3571	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3572	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern = undefined;
		3573	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3574	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3575	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3576
		3577	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!pattern) {
		3578	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Separate startValue. */
		3579	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { separatedValue = separateValue(property, startValue);
		3580	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = separatedValue[0];
		3581	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValueUnitType = separatedValue[1];
		3582
		3583	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Separate endValue, and extract a value operator (e.g. "+=", "-=") if one exists. */
		3584	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { separatedValue = separateValue(property, endValue);
		3585	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = separatedValue[0].replace(/^([+-\/*])=/, function(match, subMatch) {
		3586	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { operator = subMatch;
		3587
		3588	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Strip the operator off of the value. */
		3589	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "";
		3590	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		3591	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = separatedValue[1];
		3592
		3593	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Parse float values from endValue and startValue. Default to 0 if NaN is returned. */
		3594	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = parseFloat(startValue) || 0;
		3595	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = parseFloat(endValue) || 0;
		3596
		3597	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************************
		3598	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Property-Specific Value Conversion
		3599	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************************/
		3600
		3601	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Custom support for properties that don't actually accept the % unit type, but where pollyfilling is trivial and relatively foolproof. */
		3602	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (endValueUnitType === "%") {
		3603	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* A %-value fontSize/lineHeight is relative to the parent's fontSize (as opposed to the parent's dimensions),
		3604	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { which is identical to the em unit's behavior, so we piggyback off of that. */
		3605	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^(fontSize|lineHeight)$/.test(property)) {
		3606	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Convert % into an em decimal value. */
		3607	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = endValue / 100;
		3608	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = "em";
		3609	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For scaleX and scaleY, convert the value into its decimal format and strip off the unit type. */
		3610	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^scale/.test(property)) {
		3611	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = endValue / 100;
		3612	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = "";
		3613	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For RGB components, take the defined percentage of 255 and strip off the unit type. */
		3614	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/(Red|Green|Blue)$/i.test(property)) {
		3615	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = (endValue / 100) * 255;
		3616	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = "";
		3617	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3618	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3619	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3620
		3621	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
		3622	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Unit Ratio Calculation
		3623	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
		3624
		3625	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When queried, the browser returns (most) CSS property values in pixels. Therefore, if an endValue with a unit type of
		3626	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { %, em, or rem is animated toward, startValue must be converted from pixels into the same unit type as endValue in order
		3627	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for value manipulation logic (increment/decrement) to proceed. Further, if the startValue was forcefed or transferred
		3628	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { from a previous call, startValue may also not be in pixels. Unit conversion logic therefore consists of two steps:
		3629	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 1) Calculating the ratio of %/em/rem/vh/vw relative to pixels
		3630	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 2) Converting startValue into the same unit of measurement as endValue based on these ratios. */
		3631	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Unit conversion ratios are calculated by inserting a sibling node next to the target node, copying over its position property,
		3632	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { setting values with the target unit type then comparing the returned pixel value. */
		3633	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Even if only one of these unit types is being animated, all unit ratios are calculated at once since the overhead
		3634	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { of batching the SETs and GETs together upfront outweights the potential overhead
		3635	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { of layout thrashing caused by re-querying for uncalculated ratios for subsequently-processed properties. */
		3636	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Todo: Shift this logic into the calls' first tick instance so that it's synced with RAF. */
		3637	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var calculateUnitRatios = function() {
		3638
		3639	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
		3640	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Same Ratio Checks
		3641	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
		3642
		3643	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The properties below are used to determine whether the element differs sufficiently from this call's
		3644	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { previously iterated element to also differ in its unit conversion ratios. If the properties match up with those
		3645	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { of the prior element, the prior element's conversion ratios are used. Like most optimizations in Velocity,
		3646	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { this is done to minimize DOM querying. */
		3647	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var sameRatioIndicators = {
		3648	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { myParent: element.parentNode || document.body, /* GET */
		3649	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { position: CSS.getPropertyValue(element, "position"), /* GET */
		3650	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { fontSize: CSS.getPropertyValue(element, "fontSize") /* GET */
		3651	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
		3652	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Determine if the same % ratio can be used. % is based on the element's position value and its parent's width and height dimensions. */
		3653	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { samePercentRatio = ((sameRatioIndicators.position === callUnitConversionData.lastPosition) && (sameRatioIndicators.myParent === callUnitConversionData.lastParent)),
		3654	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Determine if the same em ratio can be used. em is relative to the element's fontSize. */
		3655	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { sameEmRatio = (sameRatioIndicators.fontSize === callUnitConversionData.lastFontSize);
		3656
		3657	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Store these ratio indicators call-wide for the next element to compare against. */
		3658	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.lastParent = sameRatioIndicators.myParent;
		3659	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.lastPosition = sameRatioIndicators.position;
		3660	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.lastFontSize = sameRatioIndicators.fontSize;
		3661
		3662	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
		3663	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element-Specific Units
		3664	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
		3665
		3666	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: IE8 rounds to the nearest pixel when returning CSS values, thus we perform conversions using a measurement
		3667	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { of 100 (instead of 1) to give our ratios a precision of at least 2 decimal values. */
		3668	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var measurement = 100,
		3669	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios = {};
		3670
		3671	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!sameEmRatio || !samePercentRatio) {
		3672	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var dummy = data && data.isSVG ? document.createElementNS("http://www.w3.org/2000/svg", "rect") : document.createElement("div");
		3673
		3674	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.init(dummy);
		3675	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { sameRatioIndicators.myParent.appendChild(dummy);
		3676
		3677	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* To accurately and consistently calculate conversion ratios, the element's cascaded overflow and box-sizing are stripped.
		3678	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Similarly, since width/height can be artificially constrained by their min-/max- equivalents, these are controlled for as well. */
		3679	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Overflow must be also be controlled for per-axis since the overflow property overwrites its per-axis values. */
		3680	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(["overflow", "overflowX", "overflowY"], function(i, property) {
		3681	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.setPropertyValue(dummy, property, "hidden");
		3682	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		3683	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.setPropertyValue(dummy, "position", sameRatioIndicators.position);
		3684	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.setPropertyValue(dummy, "fontSize", sameRatioIndicators.fontSize);
		3685	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.setPropertyValue(dummy, "boxSizing", "content-box");
		3686
		3687	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* width and height act as our proxy properties for measuring the horizontal and vertical % ratios. */
		3688	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(["minWidth", "maxWidth", "width", "minHeight", "maxHeight", "height"], function(i, property) {
		3689	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.setPropertyValue(dummy, property, measurement + "%");
		3690	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		3691	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* paddingLeft arbitrarily acts as our proxy property for the em ratio. */
		3692	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.setPropertyValue(dummy, "paddingLeft", measurement + "em");
		3693
		3694	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3695	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth = (parseFloat(CSS.getPropertyValue(dummy, "width", null, true)) || 1) / measurement; /* GET */
		3696	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight = (parseFloat(CSS.getPropertyValue(dummy, "height", null, true)) || 1) / measurement; /* GET */
		3697	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.emToPx = callUnitConversionData.lastEmToPx = (parseFloat(CSS.getPropertyValue(dummy, "paddingLeft")) || 1) / measurement; /* GET */
		3698
		3699	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { sameRatioIndicators.myParent.removeChild(dummy);
		3700	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3701	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.emToPx = callUnitConversionData.lastEmToPx;
		3702	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth;
		3703	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight;
		3704	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3705
		3706	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
		3707	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element-Agnostic Units
		3708	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
		3709
		3710	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Whereas % and em ratios are determined on a per-element basis, the rem unit only needs to be checked
		3711	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { once per call since it's exclusively dependant upon document.body's fontSize. If this is the first time
		3712	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { that calculateUnitRatios() is being run during this call, remToPx will still be set to its default value of null,
		3713	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { so we calculate it now. */
		3714	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (callUnitConversionData.remToPx === null) {
		3715	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Default to browsers' default fontSize of 16px in the case of 0. */
		3716	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.remToPx = parseFloat(CSS.getPropertyValue(document.body, "fontSize")) || 16; /* GET */
		3717	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3718
		3719	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Similarly, viewport units are %-relative to the window's inner dimensions. */
		3720	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (callUnitConversionData.vwToPx === null) {
		3721	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.vwToPx = parseFloat(window.innerWidth) / 100; /* GET */
		3722	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.vhToPx = parseFloat(window.innerHeight) / 100; /* GET */
		3723	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3724
		3725	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.remToPx = callUnitConversionData.remToPx;
		3726	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.vwToPx = callUnitConversionData.vwToPx;
		3727	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.vhToPx = callUnitConversionData.vhToPx;
		3728
		3729	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug >= 1) {
		3730	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Unit ratios: " + JSON.stringify(unitRatios), element);
		3731	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3732	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return unitRatios;
		3733	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3734
		3735	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /********************
		3736	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Unit Conversion
		3737	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ********************/
		3738
		3739	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The * and / operators, which are not passed in with an associated unit, inherently use startValue's unit. Skip value and unit conversion. */
		3740	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/[\/*]/.test(operator)) {
		3741	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = startValueUnitType;
		3742	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If startValue and endValue differ in unit type, convert startValue into the same unit type as endValue so that if endValueUnitType
		3743	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { is a relative unit (%, em, rem), the values set during tweening will continue to be accurately relative even if the metrics they depend
		3744	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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
		3745	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { would become stale if the original unit being animated toward was relative and the underlying metrics change during the animation. */
		3746	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since 0 is 0 in any unit type, no conversion is necessary when startValue is 0 -- we just start at 0 with endValueUnitType. */
		3747	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if ((startValueUnitType !== endValueUnitType) && startValue !== 0) {
		3748	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Unit conversion is also skipped when endValue is 0, but *startValueUnitType* must be used for tween values to remain accurate. */
		3749	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Skipping unit conversion here means that if endValueUnitType was originally a relative unit, the animation won't relatively
		3750	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { match the underlying metrics if they change, but this is acceptable since we're animating toward invisibility instead of toward visibility,
		3751	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { which remains past the point of the animation's completion. */
		3752	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (endValue === 0) {
		3753	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = startValueUnitType;
		3754	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3755	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* By this point, we cannot avoid unit conversion (it's undesirable since it causes layout thrashing).
		3756	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { If we haven't already, we trigger calculateUnitRatios(), which runs once per element per call. */
		3757	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementUnitConversionData = elementUnitConversionData || calculateUnitRatios();
		3758
		3759	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The following RegEx matches CSS properties that have their % values measured relative to the x-axis. */
		3760	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		3761	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var axis = (/margin|padding|left|right|width|text|word|letter/i.test(property) || /X$/.test(property) || property === "x") ? "x" : "y";
		3762
		3763	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* In order to avoid generating n^2 bespoke conversion functions, unit conversion is a two-step process:
		3764	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 1) Convert startValue into pixels. 2) Convert this new pixel value into endValue's unit type. */
		3765	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (startValueUnitType) {
		3766	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "%":
		3767	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: translateX and translateY are the only properties that are %-relative to an element's own dimensions -- not its parent's dimensions.
		3768	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity does not include a special conversion process to account for this behavior. Therefore, animating translateX/Y from a % value
		3769	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { to a non-% value will produce an incorrect start value. Fortunately, this sort of cross-unit conversion is rarely done by users in practice. */
		3770	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue *= (axis === "x" ? elementUnitConversionData.percentToPxWidth : elementUnitConversionData.percentToPxHeight);
		3771	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3772
		3773	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "px":
		3774	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* px acts as our midpoint in the unit conversion process; do nothing. */
		3775	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3776
		3777	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
		3778	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue *= elementUnitConversionData[startValueUnitType + "ToPx"];
		3779	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3780
		3781	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Invert the px ratios to convert into to the target unit. */
		3782	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (endValueUnitType) {
		3783	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "%":
		3784	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue *= 1 / (axis === "x" ? elementUnitConversionData.percentToPxWidth : elementUnitConversionData.percentToPxHeight);
		3785	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3786
		3787	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "px":
		3788	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* startValue is already in px, do nothing; we're done. */
		3789	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3790
		3791	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
		3792	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue *= 1 / elementUnitConversionData[endValueUnitType + "ToPx"];
		3793	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3794	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3795	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3796
		3797	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
		3798	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Relative Values
		3799	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
		3800
		3801	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Operator logic must be performed last since it requires unit-normalized start and end values. */
		3802	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Relative *percent values* do not behave how most people think; while one would expect "+=50%"
		3803	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { to increase the property 1.5x its current value, it in fact increases the percent units in absolute terms:
		3804	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 50 points is added on top of the current % value. */
		3805	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (operator) {
		3806	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "+":
		3807	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue + endValue;
		3808	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3809
		3810	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "-":
		3811	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue - endValue;
		3812	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3813
		3814	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "*":
		3815	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue * endValue;
		3816	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3817
		3818	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "/":
		3819	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue / endValue;
		3820	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
		3821	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3822
		3823	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
		3824	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer Push
		3825	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
		3826
		3827	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Construct the per-property tween object, and push it to the element's tweensContainer. */
		3828	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer[property] = {
		3829	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue: rootPropertyValue,
		3830	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue: startValue,
		3831	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { currentValue: startValue,
		3832	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue: endValue,
		3833	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType: endValueUnitType,
		3834	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing: easing
		3835	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3836	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pattern) {
		3837	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer[property].pattern = pattern;
		3838	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3839
		3840	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
		3841	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("tweensContainer (" + property + "): " + JSON.stringify(tweensContainer[property]), element);
		3842	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3843	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3844
		3845	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Create a tween out of each property, and append its associated data to tweensContainer. */
		3846	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var property in propertiesMap) {
		3847
		3848	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!propertiesMap.hasOwnProperty(property)) {
		3849	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
		3850	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3851	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The original property name's format must be used for the parsePropertyValue() lookup,
		3852	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { but we then use its camelCase styling to normalize it for manipulation. */
		3853	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyName = CSS.Names.camelCase(property),
		3854	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { valueData = parsePropertyValue(propertiesMap[property]);
		3855
		3856	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Find shorthand color properties that have been passed a hex string. */
		3857	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Would be quicker to use CSS.Lists.colors.includes() if possible */
		3858	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Lists.colors.indexOf(propertyName) >= 0) {
		3859	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Parse the value data for each shorthand. */
		3860	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var endValue = valueData[0],
		3861	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = valueData[1],
		3862	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[2];
		3863
		3864	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.RegEx.isHex.test(endValue)) {
		3865	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Convert the hex strings into their RGB component arrays. */
		3866	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var colorComponents = ["Red", "Green", "Blue"],
		3867	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueRGB = CSS.Values.hexToRgb(endValue),
		3868	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValueRGB = startValue ? CSS.Values.hexToRgb(startValue) : undefined;
		3869
		3870	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inject the RGB component tweens into propertiesMap. */
		3871	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var i = 0; i < colorComponents.length; i++) {
		3872	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var dataArray = [endValueRGB[i]];
		3873
		3874	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (easing) {
		3875	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dataArray.push(easing);
		3876	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3877
		3878	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValueRGB !== undefined) {
		3879	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dataArray.push(startValueRGB[i]);
		3880	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3881
		3882	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { fixPropertyValue(propertyName + colorComponents[i], dataArray);
		3883	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3884	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If we have replaced a shortcut color value then don't update the standard property name */
		3885	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
		3886	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3887	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3888	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { fixPropertyValue(propertyName, valueData);
		3889	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3890
		3891	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Along with its property data, store a reference to the element itself onto tweensContainer. */
		3892	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer.element = element;
		3893	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3894
		3895	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************
		3896	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call Push
		3897	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************/
		3898
		3899	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: tweensContainer can be empty if all of the properties in this call's property map were skipped due to not
		3900	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { being supported by the browser. The element property is used for checking that the tweensContainer has been appended to. */
		3901	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (tweensContainer.element) {
		3902	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Apply the "velocity-animating" indicator class. */
		3903	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.Values.addClass(element, "velocity-animating");
		3904
		3905	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The call array houses the tweensContainers for each element being animated in the current call. */
		3906	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { call.push(tweensContainer);
		3907
		3908	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
		3909
		3910	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data) {
		3911	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Store the tweensContainer and options if we're working on the default effects queue, so that they can be used by the reverse command. */
		3912	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.queue === "") {
		3913
		3914	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.tweensContainer = tweensContainer;
		3915	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts = opts;
		3916	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3917
		3918	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Switch on the element's animating flag. */
		3919	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.isAnimating = true;
		3920	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3921
		3922	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Once the final element in this call's element set has been processed, push the call array onto
		3923	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.calls for the animation tick to immediately begin processing. */
		3924	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (elementsIndex === elementsLength - 1) {
		3925	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Add the current call plus its associated metadata (the element set and the call's options) onto the global call container.
		3926	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Anything on this call container is subjected to tick() processing. */
		3927	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.calls.push([call, elements, opts, null, promiseData.resolver, null, 0]);
		3928
		3929	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the animation tick isn't running, start it. (Velocity shuts it off when there are no active calls to process.) */
		3930	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.State.isTicking === false) {
		3931	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.isTicking = true;
		3932
		3933	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Start the tick loop. */
		3934	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tick();
		3935	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3936	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3937	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsIndex++;
		3938	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3939	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3940	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3941
		3942	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When the queue option is set to false, the call skips the element's queue and fires immediately. */
		3943	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.queue === false) {
		3944	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since this buildQueue call doesn't respect the element's existing queue (which is where a delay option would have been appended),
		3945	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { we manually inject the delay property here with an explicit setTimeout. */
		3946	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.delay) {
		3947
		3948	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Temporarily store delayed elements to facilitate access for global pause/resume */
		3949	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callIndex = Velocity.State.delayedElements.count++;
		3950	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[callIndex] = element;
		3951
		3952	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var delayComplete = (function(index) {
		3953	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return function() {
		3954	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clear the temporary element */
		3955	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[index] = false;
		3956
		3957	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Finally, issue the call */
		3958	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { buildQueue();
		3959	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3960	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { })(callIndex);
		3961
		3962	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayBegin = (new Date()).getTime();
		3963	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delay = parseFloat(opts.delay);
		3964	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayTimer = {
		3965	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { setTimeout: setTimeout(buildQueue, parseFloat(opts.delay)),
		3966	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { next: delayComplete
		3967	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		3968	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3969	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { buildQueue();
		3970	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3971	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Otherwise, the call undergoes element queueing as normal. */
		3972	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: To interoperate with jQuery, Velocity uses jQuery's own $.queue() stack for queuing logic. */
		3973	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		3974	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.queue(element, opts.queue, function(next, clearQueue) {
		3975	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the clearQueue flag was passed in by the stop command, resolve this call's promise. (Promises can only be resolved once,
		3976	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { so it's fine if this is repeatedly triggered for each element in the associated call.) */
		3977	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (clearQueue === true) {
		3978	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
		3979	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver(elements);
		3980	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3981
		3982	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Do not continue with animation queueing. */
		3983	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
		3984	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3985
		3986	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* This flag indicates to the upcoming completeCall() function that this queue entry was initiated by Velocity.
		3987	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { See completeCall() for further details. */
		3988	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.velocityQueueEntryFlag = true;
		3989
		3990	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { buildQueue(next);
		3991	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		3992	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		3993
		3994	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
		3995	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Auto-Dequeuing
		3996	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
		3997
		3998	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* As per jQuery's $.queue() behavior, to fire the first non-custom-queue entry on an element, the element
		3999	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { must be dequeued if its queue stack consists *solely* of the current call. (This can be determined by checking
		4000	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for the "inprogress" item that jQuery prepends to active queue stack arrays.) Regardless, whenever the element's
		4001	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { queue is further appended with additional items -- including $.delay()'s or even $.animate() calls, the queue's
		4002	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { first entry is automatically fired. This behavior contrasts that of custom queues, which never auto-fire. */
		4003	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: When an element set is being subjected to a non-parallel Velocity call, the animation will not begin until
		4004	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { each one of the elements in the set has reached the end of its individually pre-existing queue chain. */
		4005	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: Unfortunately, most people don't fully grasp jQuery's powerful, yet quirky, $.queue() function.
		4006	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Lean more here: http://stackoverflow.com/questions/1058158/can-somebody-explain-jquery-queue-to-me */
		4007	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if ((opts.queue === "" || opts.queue === "fx") && $.queue(element)[0] !== "inprogress") {
		4008	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.dequeue(element);
		4009	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4010	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4011
		4012	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
		4013	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Set Iteration
		4014	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
		4015
		4016	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If the "nodeType" property exists on the elements variable, we're animating a single element.
		4017	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Place it in an array so that $.each() can iterate over it. */
		4018	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
		4019	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Ensure each element in a set has a nodeType (is a real element) to avoid throwing errors. */
		4020	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isNode(element)) {
		4021	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { processElement(element, i);
		4022	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4023	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
		4024
		4025	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
		4026	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Loop
		4027	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
		4028
		4029	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The loop option accepts an integer indicating how many times the element should loop between the values in the
		4030	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { current call's properties map and the element's property values prior to this call. */
		4031	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: The loop option's logic is performed here -- after element processing -- because the current call needs
		4032	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { to undergo its queue insertion prior to the loop option generating its series of constituent "reverse" calls,
		4033	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { which chain after the current call. Two reverse calls (two "alternations") constitute one loop. */
		4034	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, Velocity.defaults, options);
		4035	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.loop = parseInt(opts.loop, 10);
		4036	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var reverseCallsCount = (opts.loop * 2) - 1;
		4037
		4038	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.loop) {
		4039	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Double the loop count to convert it into its appropriate number of "reverse" calls.
		4040	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Subtract 1 from the resulting value since the current call is included in the total alternation count. */
		4041	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var x = 0; x < reverseCallsCount; x++) {
		4042	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Since the logic for the reverse action occurs inside Queueing and therefore this call's options object
		4043	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isn't parsed until then as well, the current call's delay option must be explicitly passed into the reverse
		4044	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { call so that the delay logic that occurs inside *Pre-Queueing* can process it. */
		4045	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var reverseOptions = {
		4046	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delay: opts.delay,
		4047	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { progress: opts.progress
		4048	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		4049
		4050	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If a complete callback was passed into this call, transfer it to the loop redirect's final "reverse" call
		4051	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { so that it's triggered when the entire redirect is complete (and not when the very first animation is complete). */
		4052	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (x === reverseCallsCount - 1) {
		4053	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverseOptions.display = opts.display;
		4054	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverseOptions.visibility = opts.visibility;
		4055	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverseOptions.complete = opts.complete;
		4056	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4057
		4058	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { animate(elements, "reverse", reverseOptions);
		4059	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4060	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4061
		4062	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************
		4063	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Chaining
		4064	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************/
		4065
		4066	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Return the elements back to the call chain, with wrapped elements taking precedence in case Velocity was called via the $.fn. extension. */
		4067	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
		4068	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		4069
		4070	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Turn Velocity into the animation function, extended with the pre-existing Velocity object. */
		4071	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity = $.extend(animate, Velocity);
		4072	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For legacy support, also expose the literal animate method. */
		4073	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.animate = animate;
		4074
		4075	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************
		4076	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Timing
		4077	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************/
		4078
		4079	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Ticker function. */
		4080	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var ticker = window.requestAnimationFrame || rAFShim;
		4081
		4082	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inactive browser tabs pause rAF, which results in all active animations immediately sprinting to their completion states when the tab refocuses.
		4083	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { 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
		4084	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { devices to avoid wasting battery power on inactive tabs. */
		4085	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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. */
		4086	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!Velocity.State.isMobile && document.hidden !== undefined) {
		4087	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var updateTicker = function() {
		4088	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Reassign the rAF function (which the global tick() function uses) based on the tab's focus state. */
		4089	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (document.hidden) {
		4090	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ticker = function(callback) {
		4091	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The tick function needs a truthy first argument in order to pass its internal timestamp check. */
		4092	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return setTimeout(function() {
		4093	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callback(true);
		4094	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }, 16);
		4095	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		4096
		4097	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The rAF loop has been paused by the browser, so we manually restart the tick. */
		4098	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tick();
		4099	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		4100	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ticker = window.requestAnimationFrame || rAFShim;
		4101	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4102	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
		4103
		4104	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* 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 */
		4105	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { updateTicker();
		4106
		4107	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* And then run check again every time visibility changes */
		4108	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { document.addEventListener("visibilitychange", updateTicker);
		4109	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4110
		4111	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************
		4112	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tick
		4113	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************/
		4114
		4115	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Note: All calls to Velocity are pushed to the Velocity.State.calls array, which is fully iterated through upon each tick. */
		4116	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function tick(timestamp) {
		4117	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* An empty timestamp argument indicates that this is the first tick occurence since ticking was turned on.
		4118	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { We leverage this metadata to fully ignore the first tick pass since RAF's initial pass is fired whenever
		4119	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the browser's next tick sync time occurs, which results in the first elements subjected to Velocity
		4120	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { calls being animated out of sync with any elements animated immediately thereafter. In short, we ignore
		4121	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { the first RAF tick pass so that elements being immediately consecutively animated -- instead of simultaneously animated
		4122	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { by the same Velocity call -- are properly batched into the same initial RAF tick and consequently remain in sync thereafter. */
		4123	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (timestamp) {
		4124	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* We normally use RAF's high resolution timestamp but as it can be significantly offset when the browser is
		4125	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { under high stress we give the option for choppiness over allowing the browser to drop huge chunks of frames.
		4126	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { We use performance.now() and shim it if it doesn't exist for when the tab is hidden. */
		4127	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var timeCurrent = Velocity.timestamp && timestamp !== true ? timestamp : performance.now();
		4128
		4129	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /********************
		4130	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call Iteration
		4131	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ********************/
		4132
		4133	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callsLength = Velocity.State.calls.length;
		4134
		4135	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* To speed up iterating over this array, it is compacted (falsey items -- calls that have completed -- are removed)
		4136	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { when its length has ballooned to a point that can impact tick performance. This only becomes necessary when animation
		4137	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { has been continuous with many elements over a long period of time; whenever all active calls are completed, completeCall() clears Velocity.State.calls. */
		4138	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (callsLength > 10000) {
		4139	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.calls = compactSparseArray(Velocity.State.calls);
		4140	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callsLength = Velocity.State.calls.length;
		4141	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4142
		4143	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through each active call. */
		4144	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var i = 0; i < callsLength; i++) {
		4145	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* When a Velocity call is completed, its Velocity.State.calls entry is set to false. Continue on to the next call. */
		4146	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!Velocity.State.calls[i]) {
		4147	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
		4148	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4149
		4150	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
		4151	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call-Wide Variables
		4152	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
		4153
		4154	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callContainer = Velocity.State.calls[i],
		4155	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { call = callContainer[0],
		4156	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = callContainer[2],
		4157	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { timeStart = callContainer[3],
		4158	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { firstTick = !!timeStart,
		4159	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweenDummyValue = null,
		4160	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pauseObject = callContainer[5],
		4161	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { millisecondsEllapsed = callContainer[6];
		4162
		4163
		4164
		4165	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If timeStart is undefined, then this is the first time that this call has been processed by tick().
		4166	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { We assign timeStart now so that its value is as close to the real animation start time as possible.
		4167	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (Conversely, had timeStart been defined when this call was added to Velocity.State.calls, the delay
		4168	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { between that time and now would cause the first few frames of the tween to be skipped since
		4169	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { percentComplete is calculated relative to timeStart.) */
		4170	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Further, subtract 16ms (the approximate resolution of RAF) from the current time value so that the
		4171	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { first tick iteration isn't wasted by animating at 0% tween completion, which would produce the
		4172	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { same style value as the element's current value. */
		4173	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!timeStart) {
		4174	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { timeStart = Velocity.State.calls[i][3] = timeCurrent - 16;
		4175	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4176
		4177	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* If a pause object is present, skip processing unless it has been set to resume */
		4178	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pauseObject) {
		4179	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pauseObject.resume === true) {
		4180	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Update the time start to accomodate the paused completion amount */
		4181	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { timeStart = callContainer[3] = Math.round(timeCurrent - millisecondsEllapsed - 16);
		4182
		4183	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Remove pause object after processing */
		4184	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callContainer[5] = null;
		4185	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
		4186	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
		4187	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4188	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
		4189
		4190	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { millisecondsEllapsed = callContainer[6] = timeCurrent - timeStart;
		4191
		4192	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The tween's completion percentage is relative to the tween's start time, not the tween's start value
		4193	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { (which would result in unpredictable tween durations since JavaScript's timers are not particularly accurate).
		4194	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Accordingly, we ensure that percentComplete does not exceed 1. */
		4195	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var percentComplete = Math.min((millisecondsEllapsed) / opts.duration, 1);
		4196
		4197	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**********************
		4198	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Iteration
		4199	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **********************/
		4200
		4201	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* For every call, iterate through each of the elements in its set. */
		4202	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var j = 0, callLength = call.length; j < callLength; j++) {
		4203	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var tweensContainer = call[j],
		4204	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { element = tweensContainer.element;
		4205
		4206	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* Check to see if this element has been deleted midway through the animation by checking for the
		4207	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { continued existence of its data cache. If it's gone, or the element is currently paused, skip animating this element. */
		4208	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (!Data(element)) {
		4209	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { continue;
		4210	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4211
		4212	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var transformPropertyExists = false;
		4213
		4214	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /**********************************
		4215	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Display & Visibility Toggling
		4216	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { **********************************/
		4217
		4218	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* If the display option is set to non-"none", set it upfront so that the element can become visible before tweening begins.
		4219	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { (Otherwise, display's "none" value is set in completeCall() once the animation has completed.) */
		4220	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (opts.display !== undefined && opts.display !== null && opts.display !== "none") {
		4221	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (opts.display === "flex") {
		4222	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var flexValues = ["-webkit-box", "-moz-box", "-ms-flexbox", "-webkit-flex"];
		4223
		4224	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { $.each(flexValues, function(i, flexValue) {
		4225	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { CSS.setPropertyValue(element, "display", flexValue);
		4226	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { });
		4227	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4228
		4229	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { CSS.setPropertyValue(element, "display", opts.display);
		4230	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4231
		4232	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* Same goes with the visibility option, but its "none" equivalent is "hidden". */
		4233	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (opts.visibility !== undefined && opts.visibility !== "hidden") {
		4234	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { CSS.setPropertyValue(element, "visibility", opts.visibility);
		4235	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4236
		4237	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /************************
		4238	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Property Iteration
		4239	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { ************************/
		4240
		4241	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* For every element, iterate through each property. */
		4242	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { for (var property in tweensContainer) {
		4243	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* Note: In addition to property tween data, tweensContainer contains a reference to its associated element. */
		4244	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (tweensContainer.hasOwnProperty(property) && property !== "element") {
		4245	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var tween = tweensContainer[property],
		4246	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { currentValue,
		4247	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* Easing can either be a pre-genereated function or a string that references a pre-registered easing
		4248	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { on the Velocity.Easings object. In either case, return the appropriate easing *function*. */
		4249	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { easing = Type.isString(tween.easing) ? Velocity.Easings[tween.easing] : tween.easing;
		4250
		4251	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /******************************
		4252	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Current Value Calculation
		4253	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { ******************************/
		4254
		4255	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (Type.isString(tween.pattern)) {
		4256	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var patternReplace = percentComplete === 1 ?
		4257	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { function($0, index, round) {
		4258	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var result = tween.endValue[index];
		4259
		4260	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { return round ? Math.round(result) : result;
		4261	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } :
		4262	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { function($0, index, round) {
		4263	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var startValue = tween.startValue[index],
		4264	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tweenDelta = tween.endValue[index] - startValue,
		4265	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { result = startValue + (tweenDelta * easing(percentComplete, opts, tweenDelta));
		4266
		4267	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { return round ? Math.round(result) : result;
		4268	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { };
		4269
		4270	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { currentValue = tween.pattern.replace(/{(\d+)(!)?}/g, patternReplace);
		4271	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } else if (percentComplete === 1) {
		4272	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* If this is the last tick pass (if we've reached 100% completion for this tween),
		4273	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { ensure that currentValue is explicitly set to its target endValue so that it's not subjected to any rounding. */
		4274	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { currentValue = tween.endValue;
		4275	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } else {
		4276	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* Otherwise, calculate currentValue based on the current delta from startValue. */
		4277	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var tweenDelta = tween.endValue - tween.startValue;
		4278
		4279	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { currentValue = tween.startValue + (tweenDelta * easing(percentComplete, opts, tweenDelta));
		4280	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* If no value change is occurring, don't proceed with DOM updating. */
		4281	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4282	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (!firstTick && (currentValue === tween.currentValue)) {
		4283	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { continue;
		4284	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4285
		4286	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tween.currentValue = currentValue;
		4287
		4288	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* If we're tweening a fake 'tween' property in order to log transition values, update the one-per-call variable so that
		4289	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { it can be passed into the progress callback. */
		4290	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (property === "tween") {
		4291	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tweenDummyValue = currentValue;
		4292	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } else {
		4293	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /******************
		4294	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Hooks: Part I
		4295	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { ******************/
		4296	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var hookRoot;
		4297
		4298	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* For hooked properties, the newly-updated rootPropertyValueCache is cached onto the element so that it can be used
		4299	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { for subsequent hooks in this call that are associated with the same root property. If we didn't cache the updated
		4300	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { rootPropertyValue, each subsequent update to the root property in this tick pass would reset the previous hook's
		4301	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { updates to rootPropertyValue prior to injection. A nice performance byproduct of rootPropertyValue caching is that
		4302	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { subsequently chained animations using the same hookRoot but a different hook can use this cached rootPropertyValue. */
		4303	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (CSS.Hooks.registered[property]) {
		4304	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { hookRoot = CSS.Hooks.getRoot(property);
		4305
		4306	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var rootPropertyValueCache = Data(element).rootPropertyValueCache[hookRoot];
		4307
		4308	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (rootPropertyValueCache) {
		4309	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tween.rootPropertyValue = rootPropertyValueCache;
		4310	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4311	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
		4312
		4313	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /*****************
		4314	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { DOM Update
		4315	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { *****************/
		4316
		4317	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* setPropertyValue() returns an array of the property name and property value post any normalization that may have been performed. */
		4318	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /* Note: To solve an IE<=8 positioning bug, the unit type is dropped when setting a property value of 0. */
		4319	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var adjustedSetData = CSS.setPropertyValue(element, /* SET */
		4320	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { property,
		4321	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tween.currentValue + (IE < 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),
		4322	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tween.rootPropertyValue,
		4323	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tween.scrollData);
		4324
		4325	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /*******************
		4326	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Hooks: Part II
		4327	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), *******************/
		4328
		4329	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Now that we have the hook's updated rootPropertyValue (the post-processed value provided by adjustedSetData), cache it onto the element. */
		4330	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (CSS.Hooks.registered[property]) {
		4331	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Since adjustedSetData contains normalized data ready for DOM updating, the rootPropertyValue needs to be re-extracted from its normalized form. ?? */
		4332	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (CSS.Normalizations.registered[hookRoot]) {
		4333	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Data(element).rootPropertyValueCache[hookRoot] = CSS.Normalizations.registered[hookRoot]("extract", null, adjustedSetData[1]);
		4334	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), } else {
		4335	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Data(element).rootPropertyValueCache[hookRoot] = adjustedSetData[1];
		4336	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4337	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4338
		4339	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /***************
		4340	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Transforms
		4341	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ***************/
		4342
		4343	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Flag whether a transform property is being animated so that flushTransformCache() can be triggered once this tick pass is complete. */
		4344	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (adjustedSetData[0] === "transform") {
		4345	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), transformPropertyExists = true;
		4346	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4347
		4348	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4349	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4350	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4351
		4352	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /****************
		4353	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), mobileHA
		4354	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ****************/
		4355
		4356	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If mobileHA is enabled, set the translate3d transform to null to force hardware acceleration.
		4357	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), It's safe to override this property since Velocity doesn't actually support its animation (hooks are used in its place). */
		4358	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.mobileHA) {
		4359	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Don't set the null transform hack if we've already done so. */
		4360	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (Data(element).transformCache.translate3d === undefined) {
		4361	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* All entries on the transformCache object are later concatenated into a single transform string via flushTransformCache(). */
		4362	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Data(element).transformCache.translate3d = "(0px, 0px, 0px)";
		4363
		4364	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), transformPropertyExists = true;
		4365	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4366	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4367
		4368	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (transformPropertyExists) {
		4369	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), CSS.flushTransformCache(element);
		4370	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4371	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4372
		4373	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* The non-"none" display value is only applied to an element once -- when its associated call is first ticked through.
		4374	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Accordingly, it's set to false so that it isn't re-processed by this call in the next tick. */
		4375	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.display !== undefined && opts.display !== "none") {
		4376	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.State.calls[i][2].display = false;
		4377	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4378	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.visibility !== undefined && opts.visibility !== "hidden") {
		4379	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.State.calls[i][2].visibility = false;
		4380	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4381
		4382	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Pass the elements and the timing data (percentComplete, msRemaining, timeStart, tweenDummyValue) into the progress callback. */
		4383	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.progress) {
		4384	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.progress.call(callContainer[1],
		4385	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), callContainer[1],
		4386	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), percentComplete,
		4387	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Math.max(0, (timeStart + opts.duration) - timeCurrent),
		4388	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), timeStart,
		4389	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tweenDummyValue);
		4390	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4391
		4392	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If this call has finished tweening, pass its index to completeCall() to handle call cleanup. */
		4393	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (percentComplete === 1) {
		4394	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), completeCall(i);
		4395	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4396	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4397	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4398
		4399	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: completeCall() sets the isTicking flag to false when the last call on Velocity.State.calls has completed. */
		4400	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (Velocity.State.isTicking) {
		4401	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ticker(tick);
		4402	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4403	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4404
		4405	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /**********************
		4406	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Call Completion
		4407	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), **********************/
		4408
		4409	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: Unlike tick(), which processes all active calls at once, call completion is handled on a per-call basis. */
		4410	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), function completeCall(callIndex, isStopped) {
		4411	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Ensure the call exists. */
		4412	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (!Velocity.State.calls[callIndex]) {
		4413	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), return false;
		4414	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4415
		4416	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Pull the metadata from the call. */
		4417	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var call = Velocity.State.calls[callIndex][0],
		4418	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), elements = Velocity.State.calls[callIndex][1],
		4419	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts = Velocity.State.calls[callIndex][2],
		4420	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), resolver = Velocity.State.calls[callIndex][4];
		4421
		4422	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var remainingCallsExist = false;
		4423
		4424	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /*************************
		4425	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Element Finalization
		4426	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), *************************/
		4427
		4428	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), for (var i = 0, callLength = call.length; i < callLength; i++) {
		4429	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var element = call[i].element;
		4430
		4431	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If the user set display to "none" (intending to hide the element), set it now that the animation has completed. */
		4432	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: display:none isn't set when calls are manually stopped (via Velocity("stop"). */
		4433	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: Display gets ignored with "reverse" calls and infinite loops, since this behavior would be undesirable. */
		4434	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (!isStopped && !opts.loop) {
		4435	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.display === "none") {
		4436	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), CSS.setPropertyValue(element, "display", opts.display);
		4437	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4438
		4439	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.visibility === "hidden") {
		4440	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), CSS.setPropertyValue(element, "visibility", opts.visibility);
		4441	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4442	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4443
		4444	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* 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
		4445	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), a non-Velocity-initiated entry, turn off the isAnimating flag. A non-Velocity-initiatied queue entry's logic might alter
		4446	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), 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,
		4447	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), we check for the existence of our special Velocity.queueEntryFlag declaration, which minifiers won't rename since the flag
		4448	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), is assigned to jQuery's global $ object and thus exists out of Velocity's own scope. */
		4449	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var data = Data(element);
		4450
		4451	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.loop !== true && ($.queue(element)[1] === undefined || !/\.velocityQueueEntryFlag/i.test($.queue(element)[1]))) {
		4452	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* The element may have been deleted. Ensure that its data cache still exists before acting on it. */
		4453	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (data) {
		4454	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), data.isAnimating = false;
		4455	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Clear the element's rootPropertyValueCache, which will become stale. */
		4456	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), data.rootPropertyValueCache = {};
		4457
		4458	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var transformHAPropertyExists = false;
		4459	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If any 3D transform subproperty is at its default value (regardless of unit type), remove it. */
		4460	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), $.each(CSS.Lists.transforms3D, function(i, transformName) {
		4461	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var defaultValue = /^scale/.test(transformName) ? 1 : 0,
		4462	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), currentValue = data.transformCache[transformName];
		4463
		4464	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (data.transformCache[transformName] !== undefined && new RegExp("^\\(" + defaultValue + "[^.]").test(currentValue)) {
		4465	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), transformHAPropertyExists = true;
		4466
		4467	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), delete data.transformCache[transformName];
		4468	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4469	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
		4470
		4471	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Mobile devices have hardware acceleration removed at the end of the animation in order to avoid hogging the GPU's memory. */
		4472	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.mobileHA) {
		4473	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), transformHAPropertyExists = true;
		4474	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), delete data.transformCache.translate3d;
		4475	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4476
		4477	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Flush the subproperty removals to the DOM. */
		4478	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (transformHAPropertyExists) {
		4479	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), CSS.flushTransformCache(element);
		4480	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4481
		4482	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Remove the "velocity-animating" indicator class. */
		4483	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), CSS.Values.removeClass(element, "velocity-animating");
		4484	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4485	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4486
		4487	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /*********************
		4488	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Option: Complete
		4489	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), *********************/
		4490
		4491	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* 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. */
		4492	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: Callbacks aren't fired when calls are manually stopped (via Velocity("stop"). */
		4493	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (!isStopped && opts.complete && !opts.loop && (i === callLength - 1)) {
		4494	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* We throw callbacks in a setTimeout so that thrown errors don't halt the execution of Velocity itself. */
		4495	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), try {
		4496	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.complete.call(elements, elements);
		4497	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), } catch (error) {
		4498	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), setTimeout(function() {
		4499	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), throw error;
		4500	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }, 1);
		4501	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4502	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4503
		4504	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /**********************
		4505	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Promise Resolving
		4506	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), **********************/
		4507
		4508	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: Infinite loops don't return promises. */
		4509	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (resolver && opts.loop !== true) {
		4510	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), resolver(elements);
		4511	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4512
		4513	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /****************************
		4514	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Option: Loop (Infinite)
		4515	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ****************************/
		4516
		4517	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (data && opts.loop === true && !isStopped) {
		4518	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If a rotateX/Y/Z property is being animated by 360 deg with loop:true, swap tween start/end values to enable
		4519	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), continuous iterative rotation looping. (Otherise, the element would just rotate back and forth.) */
		4520	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), $.each(data.tweensContainer, function(propertyName, tweenContainer) {
		4521	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (/^rotate/.test(propertyName) && ((parseFloat(tweenContainer.startValue) - parseFloat(tweenContainer.endValue)) % 360 === 0)) {
		4522	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var oldStartValue = tweenContainer.startValue;
		4523
		4524	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tweenContainer.startValue = tweenContainer.endValue;
		4525	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tweenContainer.endValue = oldStartValue;
		4526	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4527
		4528	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (/^backgroundPosition/.test(propertyName) && parseFloat(tweenContainer.endValue) === 100 && tweenContainer.unitType === "%") {
		4529	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tweenContainer.endValue = 0;
		4530	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), tweenContainer.startValue = 100;
		4531	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4532	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
		4533
		4534	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity(element, "reverse", {loop: true, delay: opts.delay});
		4535	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4536
		4537	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /***************
		4538	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Dequeueing
		4539	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ***************/
		4540
		4541	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Fire the next call in the queue so long as this call's queue wasn't set to false (to trigger a parallel animation),
		4542	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), which would have already caused the next call to fire. Note: Even if the end of the animation queue has been reached,
		4543	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), $.dequeue() must still be called in order to completely clear jQuery's animation queue. */
		4544	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.queue !== false) {
		4545	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), $.dequeue(element, opts.queue);
		4546	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4547	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4548
		4549	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /************************
		4550	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Calls Array Cleanup
		4551	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ************************/
		4552
		4553	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Since this call is complete, set it to false so that the rAF tick skips it. This array is later compacted via compactSparseArray().
		4554	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), (For performance reasons, the call is set to false instead of being deleted from the array: http://www.html5rocks.com/en/tutorials/speed/v8/) */
		4555	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.State.calls[callIndex] = false;
		4556
		4557	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Iterate through the calls array to determine if this was the final in-progress animation.
		4558	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), If so, set a flag to end ticking and clear the calls array. */
		4559	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), for (var j = 0, callsLength = Velocity.State.calls.length; j < callsLength; j++) {
		4560	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (Velocity.State.calls[j] !== false) {
		4561	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), remainingCallsExist = true;
		4562
		4563	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), break;
		4564	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4565	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4566
		4567	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (remainingCallsExist === false) {
		4568	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* tick() will detect this flag upon its next iteration and subsequently turn itself off. */
		4569	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.State.isTicking = false;
		4570
		4571	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Clear the calls array so that its length is reset. */
		4572	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), delete Velocity.State.calls;
		4573	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.State.calls = [];
		4574	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4575	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4576
		4577	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /******************
		4578	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Frameworks
		4579	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ******************/
		4580
		4581	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Both jQuery and Zepto allow their $.fn object to be extended to allow wrapped elements to be subjected to plugin calls.
		4582	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), If either framework is loaded, register a "velocity" extension pointing to Velocity's core animate() method. Velocity
		4583	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), also registers itself onto a global container (window.jQuery || window.Zepto || window) so that certain features are
		4584	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), accessible beyond just a per-element scope. This master object contains an .animate() method, which is later assigned to $.fn
		4585	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), (if jQuery or Zepto are present). Accordingly, Velocity can both act on wrapped DOM elements and stand alone for targeting raw DOM elements. */
		4586	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), global.Velocity = Velocity;
		4587
		4588	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (global !== window) {
		4589	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Assign the element function to Velocity's core animate() method. */
		4590	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), global.fn.velocity = animate;
		4591	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Assign the object function's defaults to Velocity's global defaults object. */
		4592	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), global.fn.velocity.defaults = Velocity.defaults;
		4593	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4594
		4595	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /***********************
		4596	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Packaged Redirects
		4597	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ***********************/
		4598
		4599	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* slideUp, slideDown */
		4600	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), $.each(["Down", "Up"], function(i, direction) {
		4601	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.Redirects["slide" + direction] = function(element, options, elementsIndex, elementsSize, elements, promiseData) {
		4602	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var opts = $.extend({}, options),
		4603	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), begin = opts.begin,
		4604	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), complete = opts.complete,
		4605	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), inlineValues = {},
		4606	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), computedValues = {height: "", marginTop: "", marginBottom: "", paddingTop: "", paddingBottom: ""};
		4607
		4608	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.display === undefined) {
		4609	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Show the element before slideDown begins and hide the element after slideUp completes. */
		4610	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: Inline elements cannot have dimensions animated, so they're reverted to inline-block. */
		4611	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.display = (direction === "Down" ? (Velocity.CSS.Values.getDisplayType(element) === "inline" ? "inline-block" : "block") : "none");
		4612	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4613
		4614	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.begin = function() {
		4615	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If the user passed in a begin callback, fire it now. */
		4616	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (elementsIndex === 0 && begin) {
		4617	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), begin.call(elements, elements);
		4618	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4619
		4620	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Cache the elements' original vertical dimensional property values so that we can animate back to them. */
		4621	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), for (var property in computedValues) {
		4622	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (!computedValues.hasOwnProperty(property)) {
		4623	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), continue;
		4624	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4625	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), inlineValues[property] = element.style[property];
		4626
		4627	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* For slideDown, use forcefeeding to animate all vertical properties from 0. For slideUp,
		4628	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), use forcefeeding to start from computed values and animate down to 0. */
		4629	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var propertyValue = CSS.getPropertyValue(element, property);
		4630	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), computedValues[property] = (direction === "Down") ? [propertyValue, 0] : [0, propertyValue];
		4631	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4632
		4633	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Force vertical overflow content to clip so that sliding works as expected. */
		4634	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), inlineValues.overflow = element.style.overflow;
		4635	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), element.style.overflow = "hidden";
		4636	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
		4637
		4638	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.complete = function() {
		4639	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Reset element to its pre-slide inline values once its slide animation is complete. */
		4640	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), for (var property in inlineValues) {
		4641	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (inlineValues.hasOwnProperty(property)) {
		4642	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), element.style[property] = inlineValues[property];
		4643	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4644	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4645
		4646	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If the user passed in a complete callback, fire it now. */
		4647	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (elementsIndex === elementsSize - 1) {
		4648	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (complete) {
		4649	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), complete.call(elements, elements);
		4650	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4651	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (promiseData) {
		4652	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), promiseData.resolver(elements);
		4653	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4654	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4655	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
		4656
		4657	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity(element, computedValues, opts);
		4658	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
		4659	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
		4660
		4661	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* fadeIn, fadeOut */
		4662	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), $.each(["In", "Out"], function(i, direction) {
		4663	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity.Redirects["fade" + direction] = function(element, options, elementsIndex, elementsSize, elements, promiseData) {
		4664	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), var opts = $.extend({}, options),
		4665	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), complete = opts.complete,
		4666	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), propertiesMap = {opacity: (direction === "In") ? 1 : 0};
		4667
		4668	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Since redirects are triggered individually for each element in the animated set, avoid repeatedly triggering
		4669	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), callbacks by firing them only when the final element has been reached. */
		4670	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (elementsIndex !== 0) {
		4671	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.begin = null;
		4672	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4673	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (elementsIndex !== elementsSize - 1) {
		4674	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.complete = null;
		4675	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), } else {
		4676	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.complete = function() {
		4677	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (complete) {
		4678	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), complete.call(elements, elements);
		4679	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4680	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (promiseData) {
		4681	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), promiseData.resolver(elements);
		4682	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4683	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
		4684	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4685
		4686	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* If a display was passed in, use it. Otherwise, default to "none" for fadeOut or the element-specific default for fadeIn. */
		4687	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /* Note: We allow users to pass in "null" to skip display setting altogether. */
		4688	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), if (opts.display === undefined) {
		4689	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), opts.display = (direction === "In" ? "auto" : "none");
		4690	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
		4691
		4692	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity(this, propertiesMap, opts);
		4693	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
		4694	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
		4695
		4696	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), return Velocity;
		4697	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }((window.jQuery || window.Zepto || window), window, (window ? window.document : undefined));
		4698	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),}));
		4699
		4700	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),/******************
		4701	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Known Issues
		4702	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ******************/
		4703
		4704	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),/* The CSS spec mandates that the translateX/Y/Z transforms are %-relative to the element itself -- not its parent.
		4705	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), Velocity, however, doesn't make this distinction. Thus, converting to or from the % unit with these subproperties
		4706	< 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), will produce an inaccurate conversion value. The same issue exists with the cx/cy attributes of SVG circles and ellipses. */