corrade-http-templates – Blame information for rev
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
31 | office | 1 | /*! VelocityJS.org (1.5.0). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License */ |
2 | |||
3 | /************************* |
||
4 | Velocity jQuery Shim |
||
5 | *************************/ |
||
6 | |||
7 | /*! VelocityJS.org jQuery Shim (1.0.1). (C) 2014 The jQuery Foundation. MIT @license: en.wikipedia.org/wiki/MIT_License. */ |
||
8 | |||
9 | /* This file contains the jQuery functions that Velocity relies on, thereby removing Velocity's dependency on a full copy of jQuery, and allowing it to work in any environment. */ |
||
10 | /* These shimmed functions are only used if jQuery isn't present. If both this shim and jQuery are loaded, Velocity defaults to jQuery proper. */ |
||
11 | /* Browser support: Using this shim instead of jQuery proper removes support for IE8. */ |
||
12 | |||
13 | (function(window) { |
||
14 | "use strict"; |
||
15 | /*************** |
||
16 | Setup |
||
17 | ***************/ |
||
18 | |||
19 | /* If jQuery is already loaded, there's no point in loading this shim. */ |
||
20 | if (window.jQuery) { |
||
21 | return; |
||
22 | } |
||
23 | |||
24 | /* jQuery base. */ |
||
25 | var $ = function(selector, context) { |
||
26 | return new $.fn.init(selector, context); |
||
27 | }; |
||
28 | |||
29 | /******************** |
||
30 | Private Methods |
||
31 | ********************/ |
||
32 | |||
33 | /* jQuery */ |
||
34 | $.isWindow = function(obj) { |
||
35 | /* jshint eqeqeq: false */ |
||
36 | return obj && obj === obj.window; |
||
37 | }; |
||
38 | |||
39 | /* jQuery */ |
||
40 | $.type = function(obj) { |
||
41 | if (!obj) { |
||
42 | return obj + ""; |
||
43 | } |
||
44 | |||
45 | return typeof obj === "object" || typeof obj === "function" ? |
||
46 | class2type[toString.call(obj)] || "object" : |
||
47 | typeof obj; |
||
48 | }; |
||
49 | |||
50 | /* jQuery */ |
||
51 | $.isArray = Array.isArray || function(obj) { |
||
52 | return $.type(obj) === "array"; |
||
53 | }; |
||
54 | |||
55 | /* jQuery */ |
||
56 | function isArraylike(obj) { |
||
57 | var length = obj.length, |
||
58 | type = $.type(obj); |
||
59 | |||
60 | if (type === "function" || $.isWindow(obj)) { |
||
61 | return false; |
||
62 | } |
||
63 | |||
64 | if (obj.nodeType === 1 && length) { |
||
65 | return true; |
||
66 | } |
||
67 | |||
68 | return type === "array" || length === 0 || typeof length === "number" && length > 0 && (length - 1) in obj; |
||
69 | } |
||
70 | |||
71 | /*************** |
||
72 | $ Methods |
||
73 | ***************/ |
||
74 | |||
75 | /* jQuery: Support removed for IE<9. */ |
||
76 | $.isPlainObject = function(obj) { |
||
77 | var key; |
||
78 | |||
79 | if (!obj || $.type(obj) !== "object" || obj.nodeType || $.isWindow(obj)) { |
||
80 | return false; |
||
81 | } |
||
82 | |||
83 | try { |
||
84 | if (obj.constructor && |
||
85 | !hasOwn.call(obj, "constructor") && |
||
86 | !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) { |
||
87 | return false; |
||
88 | } |
||
89 | } catch (e) { |
||
90 | return false; |
||
91 | } |
||
92 | |||
93 | for (key in obj) { |
||
94 | } |
||
95 | |||
96 | return key === undefined || hasOwn.call(obj, key); |
||
97 | }; |
||
98 | |||
99 | /* jQuery */ |
||
100 | $.each = function(obj, callback, args) { |
||
101 | var value, |
||
102 | i = 0, |
||
103 | length = obj.length, |
||
104 | isArray = isArraylike(obj); |
||
105 | |||
106 | if (args) { |
||
107 | if (isArray) { |
||
108 | for (; i < length; i++) { |
||
109 | value = callback.apply(obj[i], args); |
||
110 | |||
111 | if (value === false) { |
||
112 | break; |
||
113 | } |
||
114 | } |
||
115 | } else { |
||
116 | for (i in obj) { |
||
117 | if (!obj.hasOwnProperty(i)) { |
||
118 | continue; |
||
119 | } |
||
120 | value = callback.apply(obj[i], args); |
||
121 | |||
122 | if (value === false) { |
||
123 | break; |
||
124 | } |
||
125 | } |
||
126 | } |
||
127 | |||
128 | } else { |
||
129 | if (isArray) { |
||
130 | for (; i < length; i++) { |
||
131 | value = callback.call(obj[i], i, obj[i]); |
||
132 | |||
133 | if (value === false) { |
||
134 | break; |
||
135 | } |
||
136 | } |
||
137 | } else { |
||
138 | for (i in obj) { |
||
139 | if (!obj.hasOwnProperty(i)) { |
||
140 | continue; |
||
141 | } |
||
142 | value = callback.call(obj[i], i, obj[i]); |
||
143 | |||
144 | if (value === false) { |
||
145 | break; |
||
146 | } |
||
147 | } |
||
148 | } |
||
149 | } |
||
150 | |||
151 | return obj; |
||
152 | }; |
||
153 | |||
154 | /* Custom */ |
||
155 | $.data = function(node, key, value) { |
||
156 | /* $.getData() */ |
||
157 | if (value === undefined) { |
||
158 | var getId = node[$.expando], |
||
159 | store = getId && cache[getId]; |
||
160 | |||
161 | if (key === undefined) { |
||
162 | return store; |
||
163 | } else if (store) { |
||
164 | if (key in store) { |
||
165 | return store[key]; |
||
166 | } |
||
167 | } |
||
168 | /* $.setData() */ |
||
169 | } else if (key !== undefined) { |
||
170 | var setId = node[$.expando] || (node[$.expando] = ++$.uuid); |
||
171 | |||
172 | cache[setId] = cache[setId] || {}; |
||
173 | cache[setId][key] = value; |
||
174 | |||
175 | return value; |
||
176 | } |
||
177 | }; |
||
178 | |||
179 | /* Custom */ |
||
180 | $.removeData = function(node, keys) { |
||
181 | var id = node[$.expando], |
||
182 | store = id && cache[id]; |
||
183 | |||
184 | if (store) { |
||
185 | // Cleanup the entire store if no keys are provided. |
||
186 | if (!keys) { |
||
187 | delete cache[id]; |
||
188 | } else { |
||
189 | $.each(keys, function(_, key) { |
||
190 | delete store[key]; |
||
191 | }); |
||
192 | } |
||
193 | } |
||
194 | }; |
||
195 | |||
196 | /* jQuery */ |
||
197 | $.extend = function() { |
||
198 | var src, copyIsArray, copy, name, options, clone, |
||
199 | target = arguments[0] || {}, |
||
200 | i = 1, |
||
201 | length = arguments.length, |
||
202 | deep = false; |
||
203 | |||
204 | if (typeof target === "boolean") { |
||
205 | deep = target; |
||
206 | |||
207 | target = arguments[i] || {}; |
||
208 | i++; |
||
209 | } |
||
210 | |||
211 | if (typeof target !== "object" && $.type(target) !== "function") { |
||
212 | target = {}; |
||
213 | } |
||
214 | |||
215 | if (i === length) { |
||
216 | target = this; |
||
217 | i--; |
||
218 | } |
||
219 | |||
220 | for (; i < length; i++) { |
||
221 | if ((options = arguments[i])) { |
||
222 | for (name in options) { |
||
223 | if (!options.hasOwnProperty(name)) { |
||
224 | continue; |
||
225 | } |
||
226 | src = target[name]; |
||
227 | copy = options[name]; |
||
228 | |||
229 | if (target === copy) { |
||
230 | continue; |
||
231 | } |
||
232 | |||
233 | if (deep && copy && ($.isPlainObject(copy) || (copyIsArray = $.isArray(copy)))) { |
||
234 | if (copyIsArray) { |
||
235 | copyIsArray = false; |
||
236 | clone = src && $.isArray(src) ? src : []; |
||
237 | |||
238 | } else { |
||
239 | clone = src && $.isPlainObject(src) ? src : {}; |
||
240 | } |
||
241 | |||
242 | target[name] = $.extend(deep, clone, copy); |
||
243 | |||
244 | } else if (copy !== undefined) { |
||
245 | target[name] = copy; |
||
246 | } |
||
247 | } |
||
248 | } |
||
249 | } |
||
250 | |||
251 | return target; |
||
252 | }; |
||
253 | |||
254 | /* jQuery 1.4.3 */ |
||
255 | $.queue = function(elem, type, data) { |
||
256 | function $makeArray(arr, results) { |
||
257 | var ret = results || []; |
||
258 | |||
259 | if (arr) { |
||
260 | if (isArraylike(Object(arr))) { |
||
261 | /* $.merge */ |
||
262 | (function(first, second) { |
||
263 | var len = +second.length, |
||
264 | j = 0, |
||
265 | i = first.length; |
||
266 | |||
267 | while (j < len) { |
||
268 | first[i++] = second[j++]; |
||
269 | } |
||
270 | |||
271 | if (len !== len) { |
||
272 | while (second[j] !== undefined) { |
||
273 | first[i++] = second[j++]; |
||
274 | } |
||
275 | } |
||
276 | |||
277 | first.length = i; |
||
278 | |||
279 | return first; |
||
280 | })(ret, typeof arr === "string" ? [arr] : arr); |
||
281 | } else { |
||
282 | [].push.call(ret, arr); |
||
283 | } |
||
284 | } |
||
285 | |||
286 | return ret; |
||
287 | } |
||
288 | |||
289 | if (!elem) { |
||
290 | return; |
||
291 | } |
||
292 | |||
293 | type = (type || "fx") + "queue"; |
||
294 | |||
295 | var q = $.data(elem, type); |
||
296 | |||
297 | if (!data) { |
||
298 | return q || []; |
||
299 | } |
||
300 | |||
301 | if (!q || $.isArray(data)) { |
||
302 | q = $.data(elem, type, $makeArray(data)); |
||
303 | } else { |
||
304 | q.push(data); |
||
305 | } |
||
306 | |||
307 | return q; |
||
308 | }; |
||
309 | |||
310 | /* jQuery 1.4.3 */ |
||
311 | $.dequeue = function(elems, type) { |
||
312 | /* Custom: Embed element iteration. */ |
||
313 | $.each(elems.nodeType ? [elems] : elems, function(i, elem) { |
||
314 | type = type || "fx"; |
||
315 | |||
316 | var queue = $.queue(elem, type), |
||
317 | fn = queue.shift(); |
||
318 | |||
319 | if (fn === "inprogress") { |
||
320 | fn = queue.shift(); |
||
321 | } |
||
322 | |||
323 | if (fn) { |
||
324 | if (type === "fx") { |
||
325 | queue.unshift("inprogress"); |
||
326 | } |
||
327 | |||
328 | fn.call(elem, function() { |
||
329 | $.dequeue(elem, type); |
||
330 | }); |
||
331 | } |
||
332 | }); |
||
333 | }; |
||
334 | |||
335 | /****************** |
||
336 | $.fn Methods |
||
337 | ******************/ |
||
338 | |||
339 | /* jQuery */ |
||
340 | $.fn = $.prototype = { |
||
341 | init: function(selector) { |
||
342 | /* Just return the element wrapped inside an array; don't proceed with the actual jQuery node wrapping process. */ |
||
343 | if (selector.nodeType) { |
||
344 | this[0] = selector; |
||
345 | |||
346 | return this; |
||
347 | } else { |
||
348 | throw new Error("Not a DOM node."); |
||
349 | } |
||
350 | }, |
||
351 | offset: function() { |
||
352 | /* jQuery altered code: Dropped disconnected DOM node checking. */ |
||
353 | var box = this[0].getBoundingClientRect ? this[0].getBoundingClientRect() : {top: 0, left: 0}; |
||
354 | |||
355 | return { |
||
356 | top: box.top + (window.pageYOffset || document.scrollTop || 0) - (document.clientTop || 0), |
||
357 | left: box.left + (window.pageXOffset || document.scrollLeft || 0) - (document.clientLeft || 0) |
||
358 | }; |
||
359 | }, |
||
360 | position: function() { |
||
361 | /* jQuery */ |
||
362 | function offsetParentFn(elem) { |
||
363 | var offsetParent = elem.offsetParent; |
||
364 | |||
365 | while (offsetParent && offsetParent.nodeName.toLowerCase() !== "html" && offsetParent.style && offsetParent.style.position === "static") { |
||
366 | offsetParent = offsetParent.offsetParent; |
||
367 | } |
||
368 | |||
369 | return offsetParent || document; |
||
370 | } |
||
371 | |||
372 | /* Zepto */ |
||
373 | var elem = this[0], |
||
374 | offsetParent = offsetParentFn(elem), |
||
375 | offset = this.offset(), |
||
376 | parentOffset = /^(?:body|html)$/i.test(offsetParent.nodeName) ? {top: 0, left: 0} : $(offsetParent).offset(); |
||
377 | |||
378 | offset.top -= parseFloat(elem.style.marginTop) || 0; |
||
379 | offset.left -= parseFloat(elem.style.marginLeft) || 0; |
||
380 | |||
381 | if (offsetParent.style) { |
||
382 | parentOffset.top += parseFloat(offsetParent.style.borderTopWidth) || 0; |
||
383 | parentOffset.left += parseFloat(offsetParent.style.borderLeftWidth) || 0; |
||
384 | } |
||
385 | |||
386 | return { |
||
387 | top: offset.top - parentOffset.top, |
||
388 | left: offset.left - parentOffset.left |
||
389 | }; |
||
390 | } |
||
391 | }; |
||
392 | |||
393 | /********************** |
||
394 | Private Variables |
||
395 | **********************/ |
||
396 | |||
397 | /* For $.data() */ |
||
398 | var cache = {}; |
||
399 | $.expando = "velocity" + (new Date().getTime()); |
||
400 | $.uuid = 0; |
||
401 | |||
402 | /* For $.queue() */ |
||
403 | var class2type = {}, |
||
404 | hasOwn = class2type.hasOwnProperty, |
||
405 | toString = class2type.toString; |
||
406 | |||
407 | var types = "Boolean Number String Function Array Date RegExp Object Error".split(" "); |
||
408 | for (var i = 0; i < types.length; i++) { |
||
409 | class2type["[object " + types[i] + "]"] = types[i].toLowerCase(); |
||
410 | } |
||
411 | |||
412 | /* Makes $(node) possible, without having to call init. */ |
||
413 | $.fn.init.prototype = $.fn; |
||
414 | |||
415 | /* Globalize Velocity onto the window, and assign its Utilities property. */ |
||
416 | window.Velocity = {Utilities: $}; |
||
417 | })(window); |
||
418 | |||
419 | /****************** |
||
420 | Velocity.js |
||
421 | ******************/ |
||
422 | |||
423 | (function(factory) { |
||
424 | "use strict"; |
||
425 | /* CommonJS module. */ |
||
426 | if (typeof module === "object" && typeof module.exports === "object") { |
||
427 | module.exports = factory(); |
||
428 | /* AMD module. */ |
||
429 | } else if (typeof define === "function" && define.amd) { |
||
430 | define(factory); |
||
431 | /* Browser globals. */ |
||
432 | } else { |
||
433 | factory(); |
||
434 | } |
||
435 | }(function() { |
||
436 | "use strict"; |
||
437 | return function(global, window, document, undefined) { |
||
438 | |||
439 | /*************** |
||
440 | Summary |
||
441 | ***************/ |
||
442 | |||
443 | /* |
||
444 | - CSS: CSS stack that works independently from the rest of Velocity. |
||
445 | - animate(): Core animation method that iterates over the targeted elements and queues the incoming call onto each element individually. |
||
446 | - Pre-Queueing: Prepare the element for animation by instantiating its data cache and processing the call's options. |
||
447 | - Queueing: The logic that runs once the call has reached its point of execution in the element's $.queue() stack. |
||
448 | Most logic is placed here to avoid risking it becoming stale (if the element's properties have changed). |
||
449 | - Pushing: Consolidation of the tween data followed by its push onto the global in-progress calls container. |
||
450 | - tick(): The single requestAnimationFrame loop responsible for tweening all in-progress calls. |
||
451 | - completeCall(): Handles the cleanup process for each Velocity call. |
||
452 | */ |
||
453 | |||
454 | /********************* |
||
455 | Helper Functions |
||
456 | *********************/ |
||
457 | |||
458 | /* IE detection. Gist: https://gist.github.com/julianshapiro/9098609 */ |
||
459 | var IE = (function() { |
||
460 | if (document.documentMode) { |
||
461 | return document.documentMode; |
||
462 | } else { |
||
463 | for (var i = 7; i > 4; i--) { |
||
464 | var div = document.createElement("div"); |
||
465 | |||
466 | div.innerHTML = "<!--[if IE " + i + "]><span></span><![endif]-->"; |
||
467 | |||
468 | if (div.getElementsByTagName("span").length) { |
||
469 | div = null; |
||
470 | |||
471 | return i; |
||
472 | } |
||
473 | } |
||
474 | } |
||
475 | |||
476 | return undefined; |
||
477 | })(); |
||
478 | |||
479 | /* rAF shim. Gist: https://gist.github.com/julianshapiro/9497513 */ |
||
480 | var rAFShim = (function() { |
||
481 | var timeLast = 0; |
||
482 | |||
483 | return window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function(callback) { |
||
484 | var timeCurrent = (new Date()).getTime(), |
||
485 | timeDelta; |
||
486 | |||
487 | /* Dynamically set delay on a per-tick basis to match 60fps. */ |
||
488 | /* Technique by Erik Moller. MIT license: https://gist.github.com/paulirish/1579671 */ |
||
489 | timeDelta = Math.max(0, 16 - (timeCurrent - timeLast)); |
||
490 | timeLast = timeCurrent + timeDelta; |
||
491 | |||
492 | return setTimeout(function() { |
||
493 | callback(timeCurrent + timeDelta); |
||
494 | }, timeDelta); |
||
495 | }; |
||
496 | })(); |
||
497 | |||
498 | var performance = (function() { |
||
499 | var perf = window.performance || {}; |
||
500 | |||
501 | if (typeof perf.now !== "function") { |
||
502 | var nowOffset = perf.timing && perf.timing.navigationStart ? perf.timing.navigationStart : (new Date()).getTime(); |
||
503 | |||
504 | perf.now = function() { |
||
505 | return (new Date()).getTime() - nowOffset; |
||
506 | }; |
||
507 | } |
||
508 | return perf; |
||
509 | })(); |
||
510 | |||
511 | /* Array compacting. Copyright Lo-Dash. MIT License: https://github.com/lodash/lodash/blob/master/LICENSE.txt */ |
||
512 | function compactSparseArray(array) { |
||
513 | var index = -1, |
||
514 | length = array ? array.length : 0, |
||
515 | result = []; |
||
516 | |||
517 | while (++index < length) { |
||
518 | var value = array[index]; |
||
519 | |||
520 | if (value) { |
||
521 | result.push(value); |
||
522 | } |
||
523 | } |
||
524 | |||
525 | return result; |
||
526 | } |
||
527 | |||
528 | /** |
||
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 | */ |
||
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); |
||
543 | return slice; |
||
544 | } catch (e) { // Fails in IE < 9 |
||
545 | |||
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) |
||
550 | return function(begin, end) { |
||
551 | var len = this.length; |
||
552 | |||
553 | if (typeof begin !== "number") { |
||
554 | begin = 0; |
||
555 | } |
||
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; |
||
587 | }; |
||
588 | } |
||
589 | })(); |
||
590 | |||
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 | |||
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 |
||
645 | && variable !== window |
||
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, |
||
780 | version: {major: 1, minor: 5, patch: 0}, |
||
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 | |||
1511 | < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) { if (unit && _inArray(CSS.Lists.units, unit)) {=>>>> |
||
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));>=>>=>=>>>> |
||
2931 | < 4; ++i) {< NEWTON_ITERATIONS; ++i) {< SUBDIVISION_MAX_ITERATIONS);<= aX; ++currentSample) {<= 8) {< CSS.Lists.transformsBase.length; i++) {<= 8) {< vendorsLength; i++) { } else if (window.console) {>=>>=>=>>>> |
||
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 */>=>>=>=>>>> |
||
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)) {>=>>=>=>>>> |
||
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. */>>>=>>=>=>>>> |