You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flex.apache.org by ah...@apache.org on 2016/05/24 16:07:04 UTC
[2/8] git commit: [flex-falcon] [refs/heads/develop] - convert
createjs build to use a patch file. There are Ant targets that can be used to
generate the patch files if we upgrade the createjs source we use
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/0128e8bd/externs/createjs/src/main/patch/tweenjs.patch
----------------------------------------------------------------------
diff --git a/externs/createjs/src/main/patch/tweenjs.patch b/externs/createjs/src/main/patch/tweenjs.patch
new file mode 100644
index 0000000..f7436c0
--- /dev/null
+++ b/externs/createjs/src/main/patch/tweenjs.patch
@@ -0,0 +1,2863 @@
+diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js
+index 52e0206..0fe6341 100644
+--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js
++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js
+@@ -31,16 +31,16 @@
+ */
+
+ // namespace:
+-this.createjs = this.createjs||{};
+
+-(function() {
+- "use strict";
++
++
++
+
+ /**
+ * A TweenJS plugin for working with numeric CSS string properties (ex. top, left). To use simply install after
+ * TweenJS has loaded:
+ *
+- * createjs.CSSPlugin.install();
++ * createjs.createjs.CSSPlugin.install();
+ *
+ * You can adjust the CSS properties it will work with by modifying the <code>cssSuffixMap</code> property. Currently,
+ * the top, left, bottom, right, width, height have a "px" suffix appended.
+@@ -49,7 +49,7 @@ this.createjs = this.createjs||{};
+ * @class CSSPlugin
+ * @constructor
+ **/
+- function CSSPlugin() {
++ createjs.CSSPlugin = function() {
+ throw("CSSPlugin cannot be instantiated.")
+ }
+
+@@ -65,14 +65,14 @@ this.createjs = this.createjs||{};
+ * @type Object
+ * @static
+ **/
+- CSSPlugin.cssSuffixMap = {top:"px",left:"px",bottom:"px",right:"px",width:"px",height:"px",opacity:""};
++ createjs.CSSPlugin.cssSuffixMap = {top:"px",left:"px",bottom:"px",right:"px",width:"px",height:"px",opacity:""};
+
+ /**
+ * @property priority
+ * @protected
+ * @static
+ **/
+- CSSPlugin.priority = -100; // very low priority, should run last
++ createjs.CSSPlugin.priority = -100; // very low priority, should run last
+
+
+ // static methods
+@@ -81,8 +81,8 @@ this.createjs = this.createjs||{};
+ * @method install
+ * @static
+ **/
+- CSSPlugin.install = function() {
+- var arr = [], map = CSSPlugin.cssSuffixMap;
++ createjs.CSSPlugin.install = function() {
++ var arr = [], map = createjs.CSSPlugin.cssSuffixMap;
+ for (var n in map) { arr.push(n); }
+ createjs.Tween.installPlugin(CSSPlugin, arr);
+ }
+@@ -92,8 +92,8 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- CSSPlugin.init = function(tween, prop, value) {
+- var sfx0,sfx1,style,map = CSSPlugin.cssSuffixMap;
++ createjs.CSSPlugin.init = function(tween, prop, value) {
++ var sfx0,sfx1,style,map = createjs.CSSPlugin.cssSuffixMap;
+ if ((sfx0 = map[prop]) == null || !(style = tween.target.style)) { return value; }
+ var str = style[prop];
+ if (!str) { return 0; } // no style set.
+@@ -110,7 +110,7 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- CSSPlugin.step = function(tween, prop, startValue, endValue, injectProps) {
++ createjs.CSSPlugin.step = function(tween, prop, startValue, endValue, injectProps) {
+ // unused
+ }
+
+@@ -119,13 +119,13 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- CSSPlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) {
+- var style,map = CSSPlugin.cssSuffixMap;
++ createjs.CSSPlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) {
++ var style,map = createjs.CSSPlugin.cssSuffixMap;
+ if (map[prop] == null || !(style = tween.target.style)) { return value; }
+ style[prop] = value+map[prop];
+ return createjs.Tween.IGNORE;
+ }
+
+- createjs.CSSPlugin = CSSPlugin;
+
+-}());
++
++
+diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js
+index e3a0809..51876a7 100644
+--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js
++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js
+@@ -1,462 +1,187 @@
+-/*
+-* Ease
+-* Visit http://createjs.com/ for documentation, updates and examples.
+-*
+-* Copyright (c) 2010 gskinner.com, inc.
+-*
+-* Permission is hereby granted, free of charge, to any person
+-* obtaining a copy of this software and associated documentation
+-* files (the "Software"), to deal in the Software without
+-* restriction, including without limitation the rights to use,
+-* copy, modify, merge, publish, distribute, sublicense, and/or sell
+-* copies of the Software, and to permit persons to whom the
+-* Software is furnished to do so, subject to the following
+-* conditions:
+-*
+-* The above copyright notice and this permission notice shall be
+-* included in all copies or substantial portions of the Software.
+-*
+-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+-* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+-* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+-* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+-* OTHER DEALINGS IN THE SOFTWARE.
+-*/
+-
+-/**
+- * @module TweenJS
++/** @fileoverview Auto-generated Externs files
++ * @externs
+ */
++/**
++ * The Ease class provides a collection of easing functions for use with TweenJS. It does not use the standard 4 param
++ * easing signature. Instead it uses a single param which indicates the current linear ratio (0 to 1) of the tween.
++ *
++ * Most methods on Ease can be passed directly as easing functions:
++ *
++ * Tween.get(target).to({x:100}, 500, createjs.Ease.linear);
++ *
++ * However, methods beginning with "get" will return an easing function based on parameter values:
++ *
++ * Tween.get(target).to({y:200}, 500, createjs.Ease.getPowIn(2.2));
++ *
++ * Please see the <a href="http://www.createjs.com/Demos/TweenJS/Tween_SparkTable">spark table demo</a> for an
++ * overview of the different ease types on <a href="http://tweenjs.com">TweenJS.com</a>.
++ *
++ * <em>Equations derived from work by Robert Penner.</em>
++ *
++ * @see [Ease]
++ * @constructor */
++createjs.Ease = function () {}
++
++ /**
++ * Configurable elastic ease.
++ *
++ * @param {(number|null)} amplitude
++ * @param {(number|null)} period
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getElasticIn = function (amplitude, period) { return null; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.circOut = function (t) { return 0; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.linear = function (t) { return 0; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.sineIn = function (t) { return 0; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.sineOut = function (t) { return 0; }
++
++ /**
++ * Mimics the simple -100 to 100 easing in Flash Pro.
++ *
++ * @param {(number|null)} amount A value from -1 (ease in) to 1 (ease out) indicating the strength and direction of the ease.
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.get = function (amount) { return null; }
++
++ /**
++ * Configurable "back in" ease.
++ *
++ * @param {(number|null)} amount The strength of the ease.
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getBackIn = function (amount) { return null; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.circIn = function (t) { return 0; }
++
++ /**
++ * Configurable "back out" ease.
++ *
++ * @param {(number|null)} amount The strength of the ease.
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getBackOut = function (amount) { return null; }
++
++ /**
++ * Configurable elastic ease.
++ *
++ * @param {(number|null)} amplitude
++ * @param {(number|null)} period
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getElasticInOut = function (amplitude, period) { return null; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.bounceInOut = function (t) { return 0; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.bounceIn = function (t) { return 0; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.sineInOut = function (t) { return 0; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.circInOut = function (t) { return 0; }
++
++ /**
++ * Configurable exponential ease.
++ *
++ * @param {(number|null)} pow The exponent to use (ex. 3 would return a cubic ease).
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getPowOut = function (pow) { return null; }
++
++ /**
++ * Configurable "back in out" ease.
++ *
++ * @param {(number|null)} amount The strength of the ease.
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getBackInOut = function (amount) { return null; }
++
++ /**
++ * Configurable exponential ease.
++ *
++ * @param {(number|null)} pow The exponent to use (ex. 3 would return a cubic ease).
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getPowIn = function (pow) { return null; }
++
++ /**
++ * Configurable exponential ease.
++ *
++ * @param {(number|null)} pow The exponent to use (ex. 3 would return a cubic ease).
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getPowInOut = function (pow) { return null; }
++
++ /**
++ * Configurable elastic ease.
++ *
++ * @param {(number|null)} amplitude
++ * @param {(number|null)} period
++ * @see [Ease]
++ * @returns {(Function|null)}
++ */
++createjs.Ease.prototype.getElasticOut = function (amplitude, period) { return null; }
++
++ /**
++ * @param {(number|null)} t
++ * @see [Ease]
++ * @returns {(number|null)}
++ */
++createjs.Ease.prototype.bounceOut = function (t) { return 0; }
+
+-// namespace:
+-this.createjs = this.createjs||{};
+-
+-(function() {
+- "use strict";
+-
+- /**
+- * The Ease class provides a collection of easing functions for use with TweenJS. It does not use the standard 4 param
+- * easing signature. Instead it uses a single param which indicates the current linear ratio (0 to 1) of the tween.
+- *
+- * Most methods on Ease can be passed directly as easing functions:
+- *
+- * Tween.get(target).to({x:100}, 500, Ease.linear);
+- *
+- * However, methods beginning with "get" will return an easing function based on parameter values:
+- *
+- * Tween.get(target).to({y:200}, 500, Ease.getPowIn(2.2));
+- *
+- * Please see the <a href="http://www.createjs.com/Demos/TweenJS/Tween_SparkTable">spark table demo</a> for an
+- * overview of the different ease types on <a href="http://tweenjs.com">TweenJS.com</a>.
+- *
+- * <em>Equations derived from work by Robert Penner.</em>
+- * @class Ease
+- * @static
+- **/
+- function Ease() {
+- throw "Ease cannot be instantiated.";
+- }
+-
+-
+-// static methods and properties
+- /**
+- * @method linear
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.linear = function(t) { return t; };
+-
+- /**
+- * Identical to linear.
+- * @method none
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.none = Ease.linear;
+-
+- /**
+- * Mimics the simple -100 to 100 easing in Flash Pro.
+- * @method get
+- * @param {Number} amount A value from -1 (ease in) to 1 (ease out) indicating the strength and direction of the ease.
+- * @static
+- * @return {Function}
+- **/
+- Ease.get = function(amount) {
+- if (amount < -1) { amount = -1; }
+- if (amount > 1) { amount = 1; }
+- return function(t) {
+- if (amount==0) { return t; }
+- if (amount<0) { return t*(t*-amount+1+amount); }
+- return t*((2-t)*amount+(1-amount));
+- };
+- };
+-
+- /**
+- * Configurable exponential ease.
+- * @method getPowIn
+- * @param {Number} pow The exponent to use (ex. 3 would return a cubic ease).
+- * @static
+- * @return {Function}
+- **/
+- Ease.getPowIn = function(pow) {
+- return function(t) {
+- return Math.pow(t,pow);
+- };
+- };
+-
+- /**
+- * Configurable exponential ease.
+- * @method getPowOut
+- * @param {Number} pow The exponent to use (ex. 3 would return a cubic ease).
+- * @static
+- * @return {Function}
+- **/
+- Ease.getPowOut = function(pow) {
+- return function(t) {
+- return 1-Math.pow(1-t,pow);
+- };
+- };
+-
+- /**
+- * Configurable exponential ease.
+- * @method getPowInOut
+- * @param {Number} pow The exponent to use (ex. 3 would return a cubic ease).
+- * @static
+- * @return {Function}
+- **/
+- Ease.getPowInOut = function(pow) {
+- return function(t) {
+- if ((t*=2)<1) return 0.5*Math.pow(t,pow);
+- return 1-0.5*Math.abs(Math.pow(2-t,pow));
+- };
+- };
+-
+- /**
+- * @method quadIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quadIn = Ease.getPowIn(2);
+- /**
+- * @method quadOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quadOut = Ease.getPowOut(2);
+- /**
+- * @method quadInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quadInOut = Ease.getPowInOut(2);
+-
+- /**
+- * @method cubicIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.cubicIn = Ease.getPowIn(3);
+- /**
+- * @method cubicOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.cubicOut = Ease.getPowOut(3);
+- /**
+- * @method cubicInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.cubicInOut = Ease.getPowInOut(3);
+-
+- /**
+- * @method quartIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quartIn = Ease.getPowIn(4);
+- /**
+- * @method quartOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quartOut = Ease.getPowOut(4);
+- /**
+- * @method quartInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quartInOut = Ease.getPowInOut(4);
+-
+- /**
+- * @method quintIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quintIn = Ease.getPowIn(5);
+- /**
+- * @method quintOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quintOut = Ease.getPowOut(5);
+- /**
+- * @method quintInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.quintInOut = Ease.getPowInOut(5);
+-
+- /**
+- * @method sineIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.sineIn = function(t) {
+- return 1-Math.cos(t*Math.PI/2);
+- };
+-
+- /**
+- * @method sineOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.sineOut = function(t) {
+- return Math.sin(t*Math.PI/2);
+- };
+-
+- /**
+- * @method sineInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.sineInOut = function(t) {
+- return -0.5*(Math.cos(Math.PI*t) - 1);
+- };
+-
+- /**
+- * Configurable "back in" ease.
+- * @method getBackIn
+- * @param {Number} amount The strength of the ease.
+- * @static
+- * @return {Function}
+- **/
+- Ease.getBackIn = function(amount) {
+- return function(t) {
+- return t*t*((amount+1)*t-amount);
+- };
+- };
+- /**
+- * @method backIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.backIn = Ease.getBackIn(1.7);
+-
+- /**
+- * Configurable "back out" ease.
+- * @method getBackOut
+- * @param {Number} amount The strength of the ease.
+- * @static
+- * @return {Function}
+- **/
+- Ease.getBackOut = function(amount) {
+- return function(t) {
+- return (--t*t*((amount+1)*t + amount) + 1);
+- };
+- };
+- /**
+- * @method backOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.backOut = Ease.getBackOut(1.7);
+-
+- /**
+- * Configurable "back in out" ease.
+- * @method getBackInOut
+- * @param {Number} amount The strength of the ease.
+- * @static
+- * @return {Function}
+- **/
+- Ease.getBackInOut = function(amount) {
+- amount*=1.525;
+- return function(t) {
+- if ((t*=2)<1) return 0.5*(t*t*((amount+1)*t-amount));
+- return 0.5*((t-=2)*t*((amount+1)*t+amount)+2);
+- };
+- };
+- /**
+- * @method backInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.backInOut = Ease.getBackInOut(1.7);
+-
+- /**
+- * @method circIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.circIn = function(t) {
+- return -(Math.sqrt(1-t*t)- 1);
+- };
+-
+- /**
+- * @method circOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.circOut = function(t) {
+- return Math.sqrt(1-(--t)*t);
+- };
+-
+- /**
+- * @method circInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.circInOut = function(t) {
+- if ((t*=2) < 1) return -0.5*(Math.sqrt(1-t*t)-1);
+- return 0.5*(Math.sqrt(1-(t-=2)*t)+1);
+- };
+-
+- /**
+- * @method bounceIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.bounceIn = function(t) {
+- return 1-Ease.bounceOut(1-t);
+- };
+-
+- /**
+- * @method bounceOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.bounceOut = function(t) {
+- if (t < 1/2.75) {
+- return (7.5625*t*t);
+- } else if (t < 2/2.75) {
+- return (7.5625*(t-=1.5/2.75)*t+0.75);
+- } else if (t < 2.5/2.75) {
+- return (7.5625*(t-=2.25/2.75)*t+0.9375);
+- } else {
+- return (7.5625*(t-=2.625/2.75)*t +0.984375);
+- }
+- };
+-
+- /**
+- * @method bounceInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.bounceInOut = function(t) {
+- if (t<0.5) return Ease.bounceIn (t*2) * .5;
+- return Ease.bounceOut(t*2-1)*0.5+0.5;
+- };
+-
+- /**
+- * Configurable elastic ease.
+- * @method getElasticIn
+- * @param {Number} amplitude
+- * @param {Number} period
+- * @static
+- * @return {Function}
+- **/
+- Ease.getElasticIn = function(amplitude,period) {
+- var pi2 = Math.PI*2;
+- return function(t) {
+- if (t==0 || t==1) return t;
+- var s = period/pi2*Math.asin(1/amplitude);
+- return -(amplitude*Math.pow(2,10*(t-=1))*Math.sin((t-s)*pi2/period));
+- };
+- };
+- /**
+- * @method elasticIn
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.elasticIn = Ease.getElasticIn(1,0.3);
+-
+- /**
+- * Configurable elastic ease.
+- * @method getElasticOut
+- * @param {Number} amplitude
+- * @param {Number} period
+- * @static
+- * @return {Function}
+- **/
+- Ease.getElasticOut = function(amplitude,period) {
+- var pi2 = Math.PI*2;
+- return function(t) {
+- if (t==0 || t==1) return t;
+- var s = period/pi2 * Math.asin(1/amplitude);
+- return (amplitude*Math.pow(2,-10*t)*Math.sin((t-s)*pi2/period )+1);
+- };
+- };
+- /**
+- * @method elasticOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.elasticOut = Ease.getElasticOut(1,0.3);
+-
+- /**
+- * Configurable elastic ease.
+- * @method getElasticInOut
+- * @param {Number} amplitude
+- * @param {Number} period
+- * @static
+- * @return {Function}
+- **/
+- Ease.getElasticInOut = function(amplitude,period) {
+- var pi2 = Math.PI*2;
+- return function(t) {
+- var s = period/pi2 * Math.asin(1/amplitude);
+- if ((t*=2)<1) return -0.5*(amplitude*Math.pow(2,10*(t-=1))*Math.sin( (t-s)*pi2/period ));
+- return amplitude*Math.pow(2,-10*(t-=1))*Math.sin((t-s)*pi2/period)*0.5+1;
+- };
+- };
+- /**
+- * @method elasticInOut
+- * @param {Number} t
+- * @static
+- * @return {Number}
+- **/
+- Ease.elasticInOut = Ease.getElasticInOut(1,0.3*1.5);
+-
+- createjs.Ease = Ease;
+-
+-}());
+diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js
+index 48fe018..7d12309 100644
+--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js
++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js
+@@ -31,17 +31,17 @@
+ */
+
+ // namespace:
+-this.createjs = this.createjs||{};
+
+-(function() {
+- "use strict";
++
++
++
+
+ /**
+ * A TweenJS plugin for working with motion guides.
+ *
+ * To use, install the plugin after TweenJS has loaded. Next tween the 'guide' property with an object as detailed below.
+ *
+- * createjs.MotionGuidePlugin.install();
++ * createjs.createjs.MotionGuidePlugin.install();
+ *
+ * <h4>Example</h4>
+ *
+@@ -68,7 +68,7 @@ this.createjs = this.createjs||{};
+ * @class MotionGuidePlugin
+ * @constructor
+ **/
+- function MotionGuidePlugin() {
++ createjs.MotionGuidePlugin = function() {
+ throw("MotionGuidePlugin cannot be instantiated.")
+ };
+
+@@ -79,32 +79,32 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- MotionGuidePlugin.priority = 0; // high priority, should run sooner
++ createjs.MotionGuidePlugin.priority = 0; // high priority, should run sooner
+
+ /**
+ * @property temporary variable storage
+ * @private
+ * @static
+ */
+- MotionGuidePlugin._rotOffS;
++ createjs.MotionGuidePlugin._rotOffS;
+ /**
+ * @property temporary variable storage
+ * @private
+ * @static
+ */
+- MotionGuidePlugin._rotOffE;
++ createjs.MotionGuidePlugin._rotOffE;
+ /**
+ * @property temporary variable storage
+ * @private
+ * @static
+ */
+- MotionGuidePlugin._rotNormS;
++ createjs.MotionGuidePlugin._rotNormS;
+ /**
+ * @property temporary variable storage
+ * @private
+ * @static
+ */
+- MotionGuidePlugin._rotNormE;
++ createjs.MotionGuidePlugin._rotNormE;
+
+
+ // static methods
+@@ -113,7 +113,7 @@ this.createjs = this.createjs||{};
+ * @method install
+ * @static
+ **/
+- MotionGuidePlugin.install = function() {
++ createjs.MotionGuidePlugin.install = function() {
+ createjs.Tween.installPlugin(MotionGuidePlugin, ["guide", "x", "y", "rotation"]);
+ return createjs.Tween.IGNORE;
+ };
+@@ -123,7 +123,7 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- MotionGuidePlugin.init = function(tween, prop, value) {
++ createjs.MotionGuidePlugin.init = function(tween, prop, value) {
+ var target = tween.target;
+ if(!target.hasOwnProperty("x")){ target.x = 0; }
+ if(!target.hasOwnProperty("y")){ target.y = 0; }
+@@ -138,12 +138,12 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- MotionGuidePlugin.step = function(tween, prop, startValue, endValue, injectProps) {
++ createjs.MotionGuidePlugin.step = function(tween, prop, startValue, endValue, injectProps) {
+ // other props
+ if(prop == "rotation"){
+ tween.__rotGlobalS = startValue;
+ tween.__rotGlobalE = endValue;
+- MotionGuidePlugin.testRotData(tween, injectProps);
++ createjs.MotionGuidePlugin.testRotData(tween, injectProps);
+ }
+ if(prop != "guide"){ return endValue; }
+
+@@ -191,18 +191,18 @@ this.createjs = this.createjs||{};
+ temp = data.orient;
+ data.orient = true;
+ var o = {};
+- MotionGuidePlugin.calc(data, data.start, o);
++ createjs.MotionGuidePlugin.calc(data, data.start, o);
+ tween.__rotPathS = Number(o.rotation.toFixed(5));
+- MotionGuidePlugin.calc(data, data.end, o);
++ createjs.MotionGuidePlugin.calc(data, data.end, o);
+ tween.__rotPathE = Number(o.rotation.toFixed(5));
+ data.orient = false; //here and now we don't know if we need to
+- MotionGuidePlugin.calc(data, data.end, injectProps);
++ createjs.MotionGuidePlugin.calc(data, data.end, injectProps);
+ data.orient = temp;
+
+ // Setup rotation properties
+ if(!data.orient){ return endValue; }
+ tween.__guideData = data;
+- MotionGuidePlugin.testRotData(tween, injectProps);
++ createjs.MotionGuidePlugin.testRotData(tween, injectProps);
+ return endValue;
+ };
+
+@@ -211,7 +211,7 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- MotionGuidePlugin.testRotData = function(tween, injectProps){
++ createjs.MotionGuidePlugin.testRotData = function(tween, injectProps){
+
+ // no rotation informat? if we need it come back, if we don't use 0 & ensure we have guide data
+ if(tween.__rotGlobalS === undefined || tween.__rotGlobalE === undefined){
+@@ -256,13 +256,13 @@ this.createjs = this.createjs||{};
+ * @protected
+ * @static
+ **/
+- MotionGuidePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) {
++ createjs.MotionGuidePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) {
+ var data = endValues.guide;
+ if(data == undefined || data === startValues.guide){ return value; }
+ if(data.lastRatio != ratio){
+ // first time through so calculate what I need to
+ var t = ((data.end-data.start)*(wait?data.end:ratio)+data.start);
+- MotionGuidePlugin.calc(data, t, tween.target);
++ createjs.MotionGuidePlugin.calc(data, t, tween.target);
+ switch(data.orient){
+ case "cw": // mix in the original rotation
+ case "ccw":
+@@ -279,13 +279,13 @@ this.createjs = this.createjs||{};
+ /**
+ * Determine the appropriate x/y/rotation information about a path for a given ratio along the path.
+ * Assumes a path object with all optional parameters specified.
+- * @param data Data object you would pass to the "guide:" property in a Tween
+- * @param ratio 0-1 Distance along path, values outside 0-1 are "best guess"
+- * @param target Object to copy the results onto, will use a new object if not supplied.
++ * @param {Object} data Data object you would pass to the "guide:" property in a Tween
++ * @param {Number} ratio 0-1 Distance along path, values outside 0-1 are "best guess"
++ * @param {Object} target Object to copy the results onto, will use a new object if not supplied.
+ * @return {Object} The target object or a new object w/ the tweened properties
+ * @static
+ */
+- MotionGuidePlugin.calc = function(data, ratio, target) {
++ createjs.MotionGuidePlugin.calc = function(data, ratio, target) {
+ if(data._segments == undefined){ throw("Missing critical pre-calculated information, please file a bug"); }
+ if(target == undefined){ target = {x:0, y:0, rotation:0}; }
+ var seg = data._segments;
+@@ -326,6 +326,6 @@ this.createjs = this.createjs||{};
+ return target;
+ };
+
+- createjs.MotionGuidePlugin = MotionGuidePlugin;
+
+-}());
++
++
+diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js
+index 371baa7..4bfca8c 100644
+--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js
++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js
+@@ -31,10 +31,10 @@
+ */
+
+ // namespace:
+-this.createjs = this.createjs||{};
+
+-(function() {
+- "use strict";
++
++
++
+
+ /**
+ * A sample TweenJS plugin. This plugin does not actually affect tweens in any way, it's merely intended to document
+@@ -45,7 +45,7 @@ this.createjs = this.createjs||{};
+ * @class SamplePlugin
+ * @constructor
+ **/
+- function SamplePlugin() {
++ createjs.SamplePlugin = function() {
+ throw("SamplePlugin cannot be instantiated.")
+ };
+
+@@ -56,7 +56,7 @@ this.createjs = this.createjs||{};
+ * @property priority
+ * @static
+ **/
+- SamplePlugin.priority = 0;
++ createjs.SamplePlugin.priority = 0;
+
+ /**
+ * Installs this plugin for use with TweenJS, and registers for a list of properties that this plugin will operate
+@@ -64,7 +64,7 @@ this.createjs = this.createjs||{};
+ * @method install
+ * @static
+ **/
+- SamplePlugin.install = function() {
++ createjs.SamplePlugin.install = function() {
+ // this registers this plugin to work with the "test" property.
+ createjs.Tween.installPlugin(SamplePlugin, ["test"]);
+ };
+@@ -75,12 +75,12 @@ this.createjs = this.createjs||{};
+ * @method init
+ * @param {Tween} tween The related tween instance.
+ * @param {String} prop The name of the property that is being initialized.
+- * @param {any} value The current value of the property on the tween's target.
+- * @return {any} The starting tween value for the property. In most cases, you would simply
++ * @param {Object} value The current value of the property on the tween's target.
++ * @return {Object} The starting tween value for the property. In most cases, you would simply
+ * return the value parameter, but some plugins may need to modify the starting value.
+ * @static
+ **/
+- SamplePlugin.init = function(tween, prop, value) {
++ createjs.SamplePlugin.init = function(tween, prop, value) {
+ console.log("init", prop, value);
+
+ // return the unmodified property value:
+@@ -93,14 +93,14 @@ this.createjs = this.createjs||{};
+ * @method init
+ * @param {Tween} tween The related tween instance.
+ * @param {String} prop The name of the property being tweened.
+- * @param {any} startValue The value of the property at the beginning of the step. This will
++ * @param {Object} startValue The value of the property at the beginning of the step. This will
+ * be the same as the init value if this is the first step, or the same as the
+ * endValue of the previous step if not.
+ * @param {Object} injectProps A generic object to which the plugin can append other properties which should be updated on this step.
+- * @param {any} endValue The value of the property at the end of the step.
++ * @param {Object} endValue The value of the property at the end of the step.
+ * @static
+ **/
+- SamplePlugin.step = function(tween, prop, startValue, endValue, injectProps) {
++ createjs.SamplePlugin.step = function(tween, prop, startValue, endValue, injectProps) {
+ console.log("to: ", prop, startValue, endValue);
+ };
+
+@@ -109,7 +109,7 @@ this.createjs = this.createjs||{};
+ * @method tween
+ * @param {Tween} tween The related tween instance.
+ * @param {String} prop The name of the property being tweened.
+- * @param {any} value The current tweened value of the property, as calculated by TweenJS.
++ * @param {Object} value The current tweened value of the property, as calculated by TweenJS.
+ * @param {Object} startValues A hash of all of the property values at the start of the current
+ * step. You could access the start value of the current property using
+ * startValues[prop].
+@@ -120,13 +120,13 @@ this.createjs = this.createjs||{};
+ * this range.
+ * @param {Boolean} wait Indicates whether the current step is a "wait" step.
+ * @param {Boolean} end Indicates that the tween has reached the end.
+- * @return {any} Return the value that should be assigned to the target property. For example
++ * @return {Object} Return the value that should be assigned to the target property. For example
+ * returning <code>Math.round(value)</code> would assign the default calculated value
+ * as an integer. Returning Tween.IGNORE will prevent Tween from assigning a value to
+ * the target property.
+ * @static
+ **/
+- SamplePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) {
++ createjs.SamplePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) {
+ // ratio is the eased ratio
+ console.log("tween", prop, value, ratio, wait, end);
+
+@@ -135,6 +135,6 @@ this.createjs = this.createjs||{};
+ };
+
+
+- createjs.SamplePlugin = SamplePlugin;
+
+-}());
++
++
+diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js
+index 5546bc2..78be88d 100644
+--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js
++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js
+@@ -1,444 +1,150 @@
+-/*
+-* Timeline
+-* Visit http://createjs.com/ for documentation, updates and examples.
+-*
+-* Copyright (c) 2010 gskinner.com, inc.
+-*
+-* Permission is hereby granted, free of charge, to any person
+-* obtaining a copy of this software and associated documentation
+-* files (the "Software"), to deal in the Software without
+-* restriction, including without limitation the rights to use,
+-* copy, modify, merge, publish, distribute, sublicense, and/or sell
+-* copies of the Software, and to permit persons to whom the
+-* Software is furnished to do so, subject to the following
+-* conditions:
+-*
+-* The above copyright notice and this permission notice shall be
+-* included in all copies or substantial portions of the Software.
+-*
+-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+-* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+-* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+-* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+-* OTHER DEALINGS IN THE SOFTWARE.
+-*/
+-
++/** @fileoverview Auto-generated Externs files
++ * @externs
++ */
+ /**
+- * @module TweenJS
++ * The Timeline class synchronizes multiple tweens and allows them to be controlled as a group. Please note that if a
++ * timeline is looping, the tweens on it may appear to loop even if the "loop" property of the tween is false.
++ *
++ * @see [Timeline]
++ * @constructor * @extends createjs.EventDispatcher
+ */
++createjs.Timeline = function (tweens, labels, props) {}
++
++ /**
++ * @see [Timeline]
++ */
++createjs.Timeline.clone = function () { }
++
++ /**
++ * If a numeric position is passed, it is returned unchanged. If a string is passed, the position of the
++ * corresponding frame label will be returned, or `null` if a matching label is not defined.
++ *
++ * @param {(number|string|null)} positionOrLabel A numeric position value or label string.
++ * @see [Timeline]
++ */
++createjs.Timeline.resolve = function (positionOrLabel) { }
++
++ /**
++ * Adds a label that can be used with {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}.
++ *
++ * @param {(string|null)} label The label name.
++ * @param {(number|null)} position The position this label represents.
++ * @see [Timeline]
++ */
++createjs.Timeline.addLabel = function (label, position) { }
++
++ /**
++ * @param {(number|null)} value
++ * @see [Timeline]
++ * @returns {(number|null)}
++ */
++createjs.Timeline._calcPosition = function (value) { return 0; }
++
++ /**
++ * Pauses this timeline and jumps to the specified position or label.
++ *
++ * @param {(number|string|null)} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label to jump to.
++ * @see [Timeline]
++ */
++createjs.Timeline.gotoAndStop = function (positionOrLabel) { }
++
++ /**
++ * Removes one or more tweens from this timeline.
++ *
++ * @see [Timeline]
++ * @returns {?} Boolean Returns `true` if all of the tweens were successfully removed.
++ */
++createjs.Timeline.removeTween = function (tween) { return null; }
++
++ /**
++ * Returns the name of the label on or immediately before the current position. For example, given a timeline with
++ * two labels, "first" on frame index 4, and "second" on frame 8, getCurrentLabel would return:
++ * <UL>
++ * <LI>null if the current position is 2.</LI>
++ * <LI>"first" if the current position is 4.</LI>
++ * <LI>"first" if the current position is 7.</LI>
++ * <LI>"second" if the current position is 15.</LI>
++ * </UL>
++ *
++ * @see [Timeline]
++ * @returns {(string|null)} The name of the current label or null if there is no label
++ */
++createjs.Timeline.getCurrentLabel = function () { return null; }
++
++ /**
++ * Advances the timeline to the specified position.
++ *
++ * @param {(number|null)} value The position to seek to in milliseconds (or ticks if `useTicks` is `true`).
++ * @param {(number|null|undefined)} actionsMode parameter specifying how actions are handled. See the Tween {{#crossLink "Tween/setPosition"}}{{/crossLink}} method for more details.
++ * @see [Timeline]
++ * @returns {(boolean|null)} Returns `true` if the timeline is complete (ie. the full timeline has run & {{#crossLink "Timeline/loop:property"}}{{/crossLink}} is `false`).
++ */
++createjs.Timeline.setPosition = function (value, actionsMode) { return null; }
++
++ /**
++ * Pauses or plays this timeline.
++ *
++ * @param {(boolean|null)} value Indicates whether the tween should be paused (`true`) or played (`false`).
++ * @see [Timeline]
++ */
++createjs.Timeline.setPaused = function (value) { }
++
++ /**
++ * Advances this timeline by the specified amount of time in milliseconds (or ticks if `useTicks` is `true`).
++ * This is normally called automatically by the Tween engine (via the {{#crossLink "Tween/tick:event"}}{{/crossLink}}
++ * event), but is exposed for advanced uses.
++ *
++ * @param {(number|null)} delta The time to advance in milliseconds (or ticks if useTicks is true).
++ * @see [Timeline]
++ */
++createjs.Timeline.tick = function (delta) { }
++
++ /**
++ * @param {(number|string|null)} positionOrLabel
++ * @see [Timeline]
++ */
++createjs.Timeline._goto = function (positionOrLabel) { }
++
++ /**
++ * Returns a sorted list of the labels defined on this timeline.
++ *
++ * @see [Timeline]
++ * @returns {(Array|null)} Object]} A sorted array of objects with label and position properties.
++ */
++createjs.Timeline.getLabels = function () { return null; }
++
++ /**
++ * Recalculates the duration of the timeline. The duration is automatically updated when tweens are added or removed,
++ * but this method is useful if you modify a tween after it was added to the timeline.
++ *
++ * @see [Timeline]
++ */
++createjs.Timeline.updateDuration = function () { }
++
++ /**
++ * Adds one or more tweens (or timelines) to this timeline. The tweens will be paused (to remove them from the
++ * normal ticking system) and managed by this timeline. Adding a tween to multiple timelines will result in
++ * unexpected behaviour.
++ *
++ * @see [Timeline]
++ * @returns {(Tween|null)} The first tween that was passed in.
++ */
++createjs.Timeline.addTween = function (tween) { return null; }
++
++
++ /**
++ * Defines labels for use with gotoAndPlay/Stop. Overwrites any previously set labels.
++ *
++ * @param {(Object|null)} o An object defining labels for using {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}} in the form `{labelName:time}` where time is in milliseconds (or ticks if `useTicks` is `true`).
++ * @see [Timeline]
++ */
++createjs.Timeline.setLabels = function (o) { }
++
++ /**
++ * Unpauses this timeline and jumps to the specified position or label.
++ *
++ * @param {(number|string|null)} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label to jump to.
++ * @see [Timeline]
++ */
++createjs.Timeline.gotoAndPlay = function (positionOrLabel) { }
+
+-// namespace:
+-this.createjs = this.createjs||{};
+-
+-
+-(function() {
+- "use strict";
+-
+-
+-// constructor
+- /**
+- * The Timeline class synchronizes multiple tweens and allows them to be controlled as a group. Please note that if a
+- * timeline is looping, the tweens on it may appear to loop even if the "loop" property of the tween is false.
+- * @class Timeline
+- * @param {Array} tweens An array of Tweens to add to this timeline. See {{#crossLink "Timeline/addTween"}}{{/crossLink}}
+- * for more info.
+- * @param {Object} labels An object defining labels for using {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}.
+- * See {{#crossLink "Timeline/setLabels"}}{{/crossLink}}
+- * for details.
+- * @param {Object} props The configuration properties to apply to this tween instance (ex. `{loop:true}`). All properties
+- * default to false. Supported props are:<UL>
+- * <LI> loop: sets the loop property on this tween.</LI>
+- * <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI>
+- * <LI> ignoreGlobalPause: sets the ignoreGlobalPause property on this tween.</LI>
+- * <LI> paused: indicates whether to start the tween paused.</LI>
+- * <LI> position: indicates the initial position for this timeline.</LI>
+- * <LI> onChange: specifies a listener to add for the {{#crossLink "Timeline/change:event"}}{{/crossLink}} event.</LI>
+- * </UL>
+- * @extends EventDispatcher
+- * @constructor
+- **/
+- function Timeline(tweens, labels, props) {
+- this.EventDispatcher_constructor();
+-
+- // public properties:
+- /**
+- * Causes this timeline to continue playing when a global pause is active.
+- * @property ignoreGlobalPause
+- * @type Boolean
+- **/
+- this.ignoreGlobalPause = false;
+-
+- /**
+- * The total duration of this timeline in milliseconds (or ticks if `useTicks `is `true`). This value is usually
+- * automatically updated as you modify the timeline. See {{#crossLink "Timeline/updateDuration"}}{{/crossLink}}
+- * for more information.
+- * @property duration
+- * @type Number
+- * @default 0
+- * @readonly
+- **/
+- this.duration = 0;
+-
+- /**
+- * If true, the timeline will loop when it reaches the end. Can be set via the props param.
+- * @property loop
+- * @type Boolean
+- **/
+- this.loop = false;
+-
+- /**
+- * The current normalized position of the timeline. This will always be a value between 0 and
+- * {{#crossLink "Timeline/duration:property"}}{{/crossLink}}.
+- * Changing this property directly will have no effect.
+- * @property position
+- * @type Object
+- * @readonly
+- **/
+- this.position = null;
+-
+- // private properties:
+- /**
+- * @property _paused
+- * @type Boolean
+- * @protected
+- **/
+- this._paused = false;
+-
+- /**
+- * @property _tweens
+- * @type Array[Tween]
+- * @protected
+- **/
+- this._tweens = [];
+-
+- /**
+- * @property _labels
+- * @type Object
+- * @protected
+- **/
+- this._labels = null;
+-
+- /**
+- * @property _labelList
+- * @type Array[Object]
+- * @protected
+- **/
+- this._labelList = null;
+-
+- /**
+- * @property _prevPosition
+- * @type Number
+- * @default 0
+- * @protected
+- **/
+- this._prevPosition = 0;
+-
+- /**
+- * @property _prevPos
+- * @type Number
+- * @default -1
+- * @protected
+- **/
+- this._prevPos = -1;
+-
+- /**
+- * @property _useTicks
+- * @type Boolean
+- * @default false
+- * @protected
+- **/
+- this._useTicks = false;
+-
+- /**
+- * Indicates whether the timeline is currently registered with Tween.
+- * @property _registered
+- * @type {boolean}
+- * @default false
+- * @protected
+- */
+- this._registered = false;
+-
+-
+- if (props) {
+- this._useTicks = props.useTicks;
+- this.loop = props.loop;
+- this.ignoreGlobalPause = props.ignoreGlobalPause;
+- props.onChange&&this.addEventListener("change", props.onChange);
+- }
+- if (tweens) { this.addTween.apply(this, tweens); }
+- this.setLabels(labels);
+- if (props&&props.paused) { this._paused=true; }
+- else { createjs.Tween._register(this,true); }
+- if (props&&props.position!=null) { this.setPosition(props.position, createjs.Tween.NONE); }
+-
+- };
+-
+- var p = createjs.extend(Timeline, createjs.EventDispatcher);
+-
+- // TODO: deprecated
+- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details.
+-
+-
+-// events:
+- /**
+- * Called whenever the timeline's position changes.
+- * @event change
+- * @since 0.5.0
+- **/
+-
+-
+-// public methods:
+- /**
+- * Adds one or more tweens (or timelines) to this timeline. The tweens will be paused (to remove them from the
+- * normal ticking system) and managed by this timeline. Adding a tween to multiple timelines will result in
+- * unexpected behaviour.
+- * @method addTween
+- * @param {Tween} ...tween The tween(s) to add. Accepts multiple arguments.
+- * @return {Tween} The first tween that was passed in.
+- **/
+- p.addTween = function(tween) {
+- var l = arguments.length;
+- if (l > 1) {
+- for (var i=0; i<l; i++) { this.addTween(arguments[i]); }
+- return arguments[0];
+- } else if (l == 0) { return null; }
+- this.removeTween(tween);
+- this._tweens.push(tween);
+- tween.setPaused(true);
+- tween._paused = false;
+- tween._useTicks = this._useTicks;
+- if (tween.duration > this.duration) { this.duration = tween.duration; }
+- if (this._prevPos >= 0) { tween.setPosition(this._prevPos, createjs.Tween.NONE); }
+- return tween;
+- };
+-
+- /**
+- * Removes one or more tweens from this timeline.
+- * @method removeTween
+- * @param {Tween} ...tween The tween(s) to remove. Accepts multiple arguments.
+- * @return Boolean Returns `true` if all of the tweens were successfully removed.
+- **/
+- p.removeTween = function(tween) {
+- var l = arguments.length;
+- if (l > 1) {
+- var good = true;
+- for (var i=0; i<l; i++) { good = good && this.removeTween(arguments[i]); }
+- return good;
+- } else if (l == 0) { return false; }
+-
+- var tweens = this._tweens;
+- var i = tweens.length;
+- while (i--) {
+- if (tweens[i] == tween) {
+- tweens.splice(i, 1);
+- if (tween.duration >= this.duration) { this.updateDuration(); }
+- return true;
+- }
+- }
+- return false;
+- };
+-
+- /**
+- * Adds a label that can be used with {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}.
+- * @method addLabel
+- * @param {String} label The label name.
+- * @param {Number} position The position this label represents.
+- **/
+- p.addLabel = function(label, position) {
+- this._labels[label] = position;
+- var list = this._labelList;
+- if (list) {
+- for (var i= 0,l=list.length; i<l; i++) { if (position < list[i].position) { break; } }
+- list.splice(i, 0, {label:label, position:position});
+- }
+- };
+-
+- /**
+- * Defines labels for use with gotoAndPlay/Stop. Overwrites any previously set labels.
+- * @method setLabels
+- * @param {Object} o An object defining labels for using {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}
+- * in the form `{labelName:time}` where time is in milliseconds (or ticks if `useTicks` is `true`).
+- **/
+- p.setLabels = function(o) {
+- this._labels = o ? o : {};
+- };
+-
+- /**
+- * Returns a sorted list of the labels defined on this timeline.
+- * @method getLabels
+- * @return {Array[Object]} A sorted array of objects with label and position properties.
+- **/
+- p.getLabels = function() {
+- var list = this._labelList;
+- if (!list) {
+- list = this._labelList = [];
+- var labels = this._labels;
+- for (var n in labels) {
+- list.push({label:n, position:labels[n]});
+- }
+- list.sort(function (a,b) { return a.position- b.position; });
+- }
+- return list;
+- };
+-
+- /**
+- * Returns the name of the label on or immediately before the current position. For example, given a timeline with
+- * two labels, "first" on frame index 4, and "second" on frame 8, getCurrentLabel would return:
+- * <UL>
+- * <LI>null if the current position is 2.</LI>
+- * <LI>"first" if the current position is 4.</LI>
+- * <LI>"first" if the current position is 7.</LI>
+- * <LI>"second" if the current position is 15.</LI>
+- * </UL>
+- * @method getCurrentLabel
+- * @return {String} The name of the current label or null if there is no label
+- **/
+- p.getCurrentLabel = function() {
+- var labels = this.getLabels();
+- var pos = this.position;
+- var l = labels.length;
+- if (l) {
+- for (var i = 0; i<l; i++) { if (pos < labels[i].position) { break; } }
+- return (i==0) ? null : labels[i-1].label;
+- }
+- return null;
+- };
+-
+- /**
+- * Unpauses this timeline and jumps to the specified position or label.
+- * @method gotoAndPlay
+- * @param {String|Number} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`)
+- * or label to jump to.
+- **/
+- p.gotoAndPlay = function(positionOrLabel) {
+- this.setPaused(false);
+- this._goto(positionOrLabel);
+- };
+-
+- /**
+- * Pauses this timeline and jumps to the specified position or label.
+- * @method gotoAndStop
+- * @param {String|Number} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label
+- * to jump to.
+- **/
+- p.gotoAndStop = function(positionOrLabel) {
+- this.setPaused(true);
+- this._goto(positionOrLabel);
+- };
+-
+- /**
+- * Advances the timeline to the specified position.
+- * @method setPosition
+- * @param {Number} value The position to seek to in milliseconds (or ticks if `useTicks` is `true`).
+- * @param {Number} [actionsMode] parameter specifying how actions are handled. See the Tween {{#crossLink "Tween/setPosition"}}{{/crossLink}}
+- * method for more details.
+- * @return {Boolean} Returns `true` if the timeline is complete (ie. the full timeline has run & {{#crossLink "Timeline/loop:property"}}{{/crossLink}}
+- * is `false`).
+- **/
+- p.setPosition = function(value, actionsMode) {
+- var t = this._calcPosition(value);
+- var end = !this.loop && value >= this.duration;
+- if (t == this._prevPos) { return end; }
+- this._prevPosition = value;
+- this.position = this._prevPos = t; // in case an action changes the current frame.
+- for (var i=0, l=this._tweens.length; i<l; i++) {
+- this._tweens[i].setPosition(t, actionsMode);
+- if (t != this._prevPos) { return false; } // an action changed this timeline's position.
+- }
+- if (end) { this.setPaused(true); }
+- this.dispatchEvent("change");
+- return end;
+- };
+-
+- /**
+- * Pauses or plays this timeline.
+- * @method setPaused
+- * @param {Boolean} value Indicates whether the tween should be paused (`true`) or played (`false`).
+- **/
+- p.setPaused = function(value) {
+- this._paused = !!value;
+- createjs.Tween._register(this, !value);
+- };
+-
+- /**
+- * Recalculates the duration of the timeline. The duration is automatically updated when tweens are added or removed,
+- * but this method is useful if you modify a tween after it was added to the timeline.
+- * @method updateDuration
+- **/
+- p.updateDuration = function() {
+- this.duration = 0;
+- for (var i=0,l=this._tweens.length; i<l; i++) {
+- var tween = this._tweens[i];
+- if (tween.duration > this.duration) { this.duration = tween.duration; }
+- }
+- };
+-
+- /**
+- * Advances this timeline by the specified amount of time in milliseconds (or ticks if `useTicks` is `true`).
+- * This is normally called automatically by the Tween engine (via the {{#crossLink "Tween/tick:event"}}{{/crossLink}}
+- * event), but is exposed for advanced uses.
+- * @method tick
+- * @param {Number} delta The time to advance in milliseconds (or ticks if useTicks is true).
+- **/
+- p.tick = function(delta) {
+- this.setPosition(this._prevPosition+delta);
+- };
+-
+- /**
+- * If a numeric position is passed, it is returned unchanged. If a string is passed, the position of the
+- * corresponding frame label will be returned, or `null` if a matching label is not defined.
+- * @method resolve
+- * @param {String|Number} positionOrLabel A numeric position value or label string.
+- **/
+- p.resolve = function(positionOrLabel) {
+- var pos = Number(positionOrLabel);
+- if (isNaN(pos)) { pos = this._labels[positionOrLabel]; }
+- return pos;
+- };
+-
+- /**
+- * Returns a string representation of this object.
+- * @method toString
+- * @return {String} a string representation of the instance.
+- **/
+- p.toString = function() {
+- return "[Timeline]";
+- };
+-
+- /**
+- * @method clone
+- * @protected
+- **/
+- p.clone = function() {
+- throw("Timeline can not be cloned.")
+- };
+-
+-// private methods:
+- /**
+- * @method _goto
+- * @param {String | Number} positionOrLabel
+- * @protected
+- **/
+- p._goto = function(positionOrLabel) {
+- var pos = this.resolve(positionOrLabel);
+- if (pos != null) { this.setPosition(pos); }
+- };
+-
+- /**
+- * @method _calcPosition
+- * @param {Number} value
+- * @return {Number}
+- * @protected
+- **/
+- p._calcPosition = function(value) {
+- if (value < 0) { return 0; }
+- if (value < this.duration) { return value; }
+- return this.loop ? value%this.duration : this.duration;
+- };
+-
+- createjs.Timeline = createjs.promote(Timeline, "EventDispatcher");
+-
+-}());
+diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js
+index 8945830..f54bc42 100644
+--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js
++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js
+@@ -1,941 +1,279 @@
+-/*
+-* Tween
+-* Visit http://createjs.com/ for documentation, updates and examples.
+-*
+-* Copyright (c) 2010 gskinner.com, inc.
+-*
+-* Permission is hereby granted, free of charge, to any person
+-* obtaining a copy of this software and associated documentation
+-* files (the "Software"), to deal in the Software without
+-* restriction, including without limitation the rights to use,
+-* copy, modify, merge, publish, distribute, sublicense, and/or sell
+-* copies of the Software, and to permit persons to whom the
+-* Software is furnished to do so, subject to the following
+-* conditions:
+-*
+-* The above copyright notice and this permission notice shall be
+-* included in all copies or substantial portions of the Software.
+-*
+-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+-* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+-* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+-* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+-* OTHER DEALINGS IN THE SOFTWARE.
+-*/
+-
++/** @fileoverview Auto-generated Externs files
++ * @externs
++ */
+ /**
+- * The TweenJS Javascript library provides a simple but powerful tweening interface. It supports tweening of both
+- * numeric object properties & CSS style properties, and allows you to chain tweens and actions together to create
+- * complex sequences.
+- *
+- * <h4>Simple Tween</h4>
+- * This tween will tween the target's alpha property from 0 to 1 for 1s then call the <code>handleComplete</code> function.
+- *
+- * target.alpha = 0;
+- * createjs.Tween.get(target).to({alpha:1}, 1000).call(handleComplete);
+- * function handleComplete() {
+- * //Tween complete
+- * }
+- *
+- * <strong>Arguments and Scope</strong>
+- * Tween also supports a `call()` with arguments and/or a scope. If no scope is passed, then the function is called
+- * anonymously (normal JavaScript behaviour). The scope is useful for maintaining scope when doing object-oriented
+- * style development.
+- *
+- * createjs.Tween.get(target).to({alpha:0})
+- * .call(handleComplete, [argument1, argument2], this);
+- *
+- * <h4>Chainable Tween</h4>
+- * This tween will wait 0.5s, tween the target's alpha property to 0 over 1s, set it's visible to false, then call the
+- * <code>handleComplete</code> function.
+- *
+- * target.alpha = 1;
+- * createjs.Tween.get(target).wait(500).to({alpha:0, visible:false}, 1000).call(handleComplete);
+- * function handleComplete() {
+- * //Tween complete
+- * }
+- *
+- * <h4>Browser Support</h4>
+- * TweenJS will work in modern browsers. To use TweenJS with IE8 and earlier, use an older version of PreloadJS
+- * (version 0.4.1 and earlier).
++ * A Tween instance tweens properties for a single target. Instance methods can be chained for easy construction and sequencing:
++ *
++ * <h4>Example</h4>
++ *
++ * target.alpha = 1;
++ * createjs.createjs.Tween.get(target)
++ * .wait(500)
++ * .to({alpha:0, visible:false}, 1000)
++ * .call(handleComplete);
++ * function handleComplete() {
++ * //Tween complete
++ * }
++ *
++ * Multiple tweens can point to the same instance, however if they affect the same properties there could be unexpected
++ * behaviour. To stop all tweens on an object, use {{#crossLink "Tween/removeTweens"}}{{/crossLink}} or pass `override:true`
++ * in the props argument.
++ *
++ * createjs.createjs.Tween.get(target, {override:true}).to({x:100});
++ *
++ * Subscribe to the {{#crossLink "Tween/change:event"}}{{/crossLink}} event to get notified when a property of the
++ * target is changed.
++ *
++ * createjs.createjs.Tween.get(target, {override:true}).to({x:100}).addEventListener("change", handleChange);
++ * function handleChange(event) {
++ * // The tween changed.
++ * }
++ *
++ * See the Tween {{#crossLink "Tween/get"}}{{/crossLink}} method for additional param documentation.
+ *
+- * @module TweenJS
+- * @main TweenJS
++ * @see [Tween]
++ * @constructor * @extends createjs.EventDispatcher
+ */
++createjs.Tween = function (target, props, pluginData) {}
++
++ /**
++ * Advances all tweens. This typically uses the {{#crossLink "Ticker"}}{{/crossLink}} class, but you can call it
++ * manually if you prefer to use your own "heartbeat" implementation.
++ *
++ * @param {(number|null)} delta The change in time in milliseconds since the last tick. Required unless all tweens have `useTicks` set to true.
++ * @param {(boolean|null)} paused Indicates whether a global pause is in effect. Tweens with {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} will ignore this, but all others will pause if this is `true`.
++ * @see [Tween]
++ */
++createjs.Tween.prototype.tick = function (delta, paused) { }
++
++ /**
++ * Stop and remove all existing tweens.
++ *
++ * @see [Tween]
++ */
++createjs.Tween.prototype.removeAllTweens = function () { }
++
++ /**
++ * Returns a new tween instance. This is functionally identical to using "new Tween(...)", but looks cleaner
++ * with the chained syntax of TweenJS.
++ * <h4>Example</h4>
++ *
++ * var tween = createjs.createjs.Tween.get(target);
++ *
++ * @param {(Object|null)} target The target object that will have its properties tweened.
++ * @param {(Object|null|undefined)} props The configuration properties to apply to this tween instance (ex. `{loop:true, paused:true}`). All properties default to `false`. Supported props are: <UL> <LI> loop: sets the loop property on this tween.</LI> <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI> <LI> ignoreGlobalPause: sets the {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} property on this tween.</LI> <LI> override: if true, `createjs.createjs.Tween.removeTweens(target)` will be called to remove any other tweens with the same target. <LI> paused: indicates whether to start the tween paused.</LI> <LI> position: indicates the initial position for this tween.</LI> <LI> onChange: specifies a listener for the {{#crossLink "Tween/change:event"}}{{/crossLink}} event.</LI> </UL>
++ * @param {(Object|null|undefined)} pluginData An object containing data for use by installed plugins. See individual plugins' documentation for details.
++ * @param {(boolean|null|undefined)} override If true, any previous tweens on the same target will be removed. This is the same as calling `createjs.Tween.removeTweens(target)`.
++ * @see [Tween]
++ * @returns {(Tween|null)} A reference to the created tween. Additional chained tweens, method calls, or callbacks can be applied to the returned tween instance.
++ */
++createjs.Tween.prototype.get = function (target, props, pluginData, override) { return null; }
++
++ /**
++ * Handle events that result from Tween being used as an event handler. This is included to allow Tween to handle
++ * {{#crossLink "Ticker/tick:event"}}{{/crossLink}} events from the createjs {{#crossLink "Ticker"}}{{/crossLink}}.
++ * No other events are handled in createjs.Tween.
++ *
++ * @param {(Object|null)} event An event object passed in by the {{#crossLink "EventDispatcher"}}{{/crossLink}}. Will usually be of type "tick".
++ * @see [Tween]
++ */
++createjs.Tween.prototype.handleEvent = function (event) { }
++
++ /**
++ * Indicates whether there are any active tweens (and how many) on the target object (if specified) or in general.
++ *
++ * @param {(Object|null|undefined)} target The target to check for active tweens. If not specified, the return value will indicate if there are any active tweens on any target.
++ * @see [Tween]
++ * @returns {(boolean|null)} If there are active tweens.
++ */
++createjs.Tween.prototype.hasActiveTweens = function (target) { return null; }
++
++ /**
++ * Installs a plugin, which can modify how certain properties are handled when tweened. See the {{#crossLink "CSSPlugin"}}{{/crossLink}}
++ * for an example of how to write TweenJS plugins.
++ *
++ * @param {(Object|null)} plugin The plugin class to install
++ * @param {(Array|null)} properties An array of properties that the plugin will handle.
++ * @see [Tween]
++ */
++createjs.Tween.prototype.installPlugin = function (plugin, properties) { }
++
++ /**
++ * Removes all existing tweens for a target. This is called automatically by new tweens if the `override`
++ * property is `true`.
++ *
++ * @param {(Object|null)} target The target object to remove existing tweens from.
++ * @see [Tween]
++ */
++createjs.Tween.prototype.removeTweens = function (target) { }
++
++ /**
++ * Registers or unregisters a tween with the ticking system.
++ *
++ * @param {(Tween|null)} tween The tween instance to register or unregister.
++ * @param {(boolean|null)} value If `true`, the tween is registered. If `false` the tween is unregistered.
++ * @see [Tween]
++ */
++createjs.Tween.prototype._register = function (tween, value) { }
++
++ /**
++ * @param {(Object|null)} o
++ * @see [Tween]
++ */
++createjs.Tween._addAction = function (o) { }
++
++ /**
++ * Queues a tween from the current values to the target properties. Set duration to 0 to jump to these value.
++ * Numeric properties will be tweened from their current value in the tween to the target value. Non-numeric
++ * properties will be set at the end of the specified duration.
++ * <h4>Example</h4>
++ *
++ * createjs.createjs.Tween.get(target).to({alpha:0}, 1000);
++ *
++ * @param {(Object|null)} props An object specifying property target values for this tween (Ex. `{x:300}` would tween the x property of the target to 300).
++ * @param {(number|null|undefined)} duration The duration of the wait in milliseconds (or in ticks if `useTicks` is true).
++ * @param {(Function|null|undefined)} ease The easing function to use for this tween. See the {{#crossLink "Ease"}}{{/crossLink}} class for a list of built-in ease functions.
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls).
++ */
++createjs.Tween.to = function (props, duration, ease) { return null; }
++
++ /**
++ * Queues an action to call the specified function.
++ * <h4>Example</h4>
++ *
++ * //would call myFunction() after 1 second.
++ * mycreatejs.Tween.wait(1000).call(myFunction);
++ *
++ * @param {(Function|null)} callback The function to call.
++ * @param {(Array|null|undefined)} params . The parameters to call the function with. If this is omitted, then the function will be called with a single param pointing to this tween.
++ * @param {(Object|null|undefined)} scope . The scope to call the function in. If omitted, it will be called in the target's scope.
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls).
++ */
++createjs.Tween.call = function (callback, params, scope) { return null; }
++
++ /**
++ * @see [Tween]
++ */
++createjs.Tween.clone = function () { }
++
++ /**
++ * @param {(Object|null)} o
++ * @see [Tween]
++ */
++createjs.Tween._appendQueueProps = function (o) { }
++
++ /**
++ * @param {(number|null)} startPos
++ * @param {(number|null)} endPos
++ * @param {(boolean|null)} includeStart
++ * @see [Tween]
++ */
++createjs.Tween._runActions = function (startPos, endPos, includeStart) { }
++
++ /**
++ * Queues an action to set the specified props on the specified target. If target is null, it will use this tween's
++ * target.
++ * <h4>Example</h4>
++ *
++ * mycreatejs.Tween.wait(1000).set({visible:false},foo);
++ *
++ * @param {(Object|null)} props The properties to set (ex. `{visible:false}`).
++ * @param {(Object|null|undefined)} target The target to set the properties on. If omitted, they will be set on the tween's target.
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls).
++ */
++createjs.Tween.set = function (props, target) { return null; }
++
++ /**
++ * Queues an action to play (unpause) the specified tween. This enables you to sequence multiple tweens.
++ * <h4>Example</h4>
++ *
++ * mycreatejs.Tween.to({x:100},500).play(otherTween);
++ *
++ * @param {(Tween|null)} tween The tween to play.
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls).
++ */
++createjs.Tween.play = function (tween) { return null; }
++
++ /**
++ * Advances the tween to a specified position.
++ *
++ * @param {(number|null)} value The position to seek to in milliseconds (or ticks if useTicks is true).
++ * @param {(number|null|undefined)} actionsMode Specifies how actions are handled (ie. call, set, play, pause): <ul> <li>{{#crossLink "Tween/NONE:property"}}{{/crossLink}} (0) - run no actions.</li> <li>{{#crossLink "Tween/LOOP:property"}}{{/crossLink}} (1) - if new position is less than old, then run all actions between old and duration, then all actions between 0 and new.</li> <li>{{#crossLink "Tween/REVERSE:property"}}{{/crossLink}} (2) - if new position is less than old, run all actions between them in reverse.</li> </ul>
++ * @see [Tween]
++ * @returns {(boolean|null)} Returns `true` if the tween is complete (ie. the full tween has run & {{#crossLink "Tween/loop:property"}}{{/crossLink}} is `false`).
++ */
++createjs.Tween.setPosition = function (value, actionsMode) { return null; }
++
++ /**
++ * @param {(Object|null)} props
++ * @param {(Object|null)} o
++ * @see [Tween]
++ */
++createjs.Tween._set = function (props, o) { }
++
++ /**
++ * Queues a wait (essentially an empty tween).
++ * <h4>Example</h4>
++ *
++ * //This tween will wait 1s before alpha is faded to 0.
++ * createjs.createjs.Tween.get(target).wait(1000).to({alpha:0}, 1000);
++ *
++ * @param {(number|null)} duration The duration of the wait in milliseconds (or in ticks if `useTicks` is true).
++ * @param {(boolean|null|undefined)} passive Tween properties will not be updated during a passive wait. This is mostly useful for use with {{#crossLink "Timeline"}}{{/crossLink}} instances that contain multiple tweens affecting the same target at different times.
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls).
++ */
++createjs.Tween.wait = function (duration, passive) { return null; }
++
++ /**
++ * Pauses or plays this tween.
++ *
++ * @param {(boolean|null|undefined)} value Indicates whether the tween should be paused (`true`) or played (`false`).
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls)
++ */
++createjs.Tween.setPaused = function (value) { return null; }
++
++ /**
++ * Queues an action to pause the specified tween.
++ *
++ * @param {(Tween|null)} tween The tween to pause. If null, it pauses this tween.
++ * @see [Tween]
++ * @returns {(Tween|null)} This tween instance (for chaining calls)
++ */
++createjs.Tween.pause = function (tween) { return null; }
++
++ /**
++ * @param {(Object|null)} step
++ * @param {(number|null)} ratio
++ * @see [Tween]
++ */
++createjs.Tween._updateTargetProps = function (step, ratio) { }
++
++ /**
++ * Advances this tween by the specified amount of time in milliseconds (or ticks if`useTicks` is `true`).
++ * This is normally called automatically by the Tween engine (via {{#crossLink "Tween/tick"}}{{/crossLink}}), but is
++ * exposed for advanced uses.
++ *
++ * @param {(number|null)} delta The time to advance in milliseconds (or ticks if `useTicks` is `true`).
++ * @see [Tween]
++ */
++createjs.Tween.tick = function (delta) { }
++
++ /**
++ * @param {(Object|null)} props
++ * @see [Tween]
++ */
++createjs.Tween._cloneProps = function (props) { }
++
++
++ /**
++ * @param {(Object|null)} o
++ * @see [Tween]
++ */
++createjs.Tween._addStep = function (o) { }
+
+-// TODO: possibly add a END actionsMode (only runs actions that == position)?
+-// TODO: evaluate a way to decouple paused from tick registration.
+-
+-// namespace:
+-this.createjs = this.createjs||{};
+-
+-(function() {
+- "use strict";
+-
+-
+-// constructor
+- /**
+- * A Tween instance tweens properties for a single target. Instance methods can be chained for easy construction and sequencing:
+- *
+- * <h4>Example</h4>
+- *
+- * target.alpha = 1;
+- * createjs.Tween.get(target)
+- * .wait(500)
+- * .to({alpha:0, visible:false}, 1000)
+- * .call(handleComplete);
+- * function handleComplete() {
+- * //Tween complete
+- * }
+- *
+- * Multiple tweens can point to the same instance, however if they affect the same properties there could be unexpected
+- * behaviour. To stop all tweens on an object, use {{#crossLink "Tween/removeTweens"}}{{/crossLink}} or pass `override:true`
+- * in the props argument.
+- *
+- * createjs.Tween.get(target, {override:true}).to({x:100});
+- *
+- * Subscribe to the {{#crossLink "Tween/change:event"}}{{/crossLink}} event to get notified when a property of the
+- * target is changed.
+- *
+- * createjs.Tween.get(target, {override:true}).to({x:100}).addEventListener("change", handleChange);
+- * function handleChange(event) {
+- * // The tween changed.
+- * }
+- *
+- * See the Tween {{#crossLink "Tween/get"}}{{/crossLink}} method for additional param documentation.
+- * @class Tween
+- * @param {Object} target The target object that will have its properties tweened.
+- * @param {Object} [props] The configuration properties to apply to this tween instance (ex. `{loop:true, paused:true}`.
+- * All properties default to false. Supported props are:<UL>
+- * <LI> loop: sets the loop property on this tween.</LI>
+- * <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI>
+- * <LI> ignoreGlobalPause: sets the {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} property on this tween.</LI>
+- * <LI> override: if true, `Tween.removeTweens(target)` will be called to remove any other tweens with the same target.
+- * <LI> paused: indicates whether to start the tween paused.</LI>
+- * <LI> position: indicates the initial position for this tween.</LI>
+- * <LI> onChange: specifies a listener for the "change" event.</LI>
+- * </UL>
+- * @param {Object} [pluginData] An object containing data for use by installed plugins. See individual
+- * plugins' documentation for details.
+- * @extends EventDispatcher
+- * @constructor
+- */
+- function Tween(target, props, pluginData) {
+-
+- // public properties:
+- /**
+- * Causes this tween to continue playing when a global pause is active. For example, if TweenJS is using {{#crossLink "Ticker"}}{{/crossLink}},
+- * then setting this to true (the default) will cause this tween to be paused when <code>Ticker.setPaused(true)</code>
+- * is called. See the Tween {{#crossLink "Tween/tick"}}{{/crossLink}} method for more info. Can be set via the props
+- * parameter.
+- * @property ignoreGlobalPause
+- * @type Boolean
+- * @default false
+- */
+- this.ignoreGlobalPause = false;
+-
+- /**
+- * If true, the tween will loop when it reaches the end. Can be set via the props param.
+- * @property loop
+- * @type {Boolean}
+- * @default false
+- */
+- this.loop = false;
+-
+- /**
+- * Specifies the total duration of this tween in milliseconds (or ticks if useTicks is true).
+- * This value is automatically updated as you modify the tween. Changing it directly could result in unexpected
+- * behaviour.
+- * @property duration
+- * @type {Number}
+- * @default 0
+- * @readonly
+- */
+- this.duration = 0;
+-
+- /**
+- * Allows you to specify data that will be used by installed plugins. Each plugin uses this differently, but in general
+- * you specify data by setting it to a property of pluginData with the same name as the plugin class.
+- * @example
+- * myTween.pluginData.PluginClassName = data;
+- * <br/>
+- * Also, most plugins support a property to enable or disable them. This is typically the plugin class name followed by "_enabled".<br/>
+- * @example
+- * myTween.pluginData.PluginClassName_enabled = false;<br/>
+- * <br/>
+- * Some plugins also store instance data in this object, usually in a property named _PluginClassName.
+- * See the documentation for individual plugins for more details.
+- * @property pluginData
+- * @type {Object}
+- */
+- this.pluginData = pluginData || {};
+-
+- /**
+- * The target of this tween. This is the object on which the tweened properties will be changed. Changing
+- * this property after the tween is created will not have any effect.
+- * @property target
+- * @type {Object}
+- * @readonly
+- */
+- this.target = target;
+-
+- /**
+- * The current normalized position of the tween. This will always be a value between 0 and duration.
+- * Changing this property directly will have no effect.
+- * @property position
+- * @type {Object}
+- * @readonly
+- */
+- this.position = null;
+-
+- /**
+- * Indicates the tween's current position is within a passive wait.
+- * @property passive
+- * @type {Boolean}
+- * @default false
+- * @readonly
+- **/
+- this.passive = false;
+-
+- // private properties:
+- /**
+- * @property _paused
+- * @type {Boolean}
+- * @default false
+- * @protected
+- */
+- this._paused = false;
+-
+- /**
+- * @property _curQueueProps
+- * @type {Object}
+- * @protected
+- */
+- this._curQueueProps = {};
+-
+- /**
+- * @property _initQueueProps
+- * @type {Object}
+- * @protected
+- */
+- this._initQueueProps = {};
+-
+- /**
+- * @property _steps
+- * @type {Array}
+- * @protected
+- */
+- this._steps = [];
+-
+- /**
+- * @property _actions
+- * @type {Array}
+- * @protected
+- */
+- this._actions = [];
+-
+- /**
+- * Raw position.
+- * @property _prevPosition
+- * @type {Number}
+- * @default 0
+- * @protected
+- */
+- this._prevPosition = 0;
+-
+- /**
+- * The position within the current step.
+- * @property _stepPosition
+- * @type {Number}
+- * @default 0
+- * @protected
+- */
+- this._stepPosition = 0; // this is needed by MovieClip.
+-
+- /**
+- * Normalized position.
+- * @property _prevPos
+- * @type {Number}
+- * @default -1
+- * @protected
+- */
+- this._prevPos = -1;
+-
+- /**
+- * @property _target
+- * @type {Object}
+- * @protected
+- */
+- this._target = target;
+-
+- /**
+- * @property _useTicks
+- * @type {Boolean}
+- * @default false
+- * @protected
+- */
+- this._useTicks = false;
+-
+- /**
+- * @property _inited
+- * @type {boolean}
+- * @default false
+- * @protected
+- */
+- this._inited = false;
+-
+- /**
+- * Indicates whether the tween is currently registered with Tween.
+- * @property _registered
+- * @type {boolean}
+- * @default false
+- * @protected
+- */
+- this._registered = false;
+-
+-
+- if (props) {
+- this._useTicks = props.useTicks;
+- this.ignoreGlobalPause = props.ignoreGlobalPause;
+- this.loop = props.loop;
+- props.onChange && this.addEventListener("change", props.onChange);
+- if (props.override) { Tween.removeTweens(target); }
+- }
+- if (props&&props.paused) { this._paused=true; }
+- else { createjs.Tween._register(this,true); }
+- if (props&&props.position!=null) { this.setPosition(props.position, Tween.NONE); }
+-
+- };
+-
+- var p = createjs.extend(Tween, createjs.EventDispatcher);
+-
+- // TODO: deprecated
+- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details.
+-
+-
+-// static properties
+- /**
+- * Constant defining the none actionsMode for use with setPosition.
+- * @property NONE
+- * @type Number
+- * @default 0
+- * @static
+- */
+- Tween.NONE = 0;
+-
+- /**
+- * Constant defining the loop actionsMode for use with setPosition.
+- * @property LOOP
+- * @type Number
+- * @default 1
+- * @static
+- */
+- Tween.LOOP = 1;
+-
+- /**
+- * Constant defining the reverse actionsMode for use with setPosition.
+- * @property REVERSE
+- * @type Number
+- * @default 2
+- * @static
+- */
+- Tween.REVERSE = 2;
+-
+- /**
+- * Constant returned by plugins to tell the tween not to use default assignment.
+- * @property IGNORE
+- * @type Object
+- * @static
+- */
+- Tween.IGNORE = {};
+-
+- /**
+- * @property _listeners
+- * @type Array[Tween]
+- * @static
+- * @protected
+- */
+- Tween._tweens = [];
+-
+- /**
+- * @property _plugins
+- * @type Object
+- * @static
+- * @protected
+- */
+- Tween._plugins = {};
+-
+-
+-// static methods
+- /**
+- * Returns a new tween instance. This is functionally identical to using "new Tween(...)", but looks cleaner
+- * with the chained syntax of TweenJS.
+- * <h4>Example</h4>
+- *
+- * var tween = createjs.Tween.get(target);
+- *
+- * @method get
+- * @param {Object} target The target object that will have its properties tweened.
+- * @param {Object} [props] The configuration properties to apply to this tween instance (ex. `{loop:true, paused:true}`).
+- * All properties default to `false`. Supported props are:
+- * <UL>
+- * <LI> loop: sets the loop property on this tween.</LI>
+- * <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI>
+- * <LI> ignoreGlobalPause: sets the {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} property on
+- * this tween.</LI>
+- * <LI> override: if true, `createjs.Tween.removeTweens(target)` will be called to remove any other tweens with
+- * the same target.
+- * <LI> paused: indicates whether to start the tween paused.</LI>
+- * <LI> position: indicates the initial position for this tween.</LI>
+- * <LI> onChange: specifies a listener for the {{#crossLink "Tween/change:event"}}{{/crossLink}} event.</LI>
+- * </UL>
+- * @param {Object} [pluginData] An object containing data for use by installed plugins. See individual plugins'
+- * documentation for details.
+- * @param {Boolean} [override=false] If true, any previous tweens on the same target will be removed. This is the
+- * same as calling `Tween.removeTweens(target)`.
+- * @return {Tween} A reference to the created tween. Additional chained tweens, method calls, or callbacks can be
+- * applied to the returned tween instance.
+- * @static
+- */
+- Tween.get = function(target, props, pluginData, override) {
+- if (override) { Tween.removeTweens(target); }
+- return new Tween(target, props, pluginData);
+- };
+-
+- /**
+- * Advances all tweens. This typically uses the {{#crossLink "Ticker"}}{{/crossLink}} class, but you can call it
+- * manually if you prefer to use your own "heartbeat" implementation.
+- * @method tick
+- * @param {Number} delta The change in time in milliseconds since the last tick. Required unless all tweens have
+- * `useTicks` set to true.
+- * @param {Boolean} paused Indicates whether a global pause is in effect. Tweens with {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}}
+- * will ignore this, but all others will pause if this is `true`.
+- * @static
+- */
+- Tween.tick = function(delta, paused) {
+- var tweens = Tween._tweens.slice(); // to avoid race conditions.
+- for (var i=tweens.length-1; i>=0; i--) {
+- var tween = tweens[i];
+- if ((paused && !tween.ignoreGlobalPause) || tween._paused) { continue; }
+- tween.tick(tween._useTicks?1:delta);
+- }
+- };
+-
+- /**
+- * Handle events that result from Tween being used as an event handler. This is included to allow Tween to handle
+- * {{#crossLink "Ticker/tick:event"}}{{/crossLink}} events from the createjs {{#crossLink "Ticker"}}{{/crossLink}}.
+- * No other events are handled in Tween.
+- * @method handleEvent
+- * @param {Object} event An event object passed in by the {{#crossLink "EventDispatcher"}}{{/crossLink}}. Will
+- * usually be of type "tick".
+- * @private
+- * @static
+- * @since 0.4.2
+- */
+- Tween.handleEvent = function(event) {
+- if (event.type == "tick") {
+- this.tick(event.delta, event.paused);
+- }
+- };
+-
+- /**
+- * Removes all existing tweens for a target. This is called automatically by new tweens if the `override`
+- * property is `true`.
+- * @method removeTweens
+- * @param {Object} target The target object to remove existing tweens from.
+- * @static
+- */
+- Tween.removeTweens = function(target) {
+- if (!target.tweenjs_count) { return; }
+- var tweens = Tween._tweens;
+- for (var i=tweens.length-1; i>=0; i--) {
+- var tween = tweens[i];
+- if (tween._target == target) {
+- tween._paused = true;
+- tweens.splice(i, 1);
+- }
+- }
+- target.tweenjs_count = 0;
+- };
+-
+- /**
+- * Stop and remove all existing tweens.
+- * @method removeAllTweens
+- * @static
+- * @since 0.4.1
+- */
+- Tween.removeAllTweens = function() {
+- var tweens = Tween._tweens;
+- for (var i= 0, l=tweens.length; i<l; i++) {
+- var tween = tweens[i];
+- tween._paused = true;
+- tween.target&&(tween.target.tweenjs_count = 0);
+- }
+- tweens.length = 0;
+- };
+-
+- /**
+- * Indicates whether there are any active tweens (and how many) on the target object (if specified) or in general.
+- * @method hasActiveTweens
+- * @param {Object} [target] The target to check for active tweens. If not specified, the return value will indicate
+- * if there are any active tweens on any target.
+- * @return {Boolean} If there are active tweens.
+- * @static
+- */
+- Tween.hasActiveTweens = function(target) {
+- if (target) { return target.tweenjs_count != null && !!target.tweenjs_count; }
+- return Tween._tweens && !!Tween._tweens.length;
+- };
+-
+- /**
+- * Installs a plugin, which can modify how certain properties are handled when tweened. See the {{#crossLink "CSSPlugin"}}{{/crossLink}}
+- * for an example of how to write TweenJS plugins.
+- * @method installPlugin
+- * @static
+- * @param {Object} plugin The plugin class to install
+- * @param {Array} properties An array of properties that the plugin will handle.
+- */
+- Tween.installPlugin = function(plugin, properties) {
+- var priority = plugin.priority;
+- if (priority == null) { plugin.priority = priority = 0; }
+- for (var i=0,l=properties.length,p=Tween._plugins;i<l;i++) {
+- var n = properties[i];
+- if (!p[n]) { p[n] = [plugin]; }
+- else {
+- var arr = p[n];
+- for (var j=0,jl=arr.length;j<jl;j++) {
+- if (priority < arr[j].priority) { break; }
+- }
+- p[n].splice(j,0,plugin);
+- }
+- }
+- };
+-
+- /**
+- * Registers or unregisters a tween with the ticking system.
+- * @method _register
+- * @param {Tween} tween The tween instance to register or unregister.
+- * @param {Boolean} value If `true`, the tween is registered. If `false` the tween is unregistered.
+- * @static
+- * @protected
+- */
+- Tween._register = function(tween, value) {
+- var target = tween._target;
+- var tweens = Tween._tweens;
+- if (value && !tween._registered) {
+- // TODO: this approach might fail if a dev is using sealed objects in ES5
+- if (target) { target.tweenjs_count = target.tweenjs_count ? target.tweenjs_count+1 : 1; }
+- tweens.push(tween);
+- if (!Tween._inited && createjs.Ticker) { createjs.Ticker.addEventListener("tick", Tween); Tween._inited = true; }
+- } else if (!value && tween._registered) {
+- if (target) { target.tweenjs_count--; }
+- var i = tweens.length;
+- while (i--) {
+- if (tweens[i] == tween) {
+- tweens.splice(i, 1);
+- break;
+- }
+- }
+- }
+- tween._registered = value;
+- };
+-
+-
+-// events:
+- /**
+- * Called whenever the tween's position changes.
+- * @event change
+- * @since 0.4.0
+- **/
+-
+-
+-// public methods:
+- /**
+- * Queues a wait (essentially an empty tween).
+- * <h4>Example</h4>
+- *
+- * //This tween will wait 1s before alpha is faded to 0.
+- * createjs.Tween.get(target).wait(1000).to({alpha:0}, 1000);
+- *
+- * @method wait
+- * @param {Number} duration The duration of the wait in milliseconds (or in ticks if `useTicks` is true).
+- * @param {Boolean} [passive] Tween properties will not be updated during a passive wait. This
+- * is mostly useful for use with {{#crossLink "Timeline"}}{{/crossLink}} instances that contain multiple tweens
+- * affecting the same target at different times.
+- * @return {Tween} This tween instance (for chaining calls).
+- **/
+- p.wait = function(duration, passive) {
+- if (duration == null || duration <= 0) { return this; }
+- var o = this._cloneProps(this._curQueueProps);
+- return this._addStep({d:duration, p0:o, e:this._linearEase, p1:o, v:passive});
+- };
+-
+- /**
+- * Queues a tween from the current values to the target properties. Set duration to 0 to jump to these value.
+- * Numeric properties will be tweened from their current value in the tween to the target value. Non-numeric
+- * properties will be set at the end of the specified duration.
+- * <h4>Example</h4>
+- *
+- * createjs.Tween.get(target).to({alpha:0}, 1000);
+- *
+- * @method to
+- * @param {Object} props An object specifying property target values for this tween (Ex. `{x:300}` would tween the x
+- * property of the target to 300).
+- * @param {Number} [duration=0] The duration of the wait in milliseconds (or in ticks if `useTicks` is true).
+- * @param {Function} [ease="linear"] The easing function to use for this tween. See the {{#crossLink "Ease"}}{{/crossLink}}
+- * class for a list of built-in ease functions.
+- * @return {Tween} This tween instance (for chaining calls).
+- */
+- p.to = function(props, duration, ease) {
+- if (isNaN(duration) || duration < 0) { duration = 0; }
+- return this._addStep({d:duration||0, p0:this._cloneProps(this._curQueueProps), e:ease, p1:this._cloneProps(this._appendQueueProps(props))});
+- };
+-
+- /**
+- * Queues an action to call the specified function
<TRUNCATED>