scratch – Blame information for rev 125

Subversion Repositories:
Rev:
Rev Author Line No. Line
125 office 1 /*! VelocityJS.org (1.5.0). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License */
77 office 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  
125 office 501 if (typeof perf.now !== "function") {
502 var nowOffset = perf.timing && perf.timing.navigationStart ? perf.timing.navigationStart : (new Date()).getTime();
77 office 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  
125 office 528 /**
529 * Shim for "fixing" IE's lack of support (IE < 9) for applying slice
530 * on host objects like NamedNodeMap, NodeList, and HTMLCollection
531 * (technically, since host objects have been implementation-dependent,
532 * at least before ES2015, IE hasn't needed to work this way).
533 * Also works on strings, fixes IE < 9 to allow an explicit undefined
534 * for the 2nd argument (as in Firefox), and prevents errors when
535 * called on other DOM objects.
536 */
77 office 537 var _slice = (function() {
538 var slice = Array.prototype.slice;
539  
540 try {
541 // Can't be used with DOM elements in IE < 9
542 slice.call(document.documentElement);
125 office 543 return slice;
77 office 544 } catch (e) { // Fails in IE < 9
125 office 545  
77 office 546 // This will work for genuine arrays, array-like objects,
547 // NamedNodeMap (attributes, entities, notations),
548 // NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes),
549 // and will not fail on other DOM objects (as do DOM elements in IE < 9)
125 office 550 return function(begin, end) {
551 var len = this.length;
77 office 552  
125 office 553 if (typeof begin !== "number") {
554 begin = 0;
77 office 555 }
125 office 556 // IE < 9 gets unhappy with an undefined end argument
557 if (typeof end !== "number") {
558 end = len;
559 }
560 // For native Array objects, we use the native slice function
561 if (this.slice) {
562 return slice.call(this, begin, end);
563 }
564 // For array like object we handle it ourselves.
565 var i,
566 cloned = [],
567 // Handle negative value for "begin"
568 start = (begin >= 0) ? begin : Math.max(0, len + begin),
569 // Handle negative value for "end"
570 upTo = end < 0 ? len + end : Math.min(end, len),
571 // Actual expected size of the slice
572 size = upTo - start;
573  
574 if (size > 0) {
575 cloned = new Array(size);
576 if (this.charAt) {
577 for (i = 0; i < size; i++) {
578 cloned[i] = this.charAt(start + i);
579 }
580 } else {
581 for (i = 0; i < size; i++) {
582 cloned[i] = this[start + i];
583 }
584 }
585 }
586 return cloned;
77 office 587 };
588 }
125 office 589 })();
77 office 590  
125 office 591 /* .indexOf doesn't exist in IE<9 */
592 var _inArray = (function() {
593 if (Array.prototype.includes) {
594 return function(arr, val) {
595 return arr.includes(val);
596 };
597 }
598 if (Array.prototype.indexOf) {
599 return function(arr, val) {
600 return arr.indexOf(val) >= 0;
601 };
602 }
603 return function(arr, val) {
604 for (var i = 0; i < arr.length; i++) {
605 if (arr[i] === val) {
606 return true;
607 }
608 }
609 return false;
610 };
611 });
612  
77 office 613 function sanitizeElements(elements) {
614 /* Unwrap jQuery/Zepto objects. */
615 if (Type.isWrapped(elements)) {
616 elements = _slice.call(elements);
617 /* Wrap a single element in an array so that $.each() can iterate with the element instead of its node's children. */
618 } else if (Type.isNode(elements)) {
619 elements = [elements];
620 }
621  
622 return elements;
623 }
624  
625 var Type = {
626 isNumber: function(variable) {
627 return (typeof variable === "number");
628 },
629 isString: function(variable) {
630 return (typeof variable === "string");
631 },
632 isArray: Array.isArray || function(variable) {
633 return Object.prototype.toString.call(variable) === "[object Array]";
634 },
635 isFunction: function(variable) {
636 return Object.prototype.toString.call(variable) === "[object Function]";
637 },
638 isNode: function(variable) {
639 return variable && variable.nodeType;
640 },
641 /* Determine if variable is an array-like wrapped jQuery, Zepto or similar element, or even a NodeList etc. */
642 /* NOTE: HTMLFormElements also have a length. */
643 isWrapped: function(variable) {
644 return variable
125 office 645 && variable !== window
77 office 646 && Type.isNumber(variable.length)
647 && !Type.isString(variable)
648 && !Type.isFunction(variable)
649 && !Type.isNode(variable)
650 && (variable.length === 0 || Type.isNode(variable[0]));
651 },
652 isSVG: function(variable) {
653 return window.SVGElement && (variable instanceof window.SVGElement);
654 },
655 isEmptyObject: function(variable) {
656 for (var name in variable) {
657 if (variable.hasOwnProperty(name)) {
658 return false;
659 }
660 }
661  
662 return true;
663 }
664 };
665  
666 /*****************
667 Dependencies
668 *****************/
669  
670 var $,
671 isJQuery = false;
672  
673 if (global.fn && global.fn.jquery) {
674 $ = global;
675 isJQuery = true;
676 } else {
677 $ = window.Velocity.Utilities;
678 }
679  
680 if (IE <= 8 && !isJQuery) {
681 throw new Error("Velocity: IE8 and below require jQuery to be loaded before Velocity.");
682 } else if (IE <= 7) {
683 /* Revert to jQuery's $.animate(), and lose Velocity's extra features. */
684 jQuery.fn.velocity = jQuery.fn.animate;
685  
686 /* Now that $.fn.velocity is aliased, abort this Velocity declaration. */
687 return;
688 }
689  
690 /*****************
691 Constants
692 *****************/
693  
694 var DURATION_DEFAULT = 400,
695 EASING_DEFAULT = "swing";
696  
697 /*************
698 State
699 *************/
700  
701 var Velocity = {
702 /* Container for page-wide Velocity state data. */
703 State: {
704 /* Detect mobile devices to determine if mobileHA should be turned on. */
705 isMobile: /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent),
706 /* The mobileHA option's behavior changes on older Android devices (Gingerbread, versions 2.3.3-2.3.7). */
707 isAndroid: /Android/i.test(navigator.userAgent),
708 isGingerbread: /Android 2\.3\.[3-7]/i.test(navigator.userAgent),
709 isChrome: window.chrome,
710 isFirefox: /Firefox/i.test(navigator.userAgent),
711 /* Create a cached element for re-use when checking for CSS property prefixes. */
712 prefixElement: document.createElement("div"),
713 /* Cache every prefix match to avoid repeating lookups. */
714 prefixMatches: {},
715 /* Cache the anchor used for animating window scrolling. */
716 scrollAnchor: null,
717 /* Cache the browser-specific property names associated with the scroll anchor. */
718 scrollPropertyLeft: null,
719 scrollPropertyTop: null,
720 /* Keep track of whether our RAF tick is running. */
721 isTicking: false,
722 /* Container for every in-progress call to Velocity. */
723 calls: [],
724 delayedElements: {
725 count: 0
726 }
727 },
728 /* Velocity's custom CSS stack. Made global for unit testing. */
729 CSS: {/* Defined below. */},
730 /* A shim of the jQuery utility functions used by Velocity -- provided by Velocity's optional jQuery shim. */
731 Utilities: $,
732 /* Container for the user's custom animation redirects that are referenced by name in place of the properties map argument. */
733 Redirects: {/* Manually registered by the user. */},
734 Easings: {/* Defined below. */},
735 /* Attempt to use ES6 Promises by default. Users can override this with a third-party promises library. */
736 Promise: window.Promise,
737 /* Velocity option defaults, which can be overriden by the user. */
738 defaults: {
739 queue: "",
740 duration: DURATION_DEFAULT,
741 easing: EASING_DEFAULT,
742 begin: undefined,
743 complete: undefined,
744 progress: undefined,
745 display: undefined,
746 visibility: undefined,
747 loop: false,
748 delay: false,
749 mobileHA: true,
750 /* Advanced: Set to false to prevent property values from being cached between consecutive Velocity-initiated chain calls. */
751 _cacheValues: true,
752 /* Advanced: Set to false if the promise should always resolve on empty element lists. */
753 promiseRejectEmpty: true
754 },
755 /* A design goal of Velocity is to cache data wherever possible in order to avoid DOM requerying. Accordingly, each element has a data cache. */
756 init: function(element) {
757 $.data(element, "velocity", {
758 /* Store whether this is an SVG element, since its properties are retrieved and updated differently than standard HTML elements. */
759 isSVG: Type.isSVG(element),
760 /* Keep track of whether the element is currently being animated by Velocity.
761 This is used to ensure that property values are not transferred between non-consecutive (stale) calls. */
762 isAnimating: false,
763 /* A reference to the element's live computedStyle object. Learn more here: https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle */
764 computedStyle: null,
765 /* Tween data is cached for each animation on the element so that data can be passed across calls --
766 in particular, end values are used as subsequent start values in consecutive Velocity calls. */
767 tweensContainer: null,
768 /* The full root property values of each CSS hook being animated on this element are cached so that:
769 1) Concurrently-animating hooks sharing the same root can have their root values' merged into one while tweening.
770 2) Post-hook-injection root values can be transferred over to consecutively chained Velocity calls as starting root values. */
771 rootPropertyValueCache: {},
772 /* A cache for transform updates, which must be manually flushed via CSS.flushTransformCache(). */
773 transformCache: {}
774 });
775 },
776 /* A parallel to jQuery's $.css(), used for getting/setting Velocity's hooked CSS properties. */
777 hook: null, /* Defined below. */
778 /* Velocity-wide animation time remapping for testing purposes. */
779 mock: false,
125 office 780 version: {major: 1, minor: 5, patch: 0},
77 office 781 /* Set to 1 or 2 (most verbose) to output debug info to console. */
782 debug: false,
783 /* Use rAF high resolution timestamp when available */
784 timestamp: true,
785 /* Pause all animations */
786 pauseAll: function(queueName) {
787 var currentTime = (new Date()).getTime();
788  
789 $.each(Velocity.State.calls, function(i, activeCall) {
790  
791 if (activeCall) {
792  
793 /* If we have a queueName and this call is not on that queue, skip */
794 if (queueName !== undefined && ((activeCall[2].queue !== queueName) || (activeCall[2].queue === false))) {
795 return true;
796 }
797  
798 /* Set call to paused */
799 activeCall[5] = {
800 resume: false
801 };
802 }
803 });
804  
805 /* Pause timers on any currently delayed calls */
806 $.each(Velocity.State.delayedElements, function(k, element) {
807 if (!element) {
808 return;
809 }
810 pauseDelayOnElement(element, currentTime);
811 });
812 },
813 /* Resume all animations */
814 resumeAll: function(queueName) {
815 var currentTime = (new Date()).getTime();
816  
817 $.each(Velocity.State.calls, function(i, activeCall) {
818  
819 if (activeCall) {
820  
821 /* If we have a queueName and this call is not on that queue, skip */
822 if (queueName !== undefined && ((activeCall[2].queue !== queueName) || (activeCall[2].queue === false))) {
823 return true;
824 }
825  
826 /* Set call to resumed if it was paused */
827 if (activeCall[5]) {
828 activeCall[5].resume = true;
829 }
830 }
831 });
832 /* Resume timers on any currently delayed calls */
833 $.each(Velocity.State.delayedElements, function(k, element) {
834 if (!element) {
835 return;
836 }
837 resumeDelayOnElement(element, currentTime);
838 });
839 }
840 };
841  
842 /* Retrieve the appropriate scroll anchor and property name for the browser: https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY */
843 if (window.pageYOffset !== undefined) {
844 Velocity.State.scrollAnchor = window;
845 Velocity.State.scrollPropertyLeft = "pageXOffset";
846 Velocity.State.scrollPropertyTop = "pageYOffset";
847 } else {
848 Velocity.State.scrollAnchor = document.documentElement || document.body.parentNode || document.body;
849 Velocity.State.scrollPropertyLeft = "scrollLeft";
850 Velocity.State.scrollPropertyTop = "scrollTop";
851 }
852  
853 /* Shorthand alias for jQuery's $.data() utility. */
854 function Data(element) {
855 /* Hardcode a reference to the plugin name. */
856 var response = $.data(element, "velocity");
857  
858 /* jQuery <=1.4.2 returns null instead of undefined when no match is found. We normalize this behavior. */
859 return response === null ? undefined : response;
860 }
861  
862 /**************
863 Delay Timer
864 **************/
865  
866 function pauseDelayOnElement(element, currentTime) {
867 /* Check for any delay timers, and pause the set timeouts (while preserving time data)
868 to be resumed when the "resume" command is issued */
869 var data = Data(element);
870 if (data && data.delayTimer && !data.delayPaused) {
871 data.delayRemaining = data.delay - currentTime + data.delayBegin;
872 data.delayPaused = true;
873 clearTimeout(data.delayTimer.setTimeout);
874 }
875 }
876  
877 function resumeDelayOnElement(element, currentTime) {
878 /* Check for any paused timers and resume */
879 var data = Data(element);
880 if (data && data.delayTimer && data.delayPaused) {
881 /* If the element was mid-delay, re initiate the timeout with the remaining delay */
882 data.delayPaused = false;
883 data.delayTimer.setTimeout = setTimeout(data.delayTimer.next, data.delayRemaining);
884 }
885 }
886  
887  
888  
889 /**************
890 Easing
891 **************/
892  
893 /* Step easing generator. */
894 function generateStep(steps) {
895 return function(p) {
896 return Math.round(p * steps) * (1 / steps);
897 };
898 }
899  
900 /* Bezier curve function generator. Copyright Gaetan Renaudeau. MIT License: http://en.wikipedia.org/wiki/MIT_License */
901 function generateBezier(mX1, mY1, mX2, mY2) {
902 var NEWTON_ITERATIONS = 4,
903 NEWTON_MIN_SLOPE = 0.001,
904 SUBDIVISION_PRECISION = 0.0000001,
905 SUBDIVISION_MAX_ITERATIONS = 10,
906 kSplineTableSize = 11,
907 kSampleStepSize = 1.0 / (kSplineTableSize - 1.0),
908 float32ArraySupported = "Float32Array" in window;
909  
910 /* Must contain four arguments. */
911 if (arguments.length !== 4) {
912 return false;
913 }
914  
915 /* Arguments must be numbers. */
916 for (var i = 0; i < 4; ++i) {
917 < 4; ++i) { if (typeof arguments[i] !== "number" || isNaN(arguments[i]) || !isFinite(arguments[i])) {
918 < 4; ++i) { return false;
919 < 4; ++i) { }
920 < 4; ++i) { }
921  
922 < 4; ++i) { /* X values must be in the [0, 1] range. */
923 < 4; ++i) { mX1 = Math.min(mX1, 1);
924 < 4; ++i) { mX2 = Math.min(mX2, 1);
925 < 4; ++i) { mX1 = Math.max(mX1, 0);
926 < 4; ++i) { mX2 = Math.max(mX2, 0);
927  
928 < 4; ++i) { var mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
929  
930 < 4; ++i) { function A(aA1, aA2) {
931 < 4; ++i) { return 1.0 - 3.0 * aA2 + 3.0 * aA1;
932 < 4; ++i) { }
933 < 4; ++i) { function B(aA1, aA2) {
934 < 4; ++i) { return 3.0 * aA2 - 6.0 * aA1;
935 < 4; ++i) { }
936 < 4; ++i) { function C(aA1) {
937 < 4; ++i) { return 3.0 * aA1;
938 < 4; ++i) { }
939  
940 < 4; ++i) { function calcBezier(aT, aA1, aA2) {
941 < 4; ++i) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
942 < 4; ++i) { }
943  
944 < 4; ++i) { function getSlope(aT, aA1, aA2) {
945 < 4; ++i) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
946 < 4; ++i) { }
947  
948 < 4; ++i) { function newtonRaphsonIterate(aX, aGuessT) {
949 < 4; ++i) { for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
950 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { var currentSlope = getSlope(aGuessT, mX1, mX2);
951  
952 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { if (currentSlope === 0.0) {
953 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { return aGuessT;
954 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
955  
956 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
957 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { aGuessT -= currentX / currentSlope;
958 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
959  
960 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { return aGuessT;
961 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
962  
963 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { function calcSampleValues() {
964 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { for (var i = 0; i < kSplineTableSize; ++i) {
965 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
966 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
967 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
968  
969 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { function binarySubdivide(aX, aA, aB) {
970 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { var currentX, currentT, i = 0;
971  
972 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { do {
973 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { currentT = aA + (aB - aA) / 2.0;
974 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { currentX = calcBezier(currentT, mX1, mX2) - aX;
975 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { if (currentX > 0.0) {
976 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { aB = currentT;
977 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { } else {
978 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { aA = currentT;
979 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { }
980 < 4; ++i) {< NEWTON_ITERATIONS; ++i) { } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
981  
982 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); return currentT;
983 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); }
984  
985 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); function getTForX(aX) {
986 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); var intervalStart = 0.0,
987 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); currentSample = 1,
988 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); lastSample = kSplineTableSize - 1;
989  
990 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS); for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
991 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { intervalStart += kSampleStepSize;
992 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
993  
994 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { --currentSample;
995  
996 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]),
997 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { guessForT = intervalStart + dist * kSampleStepSize,
998 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { initialSlope = getSlope(guessForT, mX1, mX2);
999  
1000 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (initialSlope >= NEWTON_MIN_SLOPE) {
1001 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return newtonRaphsonIterate(aX, guessForT);
1002 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (initialSlope === 0.0) {
1003 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return guessForT;
1004 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1005 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize);
1006 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1007 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1008  
1009 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var _precomputed = false;
1010  
1011 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function precompute() {
1012 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { _precomputed = true;
1013 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (mX1 !== mY1 || mX2 !== mY2) {
1014 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { calcSampleValues();
1015 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1016 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1017  
1018 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var f = function(aX) {
1019 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!_precomputed) {
1020 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { precompute();
1021 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1022 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (mX1 === mY1 && mX2 === mY2) {
1023 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return aX;
1024 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1025 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (aX === 0) {
1026 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 0;
1027 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1028 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (aX === 1) {
1029 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 1;
1030 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1031  
1032 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return calcBezier(getTForX(aX), mY1, mY2);
1033 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1034  
1035 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { f.getControlPoints = function() {
1036 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return [{x: mX1, y: mY1}, {x: mX2, y: mY2}];
1037 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1038  
1039 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var str = "generateBezier(" + [mX1, mY1, mX2, mY2] + ")";
1040 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { f.toString = function() {
1041 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return str;
1042 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1043  
1044 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return f;
1045 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1046  
1047 < 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 */
1048 < 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
1049 < 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. */
1050 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var generateSpringRK4 = (function() {
1051 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function springAccelerationForState(state) {
1052 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return (-state.tension * state.x) - (state.friction * state.v);
1053 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1054  
1055 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function springEvaluateStateWithDerivative(initialState, dt, derivative) {
1056 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var state = {
1057 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { x: initialState.x + derivative.dx * dt,
1058 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { v: initialState.v + derivative.dv * dt,
1059 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tension: initialState.tension,
1060 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { friction: initialState.friction
1061 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1062  
1063 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return {dx: state.v, dv: springAccelerationForState(state)};
1064 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1065  
1066 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function springIntegrateState(state, dt) {
1067 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var a = {
1068 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dx: state.v,
1069 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dv: springAccelerationForState(state)
1070 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1071 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { b = springEvaluateStateWithDerivative(state, dt * 0.5, a),
1072 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { c = springEvaluateStateWithDerivative(state, dt * 0.5, b),
1073 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { d = springEvaluateStateWithDerivative(state, dt, c),
1074 < 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),
1075 < 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);
1076  
1077 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { state.x = state.x + dxdt * dt;
1078 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { state.v = state.v + dvdt * dt;
1079  
1080 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return state;
1081 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1082  
1083 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return function springRK4Factory(tension, friction, duration) {
1084  
1085 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var initState = {
1086 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { x: -1,
1087 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { v: 0,
1088 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tension: null,
1089 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { friction: null
1090 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1091 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { path = [0],
1092 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { time_lapsed = 0,
1093 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tolerance = 1 / 10000,
1094 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { DT = 16 / 1000,
1095 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { have_duration, dt, last_state;
1096  
1097 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tension = parseFloat(tension) || 500;
1098 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { friction = parseFloat(friction) || 20;
1099 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { duration = duration || null;
1100  
1101 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { initState.tension = tension;
1102 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { initState.friction = friction;
1103  
1104 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { have_duration = duration !== null;
1105  
1106 < 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. */
1107 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (have_duration) {
1108 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Run the simulation without a duration. */
1109 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { time_lapsed = springRK4Factory(tension, friction);
1110 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Compute the adjusted time delta. */
1111 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dt = time_lapsed / duration * DT;
1112 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1113 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { dt = DT;
1114 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1115  
1116 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { while (true) {
1117 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Next/step function .*/
1118 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { last_state = springIntegrateState(last_state || initState, dt);
1119 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Store the position. */
1120 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { path.push(1 + last_state.x);
1121 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { time_lapsed += 16;
1122 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the change threshold is reached, break. */
1123 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!(Math.abs(last_state.x) > tolerance && Math.abs(last_state.v) > tolerance)) {
1124 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { break;
1125 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1126 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1127  
1128 < 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
1129 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { computed path and returns a snapshot of the position according to a given percentComplete. */
1130 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return !have_duration ? time_lapsed : function(percentComplete) {
1131 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return path[ (percentComplete * (path.length - 1)) | 0 ];
1132 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1133 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1134 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }());
1135  
1136 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* jQuery easings. */
1137 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Velocity.Easings = {
1138 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { linear: function(p) {
1139 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return p;
1140 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1141 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { swing: function(p) {
1142 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 0.5 - Math.cos(p * Math.PI) / 2;
1143 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1144 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Bonus "spring" easing, which is a less exaggerated version of easeInOutElastic. */
1145 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { spring: function(p) {
1146 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return 1 - (Math.cos(p * 4.5 * Math.PI) * Math.exp(-p * 6));
1147 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1148 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { };
1149  
1150 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* CSS3 and Robert Penner easings. */
1151 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { $.each(
1152 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { [
1153 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease", [0.25, 0.1, 0.25, 1.0]],
1154 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease-in", [0.42, 0.0, 1.00, 1.0]],
1155 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease-out", [0.00, 0.0, 0.58, 1.0]],
1156 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["ease-in-out", [0.42, 0.0, 0.58, 1.0]],
1157 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInSine", [0.47, 0, 0.745, 0.715]],
1158 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutSine", [0.39, 0.575, 0.565, 1]],
1159 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutSine", [0.445, 0.05, 0.55, 0.95]],
1160 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInQuad", [0.55, 0.085, 0.68, 0.53]],
1161 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutQuad", [0.25, 0.46, 0.45, 0.94]],
1162 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutQuad", [0.455, 0.03, 0.515, 0.955]],
1163 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInCubic", [0.55, 0.055, 0.675, 0.19]],
1164 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutCubic", [0.215, 0.61, 0.355, 1]],
1165 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutCubic", [0.645, 0.045, 0.355, 1]],
1166 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInQuart", [0.895, 0.03, 0.685, 0.22]],
1167 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutQuart", [0.165, 0.84, 0.44, 1]],
1168 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutQuart", [0.77, 0, 0.175, 1]],
1169 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInQuint", [0.755, 0.05, 0.855, 0.06]],
1170 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutQuint", [0.23, 1, 0.32, 1]],
1171 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutQuint", [0.86, 0, 0.07, 1]],
1172 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInExpo", [0.95, 0.05, 0.795, 0.035]],
1173 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutExpo", [0.19, 1, 0.22, 1]],
1174 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutExpo", [1, 0, 0, 1]],
1175 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInCirc", [0.6, 0.04, 0.98, 0.335]],
1176 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeOutCirc", [0.075, 0.82, 0.165, 1]],
1177 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ["easeInOutCirc", [0.785, 0.135, 0.15, 0.86]]
1178 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ], function(i, easingArray) {
1179 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Velocity.Easings[easingArray[0]] = generateBezier.apply(null, easingArray[1]);
1180 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { });
1181  
1182 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Determine the appropriate easing type given an easing input. */
1183 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function getEasing(value, duration) {
1184 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var easing = value;
1185  
1186 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* The easing option can either be a string that references a pre-registered easing,
1187 < 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. */
1188 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (Type.isString(value)) {
1189 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Ensure that the easing has been assigned to jQuery's Velocity.Easings object. */
1190 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!Velocity.Easings[value]) {
1191 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = false;
1192 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1193 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (Type.isArray(value) && value.length === 1) {
1194 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = generateStep.apply(null, value);
1195 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (Type.isArray(value) && value.length === 2) {
1196 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* springRK4 must be passed the animation's duration. */
1197 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: If the springRK4 array contains non-numbers, generateSpringRK4() returns an easing
1198 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { function generated with default tension and friction values. */
1199 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = generateSpringRK4.apply(null, value.concat([duration]));
1200 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else if (Type.isArray(value) && value.length === 4) {
1201 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: If the bezier array contains non-numbers, generateBezier() returns false. */
1202 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = generateBezier.apply(null, value);
1203 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1204 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = false;
1205 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1206  
1207 < 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)
1208 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if the Velocity-wide default has been incorrectly modified. */
1209 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (easing === false) {
1210 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (Velocity.Easings[Velocity.defaults.easing]) {
1211 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = Velocity.defaults.easing;
1212 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1213 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { easing = EASING_DEFAULT;
1214 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1215 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1216  
1217 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return easing;
1218 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1219  
1220 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*****************
1221 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS Stack
1222 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *****************/
1223  
1224 < 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.
1225 < 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. */
1226 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: A "CSS" shorthand is aliased so that our code is easier to read. */
1227 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var CSS = Velocity.CSS = {
1228 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*************
1229 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { RegEx
1230 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *************/
1231  
1232 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { RegEx: {
1233 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { isHex: /^#([A-f\d]{3}){1,2}$/i,
1234 < 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". */
1235 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { valueUnwrap: /^[A-z]+\((.*)\)$/i,
1236 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { wrappedValueAlreadyExtracted: /[0-9.]+ [0-9.]+ [0-9.]+( [0-9.]+)?/,
1237 < 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" ]. */
1238 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { valueSplit: /([A-z]+\(.+\))|(([A-z0-9#-.]+?)(?=\s|$))/ig
1239 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1240 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /************
1241 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Lists
1242 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ************/
1243  
1244 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Lists: {
1245 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { colors: ["fill", "stroke", "stopColor", "color", "backgroundColor", "borderColor", "borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor", "outlineColor"],
1246 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { transformsBase: ["translateX", "translateY", "scale", "scaleX", "scaleY", "skewX", "skewY", "rotateZ"],
1247 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { transforms3D: ["transformPerspective", "translateZ", "scaleZ", "rotateX", "rotateY"],
1248 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { units: [
1249 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "%", // relative
1250 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "em", "ex", "ch", "rem", // font relative
1251 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "vw", "vh", "vmin", "vmax", // viewport relative
1252 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cm", "mm", "Q", "in", "pc", "pt", "px", // absolute lengths
1253 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "deg", "grad", "rad", "turn", // angles
1254 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "s", "ms" // time
1255 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ],
1256 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { colorNames: {
1257 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "aliceblue": "240,248,255",
1258 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "antiquewhite": "250,235,215",
1259 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "aquamarine": "127,255,212",
1260 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "aqua": "0,255,255",
1261 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "azure": "240,255,255",
1262 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "beige": "245,245,220",
1263 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "bisque": "255,228,196",
1264 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "black": "0,0,0",
1265 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "blanchedalmond": "255,235,205",
1266 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "blueviolet": "138,43,226",
1267 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "blue": "0,0,255",
1268 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "brown": "165,42,42",
1269 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "burlywood": "222,184,135",
1270 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cadetblue": "95,158,160",
1271 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "chartreuse": "127,255,0",
1272 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "chocolate": "210,105,30",
1273 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "coral": "255,127,80",
1274 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cornflowerblue": "100,149,237",
1275 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cornsilk": "255,248,220",
1276 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "crimson": "220,20,60",
1277 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "cyan": "0,255,255",
1278 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkblue": "0,0,139",
1279 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkcyan": "0,139,139",
1280 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgoldenrod": "184,134,11",
1281 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgray": "169,169,169",
1282 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgrey": "169,169,169",
1283 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkgreen": "0,100,0",
1284 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkkhaki": "189,183,107",
1285 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkmagenta": "139,0,139",
1286 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkolivegreen": "85,107,47",
1287 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkorange": "255,140,0",
1288 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkorchid": "153,50,204",
1289 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkred": "139,0,0",
1290 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darksalmon": "233,150,122",
1291 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkseagreen": "143,188,143",
1292 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkslateblue": "72,61,139",
1293 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkslategray": "47,79,79",
1294 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkturquoise": "0,206,209",
1295 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "darkviolet": "148,0,211",
1296 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "deeppink": "255,20,147",
1297 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "deepskyblue": "0,191,255",
1298 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "dimgray": "105,105,105",
1299 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "dimgrey": "105,105,105",
1300 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "dodgerblue": "30,144,255",
1301 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "firebrick": "178,34,34",
1302 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "floralwhite": "255,250,240",
1303 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "forestgreen": "34,139,34",
1304 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "fuchsia": "255,0,255",
1305 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "gainsboro": "220,220,220",
1306 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "ghostwhite": "248,248,255",
1307 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "gold": "255,215,0",
1308 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "goldenrod": "218,165,32",
1309 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "gray": "128,128,128",
1310 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "grey": "128,128,128",
1311 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "greenyellow": "173,255,47",
1312 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "green": "0,128,0",
1313 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "honeydew": "240,255,240",
1314 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "hotpink": "255,105,180",
1315 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "indianred": "205,92,92",
1316 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "indigo": "75,0,130",
1317 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "ivory": "255,255,240",
1318 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "khaki": "240,230,140",
1319 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lavenderblush": "255,240,245",
1320 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lavender": "230,230,250",
1321 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lawngreen": "124,252,0",
1322 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lemonchiffon": "255,250,205",
1323 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightblue": "173,216,230",
1324 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightcoral": "240,128,128",
1325 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightcyan": "224,255,255",
1326 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgoldenrodyellow": "250,250,210",
1327 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgray": "211,211,211",
1328 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgrey": "211,211,211",
1329 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightgreen": "144,238,144",
1330 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightpink": "255,182,193",
1331 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightsalmon": "255,160,122",
1332 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightseagreen": "32,178,170",
1333 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightskyblue": "135,206,250",
1334 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightslategray": "119,136,153",
1335 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightsteelblue": "176,196,222",
1336 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lightyellow": "255,255,224",
1337 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "limegreen": "50,205,50",
1338 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "lime": "0,255,0",
1339 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "linen": "250,240,230",
1340 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "magenta": "255,0,255",
1341 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "maroon": "128,0,0",
1342 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumaquamarine": "102,205,170",
1343 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumblue": "0,0,205",
1344 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumorchid": "186,85,211",
1345 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumpurple": "147,112,219",
1346 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumseagreen": "60,179,113",
1347 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumslateblue": "123,104,238",
1348 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumspringgreen": "0,250,154",
1349 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumturquoise": "72,209,204",
1350 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mediumvioletred": "199,21,133",
1351 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "midnightblue": "25,25,112",
1352 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mintcream": "245,255,250",
1353 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "mistyrose": "255,228,225",
1354 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "moccasin": "255,228,181",
1355 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "navajowhite": "255,222,173",
1356 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "navy": "0,0,128",
1357 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "oldlace": "253,245,230",
1358 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "olivedrab": "107,142,35",
1359 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "olive": "128,128,0",
1360 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "orangered": "255,69,0",
1361 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "orange": "255,165,0",
1362 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "orchid": "218,112,214",
1363 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "palegoldenrod": "238,232,170",
1364 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "palegreen": "152,251,152",
1365 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "paleturquoise": "175,238,238",
1366 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "palevioletred": "219,112,147",
1367 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "papayawhip": "255,239,213",
1368 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "peachpuff": "255,218,185",
1369 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "peru": "205,133,63",
1370 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "pink": "255,192,203",
1371 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "plum": "221,160,221",
1372 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "powderblue": "176,224,230",
1373 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "purple": "128,0,128",
1374 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "red": "255,0,0",
1375 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "rosybrown": "188,143,143",
1376 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "royalblue": "65,105,225",
1377 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "saddlebrown": "139,69,19",
1378 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "salmon": "250,128,114",
1379 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "sandybrown": "244,164,96",
1380 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "seagreen": "46,139,87",
1381 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "seashell": "255,245,238",
1382 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "sienna": "160,82,45",
1383 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "silver": "192,192,192",
1384 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "skyblue": "135,206,235",
1385 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "slateblue": "106,90,205",
1386 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "slategray": "112,128,144",
1387 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "snow": "255,250,250",
1388 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "springgreen": "0,255,127",
1389 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "steelblue": "70,130,180",
1390 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "tan": "210,180,140",
1391 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "teal": "0,128,128",
1392 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "thistle": "216,191,216",
1393 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "tomato": "255,99,71",
1394 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "turquoise": "64,224,208",
1395 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "violet": "238,130,238",
1396 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "wheat": "245,222,179",
1397 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "whitesmoke": "245,245,245",
1398 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "white": "255,255,255",
1399 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "yellowgreen": "154,205,50",
1400 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "yellow": "255,255,0"
1401 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1402 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1403 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /************
1404 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Hooks
1405 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ************/
1406  
1407 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Hooks allow a subproperty (e.g. "boxShadowBlur") of a compound-value CSS property
1408 < 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. */
1409 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: Beyond enabling fine-grained property animation, hooking is necessary since Velocity only
1410 < 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. */
1411 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Hooks: {
1412 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /********************
1413 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Registration
1414 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { ********************/
1415  
1416 < 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. */
1417 < 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. */
1418 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { templates: {
1419 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "textShadow": ["Color X Y Blur", "black 0px 0px 0px"],
1420 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "boxShadow": ["Color X Y Blur Spread", "black 0px 0px 0px 0px"],
1421 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "clip": ["Top Right Bottom Left", "0px 0px 0px 0px"],
1422 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "backgroundPosition": ["X Y", "0% 0%"],
1423 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "transformOrigin": ["X Y Z", "50% 50% 0px"],
1424 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { "perspectiveOrigin": ["X Y", "50% 50%"]
1425 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1426 < 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,
1427 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { tweenable property. It contains data to associate it with its root property. */
1428 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { registered: {
1429 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Note: A registered hook looks like this ==> textShadowBlur: [ "textShadow", 3 ],
1430 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { which consists of the subproperty's name, the associated root property's name,
1431 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and the subproperty's position in the root's value. */
1432 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1433 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Convert the templates into individual hooks then append them to the registered object above. */
1434 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { register: function() {
1435 < 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
1436 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { currently set to "transparent" default to their respective template below when color-animated,
1437 < 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"),
1438 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { which is almost always set closer to black than white. */
1439 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (var i = 0; i < CSS.Lists.colors.length; i++) {
1440 < 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";
1441 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS.Hooks.templates[CSS.Lists.colors[i]] = ["Red Green Blue Alpha", rgbComponents];
1442 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1443  
1444 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var rootProperty,
1445 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookTemplate,
1446 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames;
1447  
1448 < 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.
1449 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Thus, we re-arrange the templates accordingly. */
1450 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (IE) {
1451 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (rootProperty in CSS.Hooks.templates) {
1452 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!CSS.Hooks.templates.hasOwnProperty(rootProperty)) {
1453 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { continue;
1454 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1455 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookTemplate = CSS.Hooks.templates[rootProperty];
1456 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames = hookTemplate[0].split(" ");
1457  
1458 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var defaultValues = hookTemplate[1].match(CSS.RegEx.valueSplit);
1459  
1460 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookNames[0] === "Color") {
1461 < 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. */
1462 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames.push(hookNames.shift());
1463 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { defaultValues.push(defaultValues.shift());
1464  
1465 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Replace the existing template for the hook's root property. */
1466 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS.Hooks.templates[rootProperty] = [hookNames.join(" "), defaultValues.join(" ")];
1467 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1468 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1469 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1470  
1471 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Hook registration. */
1472 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (rootProperty in CSS.Hooks.templates) {
1473 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!CSS.Hooks.templates.hasOwnProperty(rootProperty)) {
1474 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { continue;
1475 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1476 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookTemplate = CSS.Hooks.templates[rootProperty];
1477 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookNames = hookTemplate[0].split(" ");
1478  
1479 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { for (var j in hookNames) {
1480 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!hookNames.hasOwnProperty(j)) {
1481 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { continue;
1482 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1483 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var fullHookName = rootProperty + hookNames[j],
1484 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookPosition = j;
1485  
1486 < 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)
1487 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and the hook's position in its template's default value string. */
1488 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { CSS.Hooks.registered[fullHookName] = [rootProperty, hookPosition];
1489 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1490 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1491 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1492 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*****************************
1493 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Injection and Extraction
1494 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *****************************/
1495  
1496 < 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"). */
1497 < 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. */
1498 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { getRoot: function(property) {
1499 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookData = CSS.Hooks.registered[property];
1500  
1501 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookData) {
1502 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return hookData[0];
1503 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1504 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If there was no hook match, return the property name untouched. */
1505 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return property;
1506 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1507 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1508 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { getUnit: function(str, start) {
1509 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var unit = (str.substr(start || 0, 5).match(/^[a-z%]+/) || [])[0] || "";
1510  
125 office 1511 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (unit && _inArray(CSS.Lists.units, unit)) {
77 office 1512 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return unit;
1513 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1514 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "";
1515 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1516 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { fixColors: function(str) {
1517 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return str.replace(/(rgba?\(\s*)?(\b[a-z]+\b)/g, function($0, $1, $2) {
1518 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.Lists.colorNames.hasOwnProperty($2)) {
1519 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return ($1 ? $1 : "rgba(") + CSS.Lists.colorNames[$2] + ($1 ? "" : ",1)");
1520 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1521 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return $1 + $2;
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) { /* Convert any rootPropertyValue, null or otherwise, into a space-delimited list of hook values so that
1525 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { the targeted hook can be injected or extracted at its standard position. */
1526 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { cleanRootPropertyValue: function(rootProperty, rootPropertyValue) {
1527 < 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. */
1528 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.RegEx.valueUnwrap.test(rootPropertyValue)) {
1529 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = rootPropertyValue.match(CSS.RegEx.valueUnwrap)[1];
1530 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1531  
1532 < 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),
1533 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { default to the root's default value as defined in CSS.Hooks.templates. */
1534 < 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
1535 < 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. */
1536 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.Values.isCSSNullValue(rootPropertyValue)) {
1537 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = CSS.Hooks.templates[rootProperty][1];
1538 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1539  
1540 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue;
1541 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1542 < 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. */
1543 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extractValue: function(fullHookName, rootPropertyValue) {
1544 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookData = CSS.Hooks.registered[fullHookName];
1545  
1546 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookData) {
1547 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookRoot = hookData[0],
1548 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookPosition = hookData[1];
1549  
1550 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = CSS.Hooks.cleanRootPropertyValue(hookRoot, rootPropertyValue);
1551  
1552 < 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. */
1553 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue.toString().match(CSS.RegEx.valueSplit)[hookPosition];
1554 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1555 < 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. */
1556 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue;
1557 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1558 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1559 < 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
1560 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { once Velocity has updated one of its individually hooked values through tweening. */
1561 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { injectValue: function(fullHookName, hookValue, rootPropertyValue) {
1562 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookData = CSS.Hooks.registered[fullHookName];
1563  
1564 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (hookData) {
1565 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var hookRoot = hookData[0],
1566 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { hookPosition = hookData[1],
1567 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueParts,
1568 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueUpdated;
1569  
1570 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValue = CSS.Hooks.cleanRootPropertyValue(hookRoot, rootPropertyValue);
1571  
1572 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Split rootPropertyValue into its individual hook values, replace the targeted value with hookValue,
1573 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { then reconstruct the rootPropertyValue string. */
1574 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueParts = rootPropertyValue.toString().match(CSS.RegEx.valueSplit);
1575 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueParts[hookPosition] = hookValue;
1576 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { rootPropertyValueUpdated = rootPropertyValueParts.join(" ");
1577  
1578 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValueUpdated;
1579 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1580 < 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. */
1581 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return rootPropertyValue;
1582 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1583 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1584 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1585 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /*******************
1586 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Normalizations
1587 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { *******************/
1588  
1589 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Normalizations standardize CSS property manipulation by pollyfilling browser-specific implementations (e.g. opacity)
1590 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { and reformatting special properties (e.g. clip, rgba) to look like standard ones. */
1591 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { Normalizations: {
1592 < 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),
1593 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { the targeted element (which may need to be queried), and the targeted property value. */
1594 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { registered: {
1595 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { clip: function(type, element, propertyValue) {
1596 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { switch (type) {
1597 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "name":
1598 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "clip";
1599 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Clip needs to be unwrapped and stripped of its commas during extraction. */
1600 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "extract":
1601 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var extracted;
1602  
1603 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If Velocity also extracted this value, skip extraction. */
1604 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (CSS.RegEx.wrappedValueAlreadyExtracted.test(propertyValue)) {
1605 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = propertyValue;
1606 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1607 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Remove the "rect()" wrapper. */
1608 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = propertyValue.toString().match(CSS.RegEx.valueUnwrap);
1609  
1610 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Strip off commas. */
1611 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = extracted ? extracted[1].replace(/,(\s+)?/g, " ") : propertyValue;
1612 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1613  
1614 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return extracted;
1615 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Clip needs to be re-wrapped during injection. */
1616 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "inject":
1617 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "rect(" + propertyValue + ")";
1618 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1619 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1620 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { blur: function(type, element, propertyValue) {
1621 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { switch (type) {
1622 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "name":
1623 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return Velocity.State.isFirefox ? "filter" : "-webkit-filter";
1624 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "extract":
1625 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var extracted = parseFloat(propertyValue);
1626  
1627 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If extracted is NaN, meaning the value isn't already extracted. */
1628 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!(extracted || extracted === 0)) {
1629 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { var blurComponent = propertyValue.toString().match(/blur\(([0-9]+[A-z]+)\)/i);
1630  
1631 < 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. */
1632 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (blurComponent) {
1633 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = blurComponent[1];
1634 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* If the component doesn't exist, default blur to 0. */
1635 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1636 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { extracted = 0;
1637 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1638 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1639  
1640 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return extracted;
1641 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { /* Blur needs to be re-wrapped during injection. */
1642 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { case "inject":
1643 < 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. */
1644 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (!parseFloat(propertyValue)) {
1645 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "none";
1646 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { } else {
1647 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { return "blur(" + propertyValue + ")";
1648 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1649 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { }
1650 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { },
1651 < 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. */
1652 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { opacity: function(type, element, propertyValue) {
1653 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (IE <= 8) {
1654 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { switch (type) {
1655 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "name":
1656 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "filter";
1657 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "extract":
1658 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* <=IE8 return a "filter" value of "alpha(opacity=\d{1,3})".
1659 < 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. */
1660 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { var extracted = propertyValue.toString().match(/alpha\(opacity=(.*)\)/i);
1661  
1662 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { if (extracted) {
1663 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Convert to decimal value. */
1664 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { propertyValue = extracted[1] / 100;
1665 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { } else {
1666 < 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. */
1667 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { propertyValue = 1;
1668 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1669  
1670 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return propertyValue;
1671 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "inject":
1672 < 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. */
1673 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { element.style.zoom = 1;
1674  
1675 < 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
1676 < 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
1677 < 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. */
1678 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { if (parseFloat(propertyValue) >= 1) {
1679 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "";
1680 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { } else {
1681 < 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. */
1682 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "alpha(opacity=" + parseInt(parseFloat(propertyValue) * 100, 10) + ")";
1683 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1684 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1685 < 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. */
1686 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { } else {
1687 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { switch (type) {
1688 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "name":
1689 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return "opacity";
1690 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "extract":
1691 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return propertyValue;
1692 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { case "inject":
1693 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { return propertyValue;
1694 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1695 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1696 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1697 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { },
1698 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /*****************************
1699 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { Batched Registrations
1700 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { *****************************/
1701  
1702 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Note: Batched normalizations extend the CSS.Normalizations.registered object. */
1703 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { register: function() {
1704  
1705 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /*****************
1706 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { Transforms
1707 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { *****************/
1708  
1709 < 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
1710 < 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. */
1711 < 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
1712 < 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.
1713 < 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
1714 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { once when multiple transform subproperties are being animated simultaneously. */
1715 < 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
1716 < 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
1717 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { from being normalized for these browsers so that tweening skips these properties altogether
1718 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { (since it will ignore them as being unsupported by the browser.) */
1719 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { if ((!IE || IE > 9) && !Velocity.State.isGingerbread) {
1720 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { /* Note: Since the standalone CSS "perspective" property and the CSS transform "perspective" subproperty
1721 < 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". */
1722 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { CSS.Lists.transformsBase = CSS.Lists.transformsBase.concat(CSS.Lists.transforms3D);
1723 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { }
1724  
1725 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) { for (var i = 0; i < CSS.Lists.transformsBase.length; i++) {
1726 < 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
1727 < 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.) */
1728 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { (function() {
1729 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var transformName = CSS.Lists.transformsBase[i];
1730  
1731 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { CSS.Normalizations.registered[transformName] = function(type, element, propertyValue) {
1732 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { switch (type) {
1733 < 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. */
1734 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "name":
1735 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return "transform";
1736 < 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. */
1737 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "extract":
1738 < 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. */
1739 < 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) {
1740 < 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. */
1741 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return /^scale/i.test(transformName) ? 1 : 0;
1742 < 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.
1743 < 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. */
1744 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1745 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return Data(element).transformCache[transformName].replace(/[()]/g, "");
1746 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "inject":
1747 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var invalid = false;
1748  
1749 < 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.
1750 < 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. */
1751 < 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. */
1752 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { switch (transformName.substr(0, transformName.length - 1)) {
1753 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Whitelist unit types for each transform. */
1754 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "translate":
1755 < 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);
1756 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
1757 < 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. */
1758 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "scal":
1759 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "scale":
1760 < 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
1761 < 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
1762 < 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 */
1763 < 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) {
1764 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { propertyValue = 1;
1765 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1766  
1767 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(\d)$/i.test(propertyValue);
1768 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
1769 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "skew":
1770 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(deg|\d)$/i.test(propertyValue);
1771 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
1772 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "rotate":
1773 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { invalid = !/(deg|\d)$/i.test(propertyValue);
1774 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { break;
1775 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1776  
1777 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (!invalid) {
1778 < 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. */
1779 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { Data(element).transformCache[transformName] = "(" + propertyValue + ")";
1780 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1781  
1782 < 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. */
1783 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return Data(element).transformCache[transformName];
1784 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1785 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { };
1786 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { })();
1787 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1788  
1789 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /*************
1790 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { Colors
1791 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { *************/
1792  
1793 < 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.
1794 < 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. */
1795 < 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++) {
1796 < 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.
1797 < 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.) */
1798 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { (function() {
1799 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var colorName = CSS.Lists.colors[j];
1800  
1801 < 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. */
1802 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { CSS.Normalizations.registered[colorName] = function(type, element, propertyValue) {
1803 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { switch (type) {
1804 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "name":
1805 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return colorName;
1806 < 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.) */
1807 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "extract":
1808 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var extracted;
1809  
1810 < 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. */
1811 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (CSS.RegEx.wrappedValueAlreadyExtracted.test(propertyValue)) {
1812 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { extracted = propertyValue;
1813 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else {
1814 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { var converted,
1815 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { colorNames = {
1816 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { black: "rgb(0, 0, 0)",
1817 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { blue: "rgb(0, 0, 255)",
1818 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { gray: "rgb(128, 128, 128)",
1819 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { green: "rgb(0, 128, 0)",
1820 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { red: "rgb(255, 0, 0)",
1821 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { white: "rgb(255, 255, 255)"
1822 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { };
1823  
1824 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Convert color names to rgb. */
1825 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (/^[A-z]+$/i.test(propertyValue)) {
1826 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (colorNames[propertyValue] !== undefined) {
1827 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = colorNames[propertyValue];
1828 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else {
1829 < 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. */
1830 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = colorNames.black;
1831 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1832 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { /* Convert hex values to rgb. */
1833 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else if (CSS.RegEx.isHex.test(propertyValue)) {
1834 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = "rgb(" + CSS.Values.hexToRgb(propertyValue).join(" ") + ")";
1835 < 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. */
1836 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { } else if (!(/^rgba?\(/i.test(propertyValue))) {
1837 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { converted = colorNames.black;
1838 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1839  
1840 < 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
1841 < 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). */
1842 < 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, " ");
1843 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1844  
1845 < 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). */
1846 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if ((!IE || IE > 8) && extracted.split(" ").length === 3) {
1847 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { extracted += " 1";
1848 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1849  
1850 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return extracted;
1851 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { case "inject":
1852 < 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 */
1853 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (/^rgb/.test(propertyValue)) {
1854 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { return propertyValue;
1855 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { }
1856  
1857 < 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. */
1858 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) { if (IE <= 8) {
1859 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (propertyValue.split(" ").length === 4) {
1860 < 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(" ");
1861 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1862 < 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). */
1863 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { } else if (propertyValue.split(" ").length === 3) {
1864 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { propertyValue += " 1";
1865 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1866  
1867 < 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
1868 < 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). */
1869 < 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, "") + ")";
1870 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1871 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { };
1872 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { })();
1873 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1874  
1875 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /**************
1876 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { Dimensions
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) { function augmentDimension(name, element, wantInner) {
1879 < 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";
1880  
1881 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (isBorderBox === (wantInner || false)) {
1882 < 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. */
1883 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { var i,
1884 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { value,
1885 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { augment = 0,
1886 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { sides = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"],
1887 < 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"];
1888  
1889 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { for (i = 0; i < fields.length; i++) {
1890 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { value = parseFloat(CSS.getPropertyValue(element, fields[i]));
1891 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (!isNaN(value)) {
1892 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { augment += value;
1893 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1894 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1895 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return wantInner ? -augment : augment;
1896 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1897 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return 0;
1898 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1899 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { function getDimension(name, wantInner) {
1900 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return function(type, element, propertyValue) {
1901 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { switch (type) {
1902 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { case "name":
1903 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return name;
1904 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { case "extract":
1905 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return parseFloat(propertyValue) + augmentDimension(name, element, wantInner);
1906 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { case "inject":
1907 < 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";
1908 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1909 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { };
1910 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1911 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.innerWidth = getDimension("width", true);
1912 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.innerHeight = getDimension("height", true);
1913 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.outerWidth = getDimension("width");
1914 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS.Normalizations.registered.outerHeight = getDimension("height");
1915 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1916 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { },
1917 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { /************************
1918 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { CSS Property Names
1919 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { ************************/
1920  
1921 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { Names: {
1922 < 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").
1923 < 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. */
1924 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { camelCase: function(property) {
1925 < 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) {
1926 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return subMatch.toUpperCase();
1927 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { });
1928 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { },
1929 < 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). */
1930 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { SVGAttribute: function(property) {
1931 < 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";
1932  
1933 < 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.) */
1934 < 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)) {
1935 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { SVGAttributes += "|transform";
1936 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { }
1937  
1938 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return new RegExp("^(" + SVGAttributes + ")$", "i").test(property);
1939 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { },
1940 < 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. */
1941 < 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.
1942 < 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. */
1943 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { prefixCheck: function(property) {
1944 < 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. */
1945 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { if (Velocity.State.prefixMatches[property]) {
1946 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { return [Velocity.State.prefixMatches[property], true];
1947 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { } else {
1948 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) { var vendors = ["", "Webkit", "Moz", "ms", "O"];
1949  
1950 < 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++) {
1951 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyPrefixed;
1952  
1953 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (i === 0) {
1954 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyPrefixed = property;
1955 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
1956 < 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). */
1957 < 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) {
1958 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return match.toUpperCase();
1959 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
1960 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
1961  
1962 < 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. */
1963 < 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])) {
1964 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Cache the match. */
1965 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.prefixMatches[property] = propertyPrefixed;
1966  
1967 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [propertyPrefixed, true];
1968 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
1969 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
1970  
1971 < 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. */
1972 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [property, false];
1973 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
1974 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
1975 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
1976 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
1977 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS Property Values
1978 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
1979  
1980 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Values: {
1981 < 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 */
1982 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hexToRgb: function(hex) {
1983 < 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,
1984 < 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,
1985 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rgbParts;
1986  
1987 < 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) {
1988 < 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;
1989 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
1990  
1991 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rgbParts = longformRegex.exec(hex);
1992  
1993 < 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];
1994 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
1995 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isCSSNullValue: function(value) {
1996 < 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.
1997 < 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. */
1998 < 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
1999 < 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). */
2000 < 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". */
2001 < 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));
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++) { /* Retrieve a property's default unit type. Used for assigning a unit type when one is not supplied by the user. */
2004 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { getUnitType: function(property) {
2005 < 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)) {
2006 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "deg";
2007 < 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)) {
2008 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* The above properties are unitless. */
2009 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "";
2010 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2011 < 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. */
2012 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "px";
2013 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2014 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
2015 < 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. */
2016 < 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. */
2017 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { getDisplayType: function(element) {
2018 < 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();
2019  
2020 < 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)) {
2021 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "inline";
2022 < 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)) {
2023 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "list-item";
2024 < 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)) {
2025 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "table-row";
2026 < 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)) {
2027 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "table";
2028 < 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)) {
2029 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "table-row-group";
2030 < 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. */
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++) { return "block";
2033 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2034 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
2035 < 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. */
2036 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { addClass: function(element, className) {
2037 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element) {
2038 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element.classList) {
2039 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.classList.add(className);
2040 < 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)) {
2041 < 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
2042 < 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;
2043 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2044 < 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
2045 < 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") || "";
2046  
2047 < 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);
2048 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2049 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2050 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
2051 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { removeClass: function(element, className) {
2052 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element) {
2053 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element.classList) {
2054 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.classList.remove(className);
2055 < 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)) {
2056 < 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
2057 < 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?
2058 < 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"), " ");
2059 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2060 < 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
2061 < 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") || "";
2062  
2063 < 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"), " "));
2064 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2065 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2066 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2067 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
2068 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /****************************
2069 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Style Getting & Setting
2070 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ****************************/
2071  
2072 < 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. */
2073 < 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) {
2074 < 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. */
2075 < 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
2076 < 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
2077 < 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 */
2078 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function computePropertyValue(element, property) {
2079 < 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
2080 < 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
2081 < 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.
2082 < 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. */
2083 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var computedValue = 0;
2084  
2085 < 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
2086 < 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
2087 < 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
2088 < 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. */
2089 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE <= 8) {
2090 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = $.css(element, property); /* GET */
2091 < 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
2092 < 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. */
2093 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2094 < 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
2095 < 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. */
2096 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var toggleDisplay = false;
2097  
2098 < 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) {
2099 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { toggleDisplay = true;
2100 < 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));
2101 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2102  
2103 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var revertDisplay = function() {
2104 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (toggleDisplay) {
2105 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.setPropertyValue(element, "display", "none");
2106 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2107 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2108  
2109 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!forceStyleLookup) {
2110 < 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") {
2111 < 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);
2112 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revertDisplay();
2113  
2114 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return contentBoxHeight;
2115 < 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") {
2116 < 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);
2117 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revertDisplay();
2118  
2119 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return contentBoxWidth;
2120 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2121 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2122  
2123 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var computedStyle;
2124  
2125 < 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
2126 < 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. */
2127 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) === undefined) {
2128 < 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 */
2129 < 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. */
2130 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (!Data(element).computedStyle) {
2131 < 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 */
2132 < 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. */
2133 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2134 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedStyle = Data(element).computedStyle;
2135 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2136  
2137 < 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.
2138 < 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.
2139 < 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. */
2140 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (property === "borderColor") {
2141 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { property = "borderTopColor";
2142 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2143  
2144 < 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
2145 < 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. */
2146 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE === 9 && property === "filter") {
2147 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = computedStyle.getPropertyValue(property); /* GET */
2148 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2149 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = computedStyle[property];
2150 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2151  
2152 < 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,
2153 < 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. */
2154 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (computedValue === "" || computedValue === null) {
2155 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { computedValue = element.style[property];
2156 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2157  
2158 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { revertDisplay();
2159 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2160  
2161 < 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,
2162 < 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
2163 < 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.) */
2164 < 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"
2165 < 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
2166 < 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"). */
2167 < 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)) {
2168 < 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 */
2169  
2170 < 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;
2171 < 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. */
2172 < 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().
2173 < 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. */
2174 < 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))) {
2175 < 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. */
2176 < 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 */
2177 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2178 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2179  
2180 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return computedValue;
2181 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2182  
2183 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyValue;
2184  
2185 < 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"),
2186 < 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(). */
2187 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Hooks.registered[property]) {
2188 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var hook = property,
2189 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hookRoot = CSS.Hooks.getRoot(hook);
2190  
2191 < 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),
2192 < 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. */
2193 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (rootPropertyValue === undefined) {
2194 < 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. */
2195 < 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 */
2196 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2197  
2198 < 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. */
2199 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Normalizations.registered[hookRoot]) {
2200 < 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);
2201 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2202  
2203 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Extract the hook's value. */
2204 < 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);
2205  
2206 < 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"),
2207 < 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. */
2208 < 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
2209 < 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. */
2210 < 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]) {
2211 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var normalizedPropertyName,
2212 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { normalizedPropertyValue;
2213  
2214 < 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);
2215  
2216 < 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.
2217 < 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.
2218 < 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;
2219 < 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). */
2220 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (normalizedPropertyName !== "transform") {
2221 < 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 */
2222  
2223 < 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. */
2224 < 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]) {
2225 < 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];
2226 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2227 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2228  
2229 < 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);
2230 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2231  
2232 < 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. */
2233 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!/^[\d-]/.test(propertyValue)) {
2234 < 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
2235 < 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. */
2236 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data = Data(element);
2237  
2238 < 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)) {
2239 < 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.
2240 < 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. */
2241 < 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)) {
2242 < 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. */
2243 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { try {
2244 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = element.getBBox()[property];
2245 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } catch (error) {
2246 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = 0;
2247 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2248 < 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. */
2249 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2250 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = element.getAttribute(property);
2251 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2252 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2253 < 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 */
2254 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2255 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2256  
2257 < 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),
2258 < 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. */
2259 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Values.isCSSNullValue(propertyValue)) {
2260 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = 0;
2261 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2262  
2263 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug >= 2) {
2264 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log("Get " + property + ": " + propertyValue);
2265 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2266  
2267 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return propertyValue;
2268 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
2269 < 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. */
2270 < 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) {
2271 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var propertyName = property;
2272  
2273 < 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. */
2274 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (property === "scroll") {
2275 < 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. */
2276 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (scrollData.container) {
2277 < 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;
2278 < 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. */
2279 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2280 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (scrollData.direction === "Left") {
2281 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { window.scrollTo(propertyValue, scrollData.alternateValue);
2282 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2283 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { window.scrollTo(scrollData.alternateValue, propertyValue);
2284 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2285 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2286 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2287 < 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().
2288 < 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. */
2289 < 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") {
2290 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Perform a normalization injection. */
2291 < 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. */
2292 < 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);
2293  
2294 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyName = "transform";
2295 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertyValue = Data(element).transformCache[property];
2296 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2297 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Inject hooks. */
2298 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Hooks.registered[property]) {
2299 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var hookName = property,
2300 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { hookRoot = CSS.Hooks.getRoot(property);
2301  
2302 < 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. */
2303 < 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 */
2304  
2305 < 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);
2306 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { property = hookRoot;
2307 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2308  
2309 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Normalize names and values. */
2310 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Normalizations.registered[property]) {
2311 < 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);
2312 < 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);
2313 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2314  
2315 < 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. */
2316 < 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];
2317  
2318 < 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.
2319 < 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. */
2320 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE <= 8) {
2321 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { try {
2322 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.style[propertyName] = propertyValue;
2323 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } catch (error) {
2324 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
2325 < 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 + "]");
2326 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2327 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2328 < 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. */
2329 < 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. */
2330 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2331 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data = Data(element);
2332  
2333 < 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)) {
2334 < 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. */
2335 < 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. */
2336 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.setAttribute(property, propertyValue);
2337 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2338 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element.style[propertyName] = propertyValue;
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++) { }
2341  
2342 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug >= 2) {
2343 < 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);
2344 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2345 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2346 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2347  
2348 < 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. */
2349 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [propertyName, propertyValue];
2350 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
2351 < 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. */
2352 < 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. */
2353 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { flushTransformCache: function(element) {
2354 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var transformString = "",
2355 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
2356  
2357 < 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
2358 < 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). */
2359 < 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) {
2360 < 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.
2361 < 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. */
2362 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var getTransformFloat = function(transformProperty) {
2363 < 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));
2364 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2365  
2366 < 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,
2367 < 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). */
2368 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var SVGTransforms = {
2369 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { translate: [getTransformFloat("translateX"), getTransformFloat("translateY")],
2370 < 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")],
2371 < 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
2372 < 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). */
2373 < 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")],
2374 < 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
2375 < 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). */
2376 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rotate: [getTransformFloat("rotateZ"), 0, 0]
2377 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2378  
2379 < 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.
2380 < 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.) */
2381 < 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) {
2382 < 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
2383 < 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. */
2384 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^translate/i.test(transformName)) {
2385 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "translate";
2386 < 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)) {
2387 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "scale";
2388 < 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)) {
2389 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "rotate";
2390 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2391  
2392 < 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. */
2393 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (SVGTransforms[transformName]) {
2394 < 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. */
2395 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformString += transformName + "(" + SVGTransforms[transformName].join(" ") + ")" + " ";
2396  
2397 < 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
2398 < 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. */
2399 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete SVGTransforms[transformName];
2400 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2401 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2402 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2403 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var transformValue,
2404 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { perspective;
2405  
2406 < 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. */
2407 < 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) {
2408 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformValue = Data(element).transformCache[transformName];
2409  
2410 < 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. */
2411 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (transformName === "transformPerspective") {
2412 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { perspective = transformValue;
2413 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
2414 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2415  
2416 < 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". */
2417 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (IE === 9 && transformName === "rotateZ") {
2418 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformName = "rotate";
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++) { transformString += transformName + transformValue + " ";
2422 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2423  
2424 < 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. */
2425 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (perspective) {
2426 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { transformString = "perspective" + perspective + " " + transformString;
2427 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2428 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2429  
2430 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.setPropertyValue(element, "transform", transformString);
2431 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2432 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2433  
2434 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Register hooks and normalizations. */
2435 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.Hooks.register();
2436 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { CSS.Normalizations.register();
2437  
2438 < 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(). */
2439 < 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) {
2440 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var value;
2441  
2442 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = sanitizeElements(elements);
2443  
2444 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
2445 < 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. */
2446 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) === undefined) {
2447 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.init(element);
2448 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2449  
2450 < 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. */
2451 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (arg3 === undefined) {
2452 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (value === undefined) {
2453 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { value = CSS.getPropertyValue(element, arg2);
2454 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2455 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Set property value. */
2456 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2457 < 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. */
2458 < 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);
2459  
2460 < 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. */
2461 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (adjustedSet[0] === "transform") {
2462 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.CSS.flushTransformCache(element);
2463 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2464  
2465 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { value = adjustedSet;
2466 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2467 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2468  
2469 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return value;
2470 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2471  
2472 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************
2473 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Animation
2474 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************/
2475  
2476 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var animate = function() {
2477 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var opts;
2478  
2479 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
2480 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call Chain
2481 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
2482  
2483 < 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. */
2484 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function getChain() {
2485 < 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,
2486 < 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. */
2487 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (isUtility) {
2488 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return promiseData.promise || null;
2489 < 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. */
2490 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2491 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return elementsWrapped;
2492 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2493 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2494  
2495 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************
2496 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Arguments Assignment
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++) { /* To allow for expressive CoffeeScript code, Velocity supports an alternative syntax in which "elements" (or "e"), "properties" (or "p"), and "options" (or "o")
2500 < 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. */
2501 < 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. */
2502 < 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)))),
2503 < 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). */
2504 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isUtility,
2505 < 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
2506 < 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. */
2507 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsWrapped,
2508 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { argumentIndex;
2509  
2510 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var elements,
2511 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertiesMap,
2512 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options;
2513  
2514 < 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. */
2515 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isWrapped(this)) {
2516 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isUtility = false;
2517  
2518 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { argumentIndex = 0;
2519 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = this;
2520 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsWrapped = this;
2521 < 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. */
2522 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2523 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { isUtility = true;
2524  
2525 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { argumentIndex = 1;
2526 < 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];
2527 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2528  
2529 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************
2530 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Promises
2531 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************/
2532  
2533 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var promiseData = {
2534 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promise: null,
2535 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { resolver: null,
2536 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rejecter: null
2537 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2538  
2539 < 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
2540 < 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
2541 < 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
2542 < 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. */
2543 < 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
2544 < 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
2545 < 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. */
2546 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (isUtility && Velocity.Promise) {
2547 < 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) {
2548 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver = resolve;
2549 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.rejecter = reject;
2550 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2551 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2552  
2553 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (syntacticSugar) {
2554 < 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;
2555 < 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;
2556 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2557 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { propertiesMap = arguments[argumentIndex];
2558 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options = arguments[argumentIndex + 1];
2559 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2560  
2561 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = sanitizeElements(elements);
2562  
2563 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!elements) {
2564 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
2565 < 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) {
2566 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.rejecter();
2567 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2568 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver();
2569 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2570 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2571 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
2572 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2573  
2574 < 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
2575 < 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). */
2576 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var elementsLength = elements.length,
2577 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsIndex = 0;
2578  
2579 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
2580 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Argument Overloading
2581 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
2582  
2583 < 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]).
2584 < 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. */
2585 < 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. */
2586 < 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)) {
2587 < 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. */
2588 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var startingArgumentPosition = argumentIndex + 1;
2589  
2590 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options = {};
2591  
2592 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through all options arguments */
2593 < 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++) {
2594 < 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. */
2595 < 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.
2596 < 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. */
2597 < 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]))) {
2598 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options.duration = arguments[i];
2599 < 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. */
2600 < 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])) {
2601 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options.easing = arguments[i];
2602 < 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. */
2603 < 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])) {
2604 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { options.complete = arguments[i];
2605 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2606 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2607 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2608  
2609 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
2610 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action Detection
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++) { /* Velocity's behavior is categorized into "actions": Elements can either be specially scrolled into view,
2614 < 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
2615 < 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
2616 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { instead of a properties map. */
2617 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var action;
2618  
2619 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (propertiesMap) {
2620 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "scroll":
2621 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { action = "scroll";
2622 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
2623  
2624 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "reverse":
2625 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { action = "reverse";
2626 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
2627  
2628 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "pause":
2629  
2630 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
2631 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action: Pause
2632 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
2633  
2634 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var currentTime = (new Date()).getTime();
2635  
2636 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle delay timers */
2637 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
2638 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pauseDelayOnElement(element, currentTime);
2639 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2640  
2641 < 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
2642 < 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
2643 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { as well. */
2644  
2645 < 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 */
2646 < 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) {
2647  
2648 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var found = false;
2649 < 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. */
2650 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (activeCall) {
2651 < 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. */
2652 < 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) {
2653 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var queueName = (options === undefined) ? "" : options;
2654  
2655 < 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)) {
2656 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
2657 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2658  
2659 < 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. */
2660 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(l, element) {
2661 < 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. */
2662 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element === activeElement) {
2663  
2664 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Set call to paused */
2665 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeCall[5] = {
2666 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { resume: false
2667 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2668  
2669 < 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 */
2670 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { found = true;
2671 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
2672 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2673 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2674  
2675 < 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 */
2676 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (found) {
2677 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
2678 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2679 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
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++) { });
2683  
2684 < 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. */
2685 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
2686  
2687 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "resume":
2688  
2689 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
2690 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action: Resume
2691 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
2692  
2693 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle delay timers */
2694 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
2695 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { resumeDelayOnElement(element, currentTime);
2696 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2697  
2698 < 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
2699 < 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
2700 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { as well. */
2701  
2702 < 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 */
2703 < 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) {
2704 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var found = false;
2705 < 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. */
2706 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (activeCall) {
2707 < 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. */
2708 < 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) {
2709 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var queueName = (options === undefined) ? "" : options;
2710  
2711 < 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)) {
2712 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
2713 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2714  
2715 < 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 */
2716 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!activeCall[5]) {
2717 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
2718 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2719  
2720 < 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. */
2721 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(l, element) {
2722 < 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. */
2723 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element === activeElement) {
2724  
2725 < 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
2726 < 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 */
2727 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeCall[5].resume = true;
2728  
2729 < 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 */
2730 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { found = true;
2731 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
2732 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2733 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2734  
2735 < 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 */
2736 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (found) {
2737 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return false;
2738 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2739 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2740 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2741  
2742 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2743  
2744 < 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. */
2745 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
2746  
2747 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "finish":
2748 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "finishAll":
2749 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "stop":
2750 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
2751 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Action: Stop
2752 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
2753  
2754 < 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. */
2755 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
2756 < 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) {
2757 < 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. */
2758 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { clearTimeout(Data(element).delayTimer.setTimeout);
2759  
2760 < 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. */
2761 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element).delayTimer.next) {
2762 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayTimer.next();
2763 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2764  
2765 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete Data(element).delayTimer;
2766 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2767  
2768 < 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
2769 < 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
2770 < 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. */
2771 < 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))) {
2772 < 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. */
2773 < 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) {
2774 < 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. */
2775 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(item)) {
2776 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { item();
2777 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2778 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2779  
2780 < 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 []. */
2781 < 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 : "", []);
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++) { var callsToStop = [];
2786  
2787 < 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
2788 < 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
2789 < 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. */
2790 < 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)
2791 < 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. */
2792 < 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*,
2793 < 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. */
2794  
2795 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through every active call. */
2796 < 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) {
2797 < 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. */
2798 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (activeCall) {
2799 < 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. */
2800 < 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) {
2801 < 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
2802 < 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. */
2803 < 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:
2804 < 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.
2805 < 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.
2806 < 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.
2807 < 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). */
2808 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var queueName = (options === undefined) ? "" : options;
2809  
2810 < 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)) {
2811 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
2812 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2813  
2814 < 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. */
2815 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(l, element) {
2816 < 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. */
2817 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (element === activeElement) {
2818 < 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,
2819 < 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. */
2820 < 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)) {
2821 < 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. */
2822 < 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) {
2823 < 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. */
2824 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(item)) {
2825 < 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.
2826 < 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.) */
2827 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { item(null, true);
2828 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2829 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2830  
2831 < 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 []. */
2832 < 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 : "", []);
2833 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2834  
2835 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (propertiesMap === "stop") {
2836 < 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
2837 < 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. */
2838 < 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
2839 < 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. */
2840 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data = Data(element);
2841 < 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) {
2842 < 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) {
2843 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeTween.endValue = activeTween.currentValue;
2844 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2845 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2846  
2847 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callsToStop.push(i);
2848 < 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") {
2849 < 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
2850 < 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. */
2851 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { activeCall[2].duration = 1;
2852 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2853 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2854 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2855 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2856 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2857 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2858  
2859 < 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
2860 < 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. */
2861 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (propertiesMap === "stop") {
2862 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(callsToStop, function(i, j) {
2863 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { completeCall(j, true);
2864 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
2865  
2866 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
2867 < 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. */
2868 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver(elements);
2869 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2870 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2871  
2872 < 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. */
2873 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
2874  
2875 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
2876 < 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. */
2877 < 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)) {
2878 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { action = "start";
2879  
2880 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /****************
2881 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Redirects
2882 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ****************/
2883  
2884 < 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). */
2885 < 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]) {
2886 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, options);
2887  
2888 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var durationOriginal = opts.duration,
2889 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delayOriginal = opts.delay || 0;
2890  
2891 < 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. */
2892 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.backwards === true) {
2893 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elements = $.extend(true, [], elements).reverse();
2894 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2895  
2896 < 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. */
2897 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(elementIndex, element) {
2898 < 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. */
2899 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (parseFloat(opts.stagger)) {
2900 < 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);
2901 < 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)) {
2902 < 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);
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++) { /* If the drag option was passed in, successively increase/decrease (depending on the presense of opts.backwards)
2906 < 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. */
2907 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.drag) {
2908 < 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. */
2909 < 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);
2910  
2911 < 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,
2912 < 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).
2913 < 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. */
2914 < 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);
2915 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2916  
2917 < 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
2918 < 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. */
2919 < 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);
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++) { /* Since the animation logic resides within the redirect's own code, abort the remainder of this call.
2923 < 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.) */
2924 < 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. */
2925 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
2926 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
2927 < 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.";
2928  
2929 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
2930 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.rejecter(new Error(abortError));
125 office 2931 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (window.console) {
77 office 2932 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { console.log(abortError);
2933 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2934  
2935 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
2936 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2937 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2938  
2939 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
2940 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call-Wide Variables
2941 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
2942  
2943 < 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
2944 < 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
2945 < 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
2946 < 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. */
2947 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var callUnitConversionData = {
2948 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastParent: null,
2949 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastPosition: null,
2950 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastFontSize: null,
2951 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastPercentToPxWidth: null,
2952 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastPercentToPxHeight: null,
2953 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastEmToPx: null,
2954 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { remToPx: null,
2955 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { vwToPx: null,
2956 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { vhToPx: null
2957 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
2958  
2959 < 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
2960 < 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. */
2961 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var call = [];
2962  
2963 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
2964 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Processing
2965 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
2966  
2967 < 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):
2968 < 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.
2969 < 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.
2970 < 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.
2971 < 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.
2972 < 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.
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++) { function processElement(element, elementArrayIndex) {
2975  
2976 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************
2977 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Part I: Pre-Queueing
2978 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************/
2979  
2980 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
2981 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element-Wide Variables
2982 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
2983  
2984 < 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. */
2985 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, Velocity.defaults, options),
2986 < 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.
2987 < 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".) */
2988 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer = {},
2989 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementUnitConversionData;
2990  
2991 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
2992 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Init
2993 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
2994  
2995 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Data(element) === undefined) {
2996 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.init(element);
2997 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
2998  
2999 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
3000 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Delay
3001 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
3002  
3003 < 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). */
3004 < 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()
3005 < 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). */
3006 < 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) {
3007 < 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) {
3008 < 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. */
3009 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.velocityQueueEntryFlag = true;
3010  
3011 < 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.
3012 < 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
3013 < 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. */
3014  
3015 < 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 */
3016 < 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++;
3017 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[callIndex] = element;
3018  
3019 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var delayComplete = (function(index) {
3020 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return function() {
3021 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clear the temporary element */
3022 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[index] = false;
3023  
3024 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Finally, issue the call */
3025 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { next();
3026 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3027 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { })(callIndex);
3028  
3029  
3030 < 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();
3031 < 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);
3032 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayTimer = {
3033 < 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)),
3034 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { next: delayComplete
3035 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3036 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
3037 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3038  
3039 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
3040 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Duration
3041 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
3042  
3043 < 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. */
3044 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (opts.duration.toString().toLowerCase()) {
3045 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "fast":
3046 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = 200;
3047 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3048  
3049 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "normal":
3050 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = DURATION_DEFAULT;
3051 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3052  
3053 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "slow":
3054 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = 600;
3055 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3056  
3057 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
3058 < 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). */
3059 < 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;
3060 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3061  
3062 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
3063 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Global Option: Mock
3064 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
3065  
3066 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.mock !== false) {
3067 < 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.
3068 < 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. */
3069 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.mock === true) {
3070 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.duration = opts.delay = 1;
3071 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3072 < 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;
3073 < 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;
3074 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3075 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3076  
3077 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
3078 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Easing
3079 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
3080  
3081 < 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);
3082  
3083 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**********************
3084 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Callbacks
3085 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **********************/
3086  
3087 < 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. */
3088 < 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)) {
3089 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.begin = null;
3090 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3091  
3092 < 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)) {
3093 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.progress = null;
3094 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3095  
3096 < 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)) {
3097 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.complete = null;
3098 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3099  
3100 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************************
3101 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Display & Visibility
3102 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************************/
3103  
3104 < 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. */
3105 < 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. */
3106 < 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) {
3107 < 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();
3108  
3109 < 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. */
3110 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.display === "auto") {
3111 < 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);
3112 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3113 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3114  
3115 < 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) {
3116 < 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();
3117 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3118  
3119 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**********************
3120 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: mobileHA
3121 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **********************/
3122  
3123 < 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)
3124 < 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. */
3125 < 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. */
3126 < 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. */
3127 < 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);
3128  
3129 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***********************
3130 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Part II: Queueing
3131 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***********************/
3132  
3133 < 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.
3134 < 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. */
3135 < 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,
3136 < 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. */
3137 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function buildQueue(next) {
3138 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var data, lastTweensContainer;
3139  
3140 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*******************
3141 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Begin
3142 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *******************/
3143  
3144 < 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. */
3145 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.begin && elementsIndex === 0) {
3146 < 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. */
3147 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { try {
3148 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.begin.call(elements, elements);
3149 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } catch (error) {
3150 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { setTimeout(function() {
3151 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { throw error;
3152 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }, 1);
3153 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
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++) { /*****************************************
3157 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Construction (for Scroll)
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++) { /* 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. */
3161 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (action === "scroll") {
3162 < 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. */
3163 < 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"),
3164 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollOffset = parseFloat(opts.offset) || 0,
3165 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrent,
3166 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionCurrentAlternate,
3167 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollPositionEnd;
3168  
3169 < 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 --
3170 < 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. */
3171 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.container) {
3172 < 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. */
3173 < 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)) {
3174 < 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. */
3175 < 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;
3176 < 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
3177 < 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). */
3178 < 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 */
3179  
3180 < 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
3181 < 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*
3182 < 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. */
3183 < 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 */
3184 < 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. */
3185 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3186 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts.container = null;
3187 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3188 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3189 < 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
3190 < 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). */
3191 < 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 */
3192 < 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. */
3193 < 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 */
3194  
3195 < 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 --
3196 < 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. */
3197 < 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 */
3198 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3199  
3200 < 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. */
3201 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer = {
3202 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scroll: {
3203 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue: false,
3204 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue: scrollPositionCurrent,
3205 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { currentValue: scrollPositionCurrent,
3206 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue: scrollPositionEnd,
3207 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType: "",
3208 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing: opts.easing,
3209 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { scrollData: {
3210 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { container: opts.container,
3211 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { direction: scrollDirection,
3212 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { alternateValue: scrollPositionCurrentAlternate
3213 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3214 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
3215 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { element: element
3216 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3217  
3218 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
3219 < 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);
3220 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3221  
3222 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************************************
3223 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Construction (for Reverse)
3224 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************************************/
3225  
3226 < 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
3227 < 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
3228 < 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. */
3229 < 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.) */
3230 < 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;
3231 < 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
3232 < 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. */
3233 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (action === "reverse") {
3234 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
3235  
3236 < 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. */
3237 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!data) {
3238 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
3239 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3240  
3241 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!data.tweensContainer) {
3242 < 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. */
3243 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.dequeue(element, opts.queue);
3244  
3245 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
3246 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3247 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
3248 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Options Parsing
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++) { /* If the element was hidden via the display option in the previous call,
3252 < 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. */
3253 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data.opts.display === "none") {
3254 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.display = "auto";
3255 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3256  
3257 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data.opts.visibility === "hidden") {
3258 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.visibility = "visible";
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 the loop option was set in the previous call, disable it so that "reverse" calls aren't recursively generated.
3262 < 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. */
3263 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.loop = false;
3264 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.begin = null;
3265 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts.complete = null;
3266  
3267 < 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,
3268 < 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. */
3269 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!options.easing) {
3270 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete opts.easing;
3271 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3272  
3273 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!options.duration) {
3274 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delete opts.duration;
3275 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3276  
3277 < 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
3278 < 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. */
3279 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, data.opts, opts);
3280  
3281 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************************
3282 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tweens Container Reconstruction
3283 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************************/
3284  
3285 < 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. */
3286 < 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);
3287  
3288 < 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. */
3289 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var lastTween in lastTweensContainer) {
3290 < 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. */
3291 < 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") {
3292 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var lastStartValue = lastTweensContainer[lastTween].startValue;
3293  
3294 < 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;
3295 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer[lastTween].endValue = lastStartValue;
3296  
3297 < 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).
3298 < 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.
3299 < 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. */
3300 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!Type.isEmptyObject(options)) {
3301 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer[lastTween].easing = opts.easing;
3302 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3303  
3304 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
3305 < 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);
3306 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3307 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3308 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3309  
3310 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer = lastTweensContainer;
3311 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3312  
3313 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************************************
3314 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Construction (for Start)
3315 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************************************/
3316  
3317 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (action === "start") {
3318  
3319 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*************************
3320 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Value Transferring
3321 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *************************/
3322  
3323 < 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
3324 < 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
3325 < 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
3326 < 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. */
3327 < 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),
3328 < 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. */
3329 < 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. */
3330  
3331 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
3332  
3333 < 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)
3334 < 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
3335 < 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. */
3336 < 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) {
3337 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { lastTweensContainer = data.tweensContainer;
3338 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3339  
3340 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
3341 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tween Data Calculation
3342 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
3343  
3344 < 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. */
3345 < 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,
3346 < 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] ].
3347 < 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
3348 < 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 */
3349 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var parsePropertyValue = function(valueData, skipResolvingEasing) {
3350 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var endValue, easing, startValue;
3351  
3352 < 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 */
3353 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(valueData)) {
3354 < 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);
3355 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3356  
3357 < 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:
3358 < 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 ] */
3359 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isArray(valueData)) {
3360 < 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
3361 < 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. */
3362 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = valueData[0];
3363  
3364 < 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
3365 < 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. */
3366 < 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])) {
3367 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[1];
3368 < 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. */
3369 < 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])) {
3370 < 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);
3371  
3372 < 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. */
3373 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[2];
3374 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3375 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[1] || valueData[2];
3376 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3377 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle the single-value format. */
3378 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3379 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = valueData;
3380 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3381  
3382 < 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. */
3383 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!skipResolvingEasing) {
3384 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = easing || opts.easing;
3385 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3386  
3387 < 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,
3388 < 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. */
3389 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(endValue)) {
3390 < 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);
3391 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3392  
3393 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isFunction(startValue)) {
3394 < 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);
3395 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3396  
3397 < 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. */
3398 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [endValue || 0, easing, startValue];
3399 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3400  
3401 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var fixPropertyValue = function(property, valueData) {
3402 < 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. */
3403 < 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),
3404 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = false,
3405 < 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. */
3406 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = valueData[0],
3407 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = valueData[1],
3408 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[2],
3409 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern;
3410  
3411 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
3412 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Start Value Sourcing
3413 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
3414  
3415 < 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
3416 < 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.
3417 < 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. */
3418 < 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,
3419 < 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. */
3420 < 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) {
3421 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
3422 < 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.");
3423 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3424 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return;
3425 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3426  
3427 < 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
3428 < 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
3429 < 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. */
3430 < 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) {
3431 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = 0;
3432 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3433  
3434 < 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
3435 < 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. */
3436 < 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. */
3437 < 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]) {
3438 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValue === undefined) {
3439 < 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;
3440 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3441  
3442 < 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
3443 < 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
3444 < 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. */
3445 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue = data.rootPropertyValueCache[rootProperty];
3446 < 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. */
3447 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3448 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Handle hooked properties. */
3449 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (CSS.Hooks.registered[property]) {
3450 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValue === undefined) {
3451 < 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 */
3452 < 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;
3453 < 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. */
3454 < 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);
3455 < 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;
3456 < 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
3457 < 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
3458 < 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. */
3459 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3460 < 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". */
3461 < 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];
3462 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3463 < 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. */
3464 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (startValue === undefined) {
3465 < 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 */
3466 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3467 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3468  
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++) { Value Data Extraction
3471 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
3472  
3473 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var separatedValue,
3474 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType,
3475 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValueUnitType,
3476 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { operator = false;
3477  
3478 < 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. */
3479 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var separateValue = function(property, value) {
3480 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var unitType,
3481 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { numericValue;
3482  
3483 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { numericValue = (value || "0")
3484 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { .toString()
3485 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { .toLowerCase()
3486 < 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. */
3487 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { .replace(/[%A-z]+$/, function(match) {
3488 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Grab the unit type. */
3489 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType = match;
3490  
3491 < 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. */
3492 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "";
3493 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
3494  
3495 < 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). */
3496 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!unitType) {
3497 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType = CSS.Values.getUnitType(property);
3498 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3499  
3500 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return [numericValue, unitType];
3501 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3502  
3503 < 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)) {
3504 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern = "";
3505 < 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
3506 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iEnd = 0, // index in endValue
3507 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart = [], // array of startValue numbers
3508 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd = [], // array of endValue numbers
3509 < 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
3510 < 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
3511 < 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
3512  
3513 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = CSS.Hooks.fixColors(startValue);
3514 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = CSS.Hooks.fixColors(endValue);
3515 < 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) {
3516 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var cStart = startValue[iStart],
3517 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cEnd = endValue[iEnd];
3518  
3519 < 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)) {
3520 < 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
3521 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tEnd = cEnd, // temporary character buffer
3522 < 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
3523 < 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
3524  
3525 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { while (++iStart < startValue.length) {
3526 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cStart = startValue[iStart];
3527 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (cStart === dotStart) {
3528 < 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
3529 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (!/\d/.test(cStart)) {
3530 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
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++) { tStart += cStart;
3533 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3534 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { while (++iEnd < endValue.length) {
3535 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { cEnd = endValue[iEnd];
3536 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (cEnd === dotEnd) {
3537 < 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
3538 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (!/\d/.test(cEnd)) {
3539 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3540 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3541 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tEnd += cEnd;
3542 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3543 < 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
3544 < 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
3545  
3546 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iStart += uStart.length;
3547 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iEnd += uEnd.length;
3548 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (uStart === uEnd) {
3549 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Same units
3550 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (tStart === tEnd) {
3551 < 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
3552 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += tStart + uStart;
3553 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3554 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // Different numbers, so store them
3555 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += "{" + aStart.length + (inRGB ? "!" : "") + "}" + uStart;
3556 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart.push(parseFloat(tStart));
3557 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd.push(parseFloat(tEnd));
3558 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3559 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3560 < 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
3561 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var nStart = parseFloat(tStart),
3562 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { nEnd = parseFloat(tEnd);
3563  
3564 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += (inCalc < 5 ? "calc" : "") + "("
3565 < 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
3566 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { + " + "
3567 < 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
3568 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { + ")";
3569 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (nStart) {
3570 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart.push(nStart);
3571 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd.push(0);
3572 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3573 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (nEnd) {
3574 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aStart.push(0);
3575 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { aEnd.push(nEnd);
3576 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3577 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3578 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (cStart === cEnd) {
3579 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern += cStart;
3580 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iStart++;
3581 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { iEnd++;
3582 < 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()
3583 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (inCalc === 0 && cStart === "c"
3584 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc === 1 && cStart === "a"
3585 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc === 2 && cStart === "l"
3586 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc === 3 && cStart === "c"
3587 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc >= 4 && cStart === "("
3588 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ) {
3589 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc++;
3590 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if ((inCalc && inCalc < 5)
3591 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inCalc >= 4 && cStart === ")" && --inCalc < 5) {
3592 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc = 0;
3593 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3594 < 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()
3595 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (inRGB === 0 && cStart === "r"
3596 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB === 1 && cStart === "g"
3597 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB === 2 && cStart === "b"
3598 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB === 3 && cStart === "a"
3599 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { || inRGB >= 3 && cStart === "("
3600 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ) {
3601 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (inRGB === 3 && cStart === "a") {
3602 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGBA = 1;
3603 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3604 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB++;
3605 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (inRGBA && cStart === ",") {
3606 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (++inRGBA > 3) {
3607 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB = inRGBA = 0;
3608 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3609 < 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))
3610 < 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)) {
3611 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inRGB = inRGBA = 0;
3612 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3613 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3614 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { inCalc = 0;
3615 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { // TODO: changing units, fixing colours
3616 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
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++) { if (iStart !== startValue.length || iEnd !== endValue.length) {
3620 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
3621 < 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 + "\"]");
3622 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3623 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern = undefined;
3624 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3625 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pattern) {
3626 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (aStart.length) {
3627 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
3628 < 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 + "]");
3629 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3630 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = aStart;
3631 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = aEnd;
3632 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = startValueUnitType = "";
3633 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3634 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pattern = undefined;
3635 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3636 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3637 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3638  
3639 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!pattern) {
3640 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Separate startValue. */
3641 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { separatedValue = separateValue(property, startValue);
3642 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = separatedValue[0];
3643 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValueUnitType = separatedValue[1];
3644  
3645 < 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. */
3646 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { separatedValue = separateValue(property, endValue);
3647 < 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) {
3648 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { operator = subMatch;
3649  
3650 < 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. */
3651 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return "";
3652 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
3653 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = separatedValue[1];
3654  
3655 < 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. */
3656 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = parseFloat(startValue) || 0;
3657 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = parseFloat(endValue) || 0;
3658  
3659 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************************
3660 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Property-Specific Value Conversion
3661 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************************/
3662  
3663 < 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. */
3664 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (endValueUnitType === "%") {
3665 < 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),
3666 < 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. */
3667 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/^(fontSize|lineHeight)$/.test(property)) {
3668 < 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. */
3669 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = endValue / 100;
3670 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = "em";
3671 < 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. */
3672 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (/^scale/.test(property)) {
3673 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = endValue / 100;
3674 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = "";
3675 < 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. */
3676 < 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)) {
3677 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = (endValue / 100) * 255;
3678 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = "";
3679 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3680 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3681 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3682  
3683 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
3684 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Unit Ratio Calculation
3685 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
3686  
3687 < 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
3688 < 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
3689 < 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
3690 < 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:
3691 < 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
3692 < 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. */
3693 < 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,
3694 < 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. */
3695 < 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
3696 < 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
3697 < 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. */
3698 < 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. */
3699 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var calculateUnitRatios = function() {
3700  
3701 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
3702 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Same Ratio Checks
3703 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
3704  
3705 < 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
3706 < 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
3707 < 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,
3708 < 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. */
3709 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var sameRatioIndicators = {
3710 < 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 */
3711 < 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 */
3712 < 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 */
3713 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { },
3714 < 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. */
3715 < 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)),
3716 < 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. */
3717 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { sameEmRatio = (sameRatioIndicators.fontSize === callUnitConversionData.lastFontSize);
3718  
3719 < 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. */
3720 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.lastParent = sameRatioIndicators.myParent;
3721 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.lastPosition = sameRatioIndicators.position;
3722 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callUnitConversionData.lastFontSize = sameRatioIndicators.fontSize;
3723  
3724 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
3725 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element-Specific Units
3726 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
3727  
3728 < 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
3729 < 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. */
3730 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var measurement = 100,
3731 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios = {};
3732  
3733 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!sameEmRatio || !samePercentRatio) {
3734 < 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");
3735  
3736 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.init(dummy);
3737 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { sameRatioIndicators.myParent.appendChild(dummy);
3738  
3739 < 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.
3740 < 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. */
3741 < 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. */
3742 < 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) {
3743 < 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");
3744 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
3745 < 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);
3746 < 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);
3747 < 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");
3748  
3749 < 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. */
3750 < 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) {
3751 < 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 + "%");
3752 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
3753 < 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. */
3754 < 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");
3755  
3756 < 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. */
3757 < 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 */
3758 < 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 */
3759 < 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 */
3760  
3761 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { sameRatioIndicators.myParent.removeChild(dummy);
3762 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3763 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.emToPx = callUnitConversionData.lastEmToPx;
3764 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth;
3765 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight;
3766 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3767  
3768 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************************
3769 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element-Agnostic Units
3770 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************************/
3771  
3772 < 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
3773 < 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
3774 < 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,
3775 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { so we calculate it now. */
3776 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (callUnitConversionData.remToPx === null) {
3777 < 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. */
3778 < 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 */
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++) { /* Similarly, viewport units are %-relative to the window's inner dimensions. */
3782 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (callUnitConversionData.vwToPx === null) {
3783 < 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 */
3784 < 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 */
3785 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3786  
3787 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.remToPx = callUnitConversionData.remToPx;
3788 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.vwToPx = callUnitConversionData.vwToPx;
3789 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitRatios.vhToPx = callUnitConversionData.vhToPx;
3790  
3791 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug >= 1) {
3792 < 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);
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++) { return unitRatios;
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++) { Unit Conversion
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++) { /* The * and / operators, which are not passed in with an associated unit, inherently use startValue's unit. Skip value and unit conversion. */
3802 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (/[\/*]/.test(operator)) {
3803 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = startValueUnitType;
3804 < 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
3805 < 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
3806 < 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
3807 < 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. */
3808 < 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. */
3809 < 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) {
3810 < 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. */
3811 < 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
3812 < 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,
3813 < 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. */
3814 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (endValue === 0) {
3815 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueUnitType = startValueUnitType;
3816 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3817 < 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).
3818 < 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. */
3819 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementUnitConversionData = elementUnitConversionData || calculateUnitRatios();
3820  
3821 < 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. */
3822 < 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. */
3823 < 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";
3824  
3825 < 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:
3826 < 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. */
3827 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (startValueUnitType) {
3828 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "%":
3829 < 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.
3830 < 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
3831 < 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. */
3832 < 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);
3833 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3834  
3835 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "px":
3836 < 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. */
3837 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3838  
3839 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
3840 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue *= elementUnitConversionData[startValueUnitType + "ToPx"];
3841 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3842  
3843 < 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. */
3844 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (endValueUnitType) {
3845 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "%":
3846 < 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);
3847 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3848  
3849 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "px":
3850 < 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. */
3851 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3852  
3853 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { default:
3854 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue *= 1 / elementUnitConversionData[endValueUnitType + "ToPx"];
3855 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3856 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3857 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3858  
3859 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
3860 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Relative Values
3861 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
3862  
3863 < 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. */
3864 < 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%"
3865 < 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:
3866 < 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. */
3867 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { switch (operator) {
3868 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "+":
3869 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue + endValue;
3870 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3871  
3872 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "-":
3873 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue - endValue;
3874 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3875  
3876 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "*":
3877 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue * endValue;
3878 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3879  
3880 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { case "/":
3881 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue = startValue / endValue;
3882 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { break;
3883 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3884  
3885 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
3886 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer Push
3887 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
3888  
3889 < 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. */
3890 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer[property] = {
3891 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { rootPropertyValue: rootPropertyValue,
3892 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue: startValue,
3893 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { currentValue: startValue,
3894 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValue: endValue,
3895 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { unitType: endValueUnitType,
3896 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing: easing
3897 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3898 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pattern) {
3899 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer[property].pattern = pattern;
3900 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3901  
3902 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.debug) {
3903 < 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);
3904 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3905 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
3906  
3907 < 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. */
3908 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { for (var property in propertiesMap) {
3909  
3910 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!propertiesMap.hasOwnProperty(property)) {
3911 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
3912 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3913 < 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,
3914 < 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. */
3915 < 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),
3916 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { valueData = parsePropertyValue(propertiesMap[property]);
3917  
3918 < 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. */
3919 < 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 */
125 office 3920 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (_inArray(CSS.Lists.colors, propertyName)) {
77 office 3921 < 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. */
3922 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var endValue = valueData[0],
3923 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { easing = valueData[1],
3924 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { startValue = valueData[2];
3925  
3926 < 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)) {
3927 < 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. */
3928 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var colorComponents = ["Red", "Green", "Blue"],
3929 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { endValueRGB = CSS.Values.hexToRgb(endValue),
3930 < 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;
3931  
3932 < 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. */
3933 < 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++) {
3934 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var dataArray = [endValueRGB[i]];
3935  
3936 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (easing) {
3937 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dataArray.push(easing);
3938 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3939  
3940 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (startValueRGB !== undefined) {
3941 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { dataArray.push(startValueRGB[i]);
3942 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3943  
3944 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { fixPropertyValue(propertyName + colorComponents[i], dataArray);
3945 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3946 < 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 */
3947 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
3948 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3949 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3950 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { fixPropertyValue(propertyName, valueData);
3951 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3952  
3953 < 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. */
3954 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweensContainer.element = element;
3955 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3956  
3957 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*****************
3958 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call Push
3959 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *****************/
3960  
3961 < 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
3962 < 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. */
3963 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (tweensContainer.element) {
3964 < 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. */
3965 < 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");
3966  
3967 < 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. */
3968 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { call.push(tweensContainer);
3969  
3970 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data = Data(element);
3971  
3972 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (data) {
3973 < 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. */
3974 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.queue === "") {
3975  
3976 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.tweensContainer = tweensContainer;
3977 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.opts = opts;
3978 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3979  
3980 < 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. */
3981 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { data.isAnimating = true;
3982 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3983  
3984 < 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
3985 < 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. */
3986 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (elementsIndex === elementsLength - 1) {
3987 < 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.
3988 < 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. */
3989 < 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]);
3990  
3991 < 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.) */
3992 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Velocity.State.isTicking === false) {
3993 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.isTicking = true;
3994  
3995 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Start the tick loop. */
3996 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tick();
3997 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
3998 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
3999 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { elementsIndex++;
4000 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4001 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4002 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4003  
4004 < 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. */
4005 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.queue === false) {
4006 < 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),
4007 < 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. */
4008 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.delay) {
4009  
4010 < 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 */
4011 < 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++;
4012 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[callIndex] = element;
4013  
4014 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var delayComplete = (function(index) {
4015 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return function() {
4016 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Clear the temporary element */
4017 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.State.delayedElements[index] = false;
4018  
4019 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Finally, issue the call */
4020 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { buildQueue();
4021 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
4022 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { })(callIndex);
4023  
4024 < 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();
4025 < 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);
4026 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Data(element).delayTimer = {
4027 < 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)),
4028 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { next: delayComplete
4029 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
4030 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
4031 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { buildQueue();
4032 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4033 < 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. */
4034 < 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. */
4035 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
4036 < 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) {
4037 < 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,
4038 < 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.) */
4039 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (clearQueue === true) {
4040 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (promiseData.promise) {
4041 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { promiseData.resolver(elements);
4042 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4043  
4044 < 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. */
4045 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return true;
4046 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4047  
4048 < 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.
4049 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { See completeCall() for further details. */
4050 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.velocityQueueEntryFlag = true;
4051  
4052 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { buildQueue(next);
4053 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
4054 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4055  
4056 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /*********************
4057 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Auto-Dequeuing
4058 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { *********************/
4059  
4060 < 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
4061 < 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
4062 < 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
4063 < 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
4064 < 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. */
4065 < 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
4066 < 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. */
4067 < 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.
4068 < 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 */
4069 < 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") {
4070 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.dequeue(element);
4071 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4072 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4073  
4074 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************************
4075 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Set Iteration
4076 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************************/
4077  
4078 < 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.
4079 < 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. */
4080 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { $.each(elements, function(i, element) {
4081 < 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. */
4082 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (Type.isNode(element)) {
4083 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { processElement(element, i);
4084 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4085 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { });
4086  
4087 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /******************
4088 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Option: Loop
4089 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ******************/
4090  
4091 < 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
4092 < 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. */
4093 < 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
4094 < 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,
4095 < 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. */
4096 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = $.extend({}, Velocity.defaults, options);
4097 < 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);
4098 < 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;
4099  
4100 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (opts.loop) {
4101 < 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.
4102 < 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. */
4103 < 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++) {
4104 < 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
4105 < 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
4106 < 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. */
4107 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var reverseOptions = {
4108 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { delay: opts.delay,
4109 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { progress: opts.progress
4110 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
4111  
4112 < 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
4113 < 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). */
4114 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (x === reverseCallsCount - 1) {
4115 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverseOptions.display = opts.display;
4116 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverseOptions.visibility = opts.visibility;
4117 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { reverseOptions.complete = opts.complete;
4118 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4119  
4120 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { animate(elements, "reverse", reverseOptions);
4121 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4122 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4123  
4124 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /***************
4125 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Chaining
4126 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ***************/
4127  
4128 < 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. */
4129 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return getChain();
4130 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
4131  
4132 < 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. */
4133 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity = $.extend(animate, Velocity);
4134 < 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. */
4135 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Velocity.animate = animate;
4136  
4137 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**************
4138 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Timing
4139 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **************/
4140  
4141 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Ticker function. */
4142 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var ticker = window.requestAnimationFrame || rAFShim;
4143  
4144 < 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.
4145 < 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
4146 < 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. */
4147 < 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. */
4148 < 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) {
4149 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { var updateTicker = function() {
4150 < 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. */
4151 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (document.hidden) {
4152 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ticker = function(callback) {
4153 < 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. */
4154 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { return setTimeout(function() {
4155 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callback(true);
4156 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }, 16);
4157 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
4158  
4159 < 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. */
4160 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tick();
4161 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
4162 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ticker = window.requestAnimationFrame || rAFShim;
4163 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4164 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { };
4165  
4166 < 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 */
4167 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { updateTicker();
4168  
4169 < 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 */
4170 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { document.addEventListener("visibilitychange", updateTicker);
4171 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4172  
4173 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************
4174 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Tick
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++) { /* Note: All calls to Velocity are pushed to the Velocity.State.calls array, which is fully iterated through upon each tick. */
4178 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { function tick(timestamp) {
4179 < 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.
4180 < 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
4181 < 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
4182 < 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
4183 < 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
4184 < 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. */
4185 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (timestamp) {
4186 < 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
4187 < 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.
4188 < 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. */
4189 < 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();
4190  
4191 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /********************
4192 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call Iteration
4193 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ********************/
4194  
4195 < 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;
4196  
4197 < 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)
4198 < 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
4199 < 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. */
4200 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (callsLength > 10000) {
4201 < 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);
4202 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callsLength = Velocity.State.calls.length;
4203 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4204  
4205 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Iterate through each active call. */
4206 < 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++) {
4207 < 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. */
4208 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!Velocity.State.calls[i]) {
4209 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
4210 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4211  
4212 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /************************
4213 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Call-Wide Variables
4214 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { ************************/
4215  
4216 < 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],
4217 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { call = callContainer[0],
4218 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { opts = callContainer[2],
4219 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { timeStart = callContainer[3],
4220 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { firstTick = !!timeStart,
4221 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { tweenDummyValue = null,
4222 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { pauseObject = callContainer[5],
4223 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { millisecondsEllapsed = callContainer[6];
4224  
4225  
4226  
4227 < 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().
4228 < 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.
4229 < 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
4230 < 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
4231 < 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.) */
4232 < 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
4233 < 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
4234 < 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. */
4235 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (!timeStart) {
4236 < 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;
4237 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4238  
4239 < 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 */
4240 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pauseObject) {
4241 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { if (pauseObject.resume === true) {
4242 < 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 */
4243 < 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);
4244  
4245 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /* Remove pause object after processing */
4246 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { callContainer[5] = null;
4247 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else {
4248 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { continue;
4249 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4250 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { }
4251  
4252 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { millisecondsEllapsed = callContainer[6] = timeCurrent - timeStart;
4253  
4254 < 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
4255 < 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).
4256 < 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. */
4257 < 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);
4258  
4259 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { /**********************
4260 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { Element Iteration
4261 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { **********************/
4262  
4263 < 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. */
4264 < 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++) {
4265 < 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],
4266 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { element = tweensContainer.element;
4267  
4268 < 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
4269 < 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. */
4270 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (!Data(element)) {
4271 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { continue;
4272 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4273  
4274 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var transformPropertyExists = false;
4275  
4276 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /**********************************
4277 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Display & Visibility Toggling
4278 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { **********************************/
4279  
4280 < 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.
4281 < 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.) */
4282 < 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") {
4283 < 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") {
4284 < 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"];
4285  
4286 < 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) {
4287 < 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);
4288 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { });
4289 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4290  
4291 < 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);
4292 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4293  
4294 < 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". */
4295 < 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") {
4296 < 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);
4297 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4298  
4299 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /************************
4300 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Property Iteration
4301 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { ************************/
4302  
4303 < 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. */
4304 < 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) {
4305 < 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. */
4306 < 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") {
4307 < 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],
4308 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { currentValue,
4309 < 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
4310 < 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*. */
4311 < 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;
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++) { Current Value Calculation
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++) { if (Type.isString(tween.pattern)) {
4318 < 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 ?
4319 < 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) {
4320 < 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];
4321  
4322 < 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;
4323 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } :
4324 < 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) {
4325 < 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],
4326 < 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,
4327 < 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));
4328  
4329 < 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;
4330 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { };
4331  
4332 < 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);
4333 < 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) {
4334 < 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),
4335 < 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. */
4336 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { currentValue = tween.endValue;
4337 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } else {
4338 < 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. */
4339 < 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;
4340  
4341 < 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));
4342 < 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. */
4343 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4344 < 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)) {
4345 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { continue;
4346 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4347  
4348 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tween.currentValue = currentValue;
4349  
4350 < 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
4351 < 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. */
4352 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (property === "tween") {
4353 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tweenDummyValue = currentValue;
4354 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { } else {
4355 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /******************
4356 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { Hooks: Part I
4357 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { ******************/
4358 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { var hookRoot;
4359  
4360 < 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
4361 < 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
4362 < 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
4363 < 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
4364 < 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. */
4365 < 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]) {
4366 < 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);
4367  
4368 < 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];
4369  
4370 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { if (rootPropertyValueCache) {
4371 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { tween.rootPropertyValue = rootPropertyValueCache;
4372 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4373 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { }
4374  
4375 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { /*****************
4376 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { DOM Update
4377 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { *****************/
4378  
4379 < 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. */
4380 < 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. */
4381 < 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 */
4382 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) { property,
4383 < 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),
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), tween.rootPropertyValue,
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), tween.scrollData);
4386  
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), /*******************
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), Hooks: Part II
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), *******************/
4390  
4391 < 4; ++i) {< NEWTON_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. */
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 (CSS.Hooks.registered[property]) {
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), /* Since adjustedSetData contains normalized data ready for DOM updating, the rootPropertyValue needs to be re-extracted from its normalized form. ?? */
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), if (CSS.Normalizations.registered[hookRoot]) {
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), Data(element).rootPropertyValueCache[hookRoot] = CSS.Normalizations.registered[hookRoot]("extract", null, adjustedSetData[1]);
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), } else {
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), Data(element).rootPropertyValueCache[hookRoot] = adjustedSetData[1];
4398 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
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), }
4400  
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), /***************
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), Transforms
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), /* Flag whether a transform property is being animated so that flushTransformCache() can be triggered once this tick pass is complete. */
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), if (adjustedSetData[0] === "transform") {
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), transformPropertyExists = true;
4408 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4409  
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), }
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), }
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), }
4413  
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 < 4; ++i) {< NEWTON_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
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), ****************/
4417  
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), /* If mobileHA is enabled, set the translate3d transform to null to force hardware acceleration.
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), It's safe to override this property since Velocity doesn't actually support its animation (hooks are used in its place). */
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), if (opts.mobileHA) {
4421 < 4; ++i) {< NEWTON_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. */
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), if (Data(element).transformCache.translate3d === undefined) {
4423 < 4; ++i) {< NEWTON_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(). */
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), Data(element).transformCache.translate3d = "(0px, 0px, 0px)";
4425  
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), transformPropertyExists = true;
4427 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
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), }
4429  
4430 < 4; ++i) {< NEWTON_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) {
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), CSS.flushTransformCache(element);
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), }
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), }
4434  
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), /* The non-"none" display value is only applied to an element once -- when its associated call is first ticked through.
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), Accordingly, it's set to false so that it isn't re-processed by this call in the next tick. */
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), if (opts.display !== undefined && opts.display !== "none") {
4438 < 4; ++i) {< NEWTON_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;
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), }
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), if (opts.visibility !== undefined && opts.visibility !== "hidden") {
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), Velocity.State.calls[i][2].visibility = false;
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), /* Pass the elements and the timing data (percentComplete, msRemaining, timeStart, tweenDummyValue) into the progress callback. */
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), if (opts.progress) {
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), opts.progress.call(callContainer[1],
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), callContainer[1],
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), percentComplete,
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), Math.max(0, (timeStart + opts.duration) - timeCurrent),
4450 < 4; ++i) {< NEWTON_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,
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), tweenDummyValue);
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), }
4453  
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), /* If this call has finished tweening, pass its index to completeCall() to handle call cleanup. */
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), if (percentComplete === 1) {
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), completeCall(i);
4457 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
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), }
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), }
4460  
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), /* Note: completeCall() sets the isTicking flag to false when the last call on Velocity.State.calls has completed. */
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), if (Velocity.State.isTicking) {
4463 < 4; ++i) {< NEWTON_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);
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), }
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), }
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), /**********************
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), Call Completion
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), /* Note: Unlike tick(), which processes all active calls at once, call completion is handled on a per-call basis. */
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), function completeCall(callIndex, isStopped) {
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), /* Ensure the call exists. */
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), if (!Velocity.State.calls[callIndex]) {
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), return false;
4476 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4477  
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), /* Pull the metadata from the call. */
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), var call = Velocity.State.calls[callIndex][0],
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), elements = Velocity.State.calls[callIndex][1],
4481 < 4; ++i) {< NEWTON_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],
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), resolver = Velocity.State.calls[callIndex][4];
4483  
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), var remainingCallsExist = false;
4485  
4486 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /*************************
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), Element Finalization
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), *************************/
4489  
4490 < 4; ++i) {< NEWTON_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++) {
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), var element = call[i].element;
4492  
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 the user set display to "none" (intending to hide the element), set it now that the animation has completed. */
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), /* Note: display:none isn't set when calls are manually stopped (via Velocity("stop"). */
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), /* Note: Display gets ignored with "reverse" calls and infinite loops, since this behavior would be undesirable. */
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), if (!isStopped && !opts.loop) {
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), if (opts.display === "none") {
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), CSS.setPropertyValue(element, "display", opts.display);
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), }
4500  
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), if (opts.visibility === "hidden") {
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), CSS.setPropertyValue(element, "visibility", opts.visibility);
4503 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
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  
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), /* 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
4507 < 4; ++i) {< NEWTON_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
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), 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,
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), we check for the existence of our special Velocity.queueEntryFlag declaration, which minifiers won't rename since the flag
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), is assigned to jQuery's global $ object and thus exists out of Velocity's own scope. */
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), var data = Data(element);
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), if (opts.loop !== true && ($.queue(element)[1] === undefined || !/\.velocityQueueEntryFlag/i.test($.queue(element)[1]))) {
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), /* The element may have been deleted. Ensure that its data cache still exists before acting on it. */
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), if (data) {
4516 < 4; ++i) {< NEWTON_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;
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), /* Clear the element's rootPropertyValueCache, which will become stale. */
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), data.rootPropertyValueCache = {};
4519  
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), var transformHAPropertyExists = false;
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 any 3D transform subproperty is at its default value (regardless of unit type), remove it. */
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), $.each(CSS.Lists.transforms3D, function(i, transformName) {
4523 < 4; ++i) {< NEWTON_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,
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), currentValue = data.transformCache[transformName];
4525  
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), if (data.transformCache[transformName] !== undefined && new RegExp("^\\(" + defaultValue + "[^.]").test(currentValue)) {
4527 < 4; ++i) {< NEWTON_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;
4528  
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), delete data.transformCache[transformName];
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), }
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  
4533 < 4; ++i) {< NEWTON_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. */
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), if (opts.mobileHA) {
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), transformHAPropertyExists = true;
4536 < 4; ++i) {< NEWTON_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;
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  
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), /* Flush the subproperty removals to the DOM. */
4540 < 4; ++i) {< NEWTON_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) {
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), CSS.flushTransformCache(element);
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), }
4543  
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), /* Remove the "velocity-animating" indicator class. */
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), CSS.Values.removeClass(element, "velocity-animating");
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), Option: Complete
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), /* 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. */
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), /* Note: Callbacks aren't fired when calls are manually stopped (via Velocity("stop"). */
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), if (!isStopped && opts.complete && !opts.loop && (i === callLength - 1)) {
4556 < 4; ++i) {< NEWTON_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. */
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), try {
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), opts.complete.call(elements, elements);
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), } catch (error) {
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), setTimeout(function() {
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), throw error;
4562 < 4; ++i) {< NEWTON_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);
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), }
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  
4566 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), /**********************
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), Promise Resolving
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), **********************/
4569  
4570 < 4; ++i) {< NEWTON_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. */
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), if (resolver && opts.loop !== true) {
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), resolver(elements);
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), }
4574  
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 < 4; ++i) {< NEWTON_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)
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  
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), if (data && opts.loop === true && !isStopped) {
4580 < 4; ++i) {< NEWTON_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
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), continuous iterative rotation looping. (Otherise, the element would just rotate back and forth.) */
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), $.each(data.tweensContainer, function(propertyName, tweenContainer) {
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), if (/^rotate/.test(propertyName) && ((parseFloat(tweenContainer.startValue) - parseFloat(tweenContainer.endValue)) % 360 === 0)) {
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), var oldStartValue = tweenContainer.startValue;
4585  
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), tweenContainer.startValue = tweenContainer.endValue;
4587 < 4; ++i) {< NEWTON_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;
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), }
4589  
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), if (/^backgroundPosition/.test(propertyName) && parseFloat(tweenContainer.endValue) === 100 && tweenContainer.unitType === "%") {
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), tweenContainer.endValue = 0;
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), tweenContainer.startValue = 100;
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 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
4595  
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), Velocity(element, "reverse", {loop: true, delay: opts.delay});
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), /***************
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), Dequeueing
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), ***************/
4602  
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), /* Fire the next call in the queue so long as this call's queue wasn't set to false (to trigger a parallel animation),
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), which would have already caused the next call to fire. Note: Even if the end of the animation queue has been reached,
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), $.dequeue() must still be called in order to completely clear jQuery's animation queue. */
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), if (opts.queue !== false) {
4607 < 4; ++i) {< NEWTON_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);
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), }
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), }
4610  
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), /************************
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), Calls Array Cleanup
4613 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ************************/
4614  
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), /* Since this call is complete, set it to false so that the rAF tick skips it. This array is later compacted via compactSparseArray().
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), (For performance reasons, the call is set to false instead of being deleted from the array: http://www.html5rocks.com/en/tutorials/speed/v8/) */
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), Velocity.State.calls[callIndex] = false;
4618  
4619 < 4; ++i) {< NEWTON_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.
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), If so, set a flag to end ticking and clear the calls array. */
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 j = 0, callsLength = Velocity.State.calls.length; j < callsLength; j++) {
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 (Velocity.State.calls[j] !== false) {
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), remainingCallsExist = true;
4624  
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), break;
4626 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
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), }
4628  
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), if (remainingCallsExist === false) {
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), /* tick() will detect this flag upon its next iteration and subsequently turn itself off. */
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), Velocity.State.isTicking = false;
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), /* Clear the calls array so that its length is reset. */
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), delete Velocity.State.calls;
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), Velocity.State.calls = [];
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 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4638  
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), /******************
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), Frameworks
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), ******************/
4642  
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), /* Both jQuery and Zepto allow their $.fn object to be extended to allow wrapped elements to be subjected to plugin calls.
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), If either framework is loaded, register a "velocity" extension pointing to Velocity's core animate() method. Velocity
4645 < 4; ++i) {< NEWTON_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
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), accessible beyond just a per-element scope. This master object contains an .animate() method, which is later assigned to $.fn
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 jQuery or Zepto are present). Accordingly, Velocity can both act on wrapped DOM elements and stand alone for targeting raw DOM elements. */
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), global.Velocity = Velocity;
4649  
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), if (global !== window) {
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), /* Assign the element function to Velocity's core animate() method. */
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), global.fn.velocity = animate;
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), /* Assign the object function's defaults to Velocity's global defaults object. */
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), global.fn.velocity.defaults = Velocity.defaults;
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), /***********************
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), Packaged Redirects
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), /* slideUp, slideDown */
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(["Down", "Up"], 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["slide" + 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), begin = opts.begin,
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), complete = opts.complete,
4667 < 4; ++i) {< NEWTON_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 = {},
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), computedValues = {height: "", marginTop: "", marginBottom: "", paddingTop: "", paddingBottom: ""};
4669  
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 (opts.display === undefined) {
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), /* Show the element before slideDown begins and hide the element after slideUp completes. */
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), /* Note: Inline elements cannot have dimensions animated, so they're reverted to inline-block. */
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), opts.display = (direction === "Down" ? (Velocity.CSS.Values.getDisplayType(element) === "inline" ? "inline-block" : "block") : "none");
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), }
4675  
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.begin = 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 the user passed in a begin callback, fire it now. */
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), if (elementsIndex === 0 && begin) {
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), begin.call(elements, elements);
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), }
4681  
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), /* Cache the elements' original vertical dimensional property values so that we can animate back to them. */
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), for (var property in computedValues) {
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), if (!computedValues.hasOwnProperty(property)) {
4685 < 4; ++i) {< NEWTON_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;
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), }
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), inlineValues[property] = element.style[property];
4688  
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), /* For slideDown, use forcefeeding to animate all vertical properties from 0. For slideUp,
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), use forcefeeding to start from computed values and animate down to 0. */
4691 < 4; ++i) {< NEWTON_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);
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), computedValues[property] = (direction === "Down") ? [propertyValue, 0] : [0, propertyValue];
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  
4695 < 4; ++i) {< NEWTON_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. */
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), inlineValues.overflow = element.style.overflow;
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), element.style.overflow = "hidden";
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), opts.complete = function() {
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), /* Reset element to its pre-slide inline values once its slide animation is complete. */
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), for (var property in inlineValues) {
4703 < 4; ++i) {< NEWTON_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)) {
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), element.style[property] = inlineValues[property];
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), }
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), }
4707  
4708 < 4; ++i) {< NEWTON_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. */
4709 < 4; ++i) {< NEWTON_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) {
4710 < 4; ++i) {< NEWTON_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) {
4711 < 4; ++i) {< NEWTON_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);
4712 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4713 < 4; ++i) {< NEWTON_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) {
4714 < 4; ++i) {< NEWTON_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);
4715 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4716 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4717 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
4718  
4719 < 4; ++i) {< NEWTON_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);
4720 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
4721 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
4722  
4723 < 4; ++i) {< NEWTON_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 */
4724 < 4; ++i) {< NEWTON_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) {
4725 < 4; ++i) {< NEWTON_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) {
4726 < 4; ++i) {< NEWTON_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),
4727 < 4; ++i) {< NEWTON_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,
4728 < 4; ++i) {< NEWTON_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};
4729  
4730 < 4; ++i) {< NEWTON_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
4731 < 4; ++i) {< NEWTON_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. */
4732 < 4; ++i) {< NEWTON_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) {
4733 < 4; ++i) {< NEWTON_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;
4734 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4735 < 4; ++i) {< NEWTON_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) {
4736 < 4; ++i) {< NEWTON_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;
4737 < 4; ++i) {< NEWTON_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 {
4738 < 4; ++i) {< NEWTON_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() {
4739 < 4; ++i) {< NEWTON_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) {
4740 < 4; ++i) {< NEWTON_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);
4741 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4742 < 4; ++i) {< NEWTON_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) {
4743 < 4; ++i) {< NEWTON_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);
4744 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4745 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
4746 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4747  
4748 < 4; ++i) {< NEWTON_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. */
4749 < 4; ++i) {< NEWTON_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. */
4750 < 4; ++i) {< NEWTON_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) {
4751 < 4; ++i) {< NEWTON_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");
4752 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), }
4753  
4754 < 4; ++i) {< NEWTON_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);
4755 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), };
4756 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), });
4757  
4758 < 4; ++i) {< NEWTON_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;
4759 < 4; ++i) {< NEWTON_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));
4760 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),}));
4761  
4762 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType),/******************
4763 < 4; ++i) {< NEWTON_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
4764 < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) {< callLength; j++) {< 9 && parseFloat(currentValue) === 0 ? "" : tween.unitType), ******************/
4765  
4766 < 4; ++i) {< NEWTON_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.
4767 < 4; ++i) {< NEWTON_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
4768 < 4; ++i) {< NEWTON_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. */