Repository: flex-falcon Updated Branches: refs/heads/develop fc4e3af9f -> 434e05866
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/434e0586/externs/createjs/src/main/patch/tweenjs2.patch ---------------------------------------------------------------------- diff --git a/externs/createjs/src/main/patch/tweenjs2.patch b/externs/createjs/src/main/patch/tweenjs2.patch new file mode 100644 index 0000000..4326c78 --- /dev/null +++ b/externs/createjs/src/main/patch/tweenjs2.patch @@ -0,0 +1,1462 @@ +diff -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js TweenJS-0.6.2/src/tweenjs/CSSPlugin.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/CSSPlugin.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // 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 +@@ -49,7 +45,7 @@ + * @class CSSPlugin + * @constructor + **/ +- function CSSPlugin() { ++ createjs.CSSPlugin = function() { + throw("CSSPlugin cannot be instantiated.") + } + +@@ -65,14 +61,14 @@ + * @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 +77,8 @@ + * @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 +88,8 @@ + * @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 +106,7 @@ + * @protected + * @static + **/ +- CSSPlugin.step = function(tween, prop, startValue, endValue, injectProps) { ++ createjs.CSSPlugin.step = function(tween, prop, startValue, endValue, injectProps) { + // unused + } + +@@ -119,13 +115,13 @@ + * @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 -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js TweenJS-0.6.2/src/tweenjs/Ease.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/Ease.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // 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 +@@ -42,11 +38,11 @@ + * + * Most methods on Ease can be passed directly as easing functions: + * +- * Tween.get(target).to({x:100}, 500, Ease.linear); ++ * 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, Ease.getPowIn(2.2)); ++ * 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>. +@@ -55,7 +51,7 @@ + * @class Ease + * @static + **/ +- function Ease() { ++ createjs.Ease = function() { + throw "Ease cannot be instantiated."; + } + +@@ -67,7 +63,7 @@ + * @static + * @return {Number} + **/ +- Ease.linear = function(t) { return t; }; ++ createjs.Ease.linear = function(t) { return t; }; + + /** + * Identical to linear. +@@ -76,7 +72,7 @@ + * @static + * @return {Number} + **/ +- Ease.none = Ease.linear; ++ createjs.Ease.none = createjs.Ease.linear; + + /** + * Mimics the simple -100 to 100 easing in Flash Pro. +@@ -85,7 +81,7 @@ + * @static + * @return {Function} + **/ +- Ease.get = function(amount) { ++ createjs.Ease.get = function(amount) { + if (amount < -1) { amount = -1; } + if (amount > 1) { amount = 1; } + return function(t) { +@@ -102,7 +98,7 @@ + * @static + * @return {Function} + **/ +- Ease.getPowIn = function(pow) { ++ createjs.Ease.getPowIn = function(pow) { + return function(t) { + return Math.pow(t,pow); + }; +@@ -115,7 +111,7 @@ + * @static + * @return {Function} + **/ +- Ease.getPowOut = function(pow) { ++ createjs.Ease.getPowOut = function(pow) { + return function(t) { + return 1-Math.pow(1-t,pow); + }; +@@ -128,7 +124,7 @@ + * @static + * @return {Function} + **/ +- Ease.getPowInOut = function(pow) { ++ createjs.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)); +@@ -141,21 +137,21 @@ + * @static + * @return {Number} + **/ +- Ease.quadIn = Ease.getPowIn(2); ++ createjs.Ease.quadIn = createjs.Ease.getPowIn(2); + /** + * @method quadOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.quadOut = Ease.getPowOut(2); ++ createjs.Ease.quadOut = createjs.Ease.getPowOut(2); + /** + * @method quadInOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.quadInOut = Ease.getPowInOut(2); ++ createjs.Ease.quadInOut = createjs.Ease.getPowInOut(2); + + /** + * @method cubicIn +@@ -163,21 +159,21 @@ + * @static + * @return {Number} + **/ +- Ease.cubicIn = Ease.getPowIn(3); ++ createjs.Ease.cubicIn = createjs.Ease.getPowIn(3); + /** + * @method cubicOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.cubicOut = Ease.getPowOut(3); ++ createjs.Ease.cubicOut = createjs.Ease.getPowOut(3); + /** + * @method cubicInOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.cubicInOut = Ease.getPowInOut(3); ++ createjs.Ease.cubicInOut = createjs.Ease.getPowInOut(3); + + /** + * @method quartIn +@@ -185,21 +181,21 @@ + * @static + * @return {Number} + **/ +- Ease.quartIn = Ease.getPowIn(4); ++ createjs.Ease.quartIn = createjs.Ease.getPowIn(4); + /** + * @method quartOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.quartOut = Ease.getPowOut(4); ++ createjs.Ease.quartOut = createjs.Ease.getPowOut(4); + /** + * @method quartInOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.quartInOut = Ease.getPowInOut(4); ++ createjs.Ease.quartInOut = createjs.Ease.getPowInOut(4); + + /** + * @method quintIn +@@ -207,21 +203,21 @@ + * @static + * @return {Number} + **/ +- Ease.quintIn = Ease.getPowIn(5); ++ createjs.Ease.quintIn = createjs.Ease.getPowIn(5); + /** + * @method quintOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.quintOut = Ease.getPowOut(5); ++ createjs.Ease.quintOut = createjs.Ease.getPowOut(5); + /** + * @method quintInOut + * @param {Number} t + * @static + * @return {Number} + **/ +- Ease.quintInOut = Ease.getPowInOut(5); ++ createjs.Ease.quintInOut = createjs.Ease.getPowInOut(5); + + /** + * @method sineIn +@@ -229,7 +225,7 @@ + * @static + * @return {Number} + **/ +- Ease.sineIn = function(t) { ++ createjs.Ease.sineIn = function(t) { + return 1-Math.cos(t*Math.PI/2); + }; + +@@ -239,7 +235,7 @@ + * @static + * @return {Number} + **/ +- Ease.sineOut = function(t) { ++ createjs.Ease.sineOut = function(t) { + return Math.sin(t*Math.PI/2); + }; + +@@ -249,7 +245,7 @@ + * @static + * @return {Number} + **/ +- Ease.sineInOut = function(t) { ++ createjs.Ease.sineInOut = function(t) { + return -0.5*(Math.cos(Math.PI*t) - 1); + }; + +@@ -260,7 +256,7 @@ + * @static + * @return {Function} + **/ +- Ease.getBackIn = function(amount) { ++ createjs.Ease.getBackIn = function(amount) { + return function(t) { + return t*t*((amount+1)*t-amount); + }; +@@ -271,7 +267,7 @@ + * @static + * @return {Number} + **/ +- Ease.backIn = Ease.getBackIn(1.7); ++ createjs.Ease.backIn = createjs.Ease.getBackIn(1.7); + + /** + * Configurable "back out" ease. +@@ -280,7 +276,7 @@ + * @static + * @return {Function} + **/ +- Ease.getBackOut = function(amount) { ++ createjs.Ease.getBackOut = function(amount) { + return function(t) { + return (--t*t*((amount+1)*t + amount) + 1); + }; +@@ -291,7 +287,7 @@ + * @static + * @return {Number} + **/ +- Ease.backOut = Ease.getBackOut(1.7); ++ createjs.Ease.backOut = createjs.Ease.getBackOut(1.7); + + /** + * Configurable "back in out" ease. +@@ -300,7 +296,7 @@ + * @static + * @return {Function} + **/ +- Ease.getBackInOut = function(amount) { ++ createjs.Ease.getBackInOut = function(amount) { + amount*=1.525; + return function(t) { + if ((t*=2)<1) return 0.5*(t*t*((amount+1)*t-amount)); +@@ -313,7 +309,7 @@ + * @static + * @return {Number} + **/ +- Ease.backInOut = Ease.getBackInOut(1.7); ++ createjs.Ease.backInOut = createjs.Ease.getBackInOut(1.7); + + /** + * @method circIn +@@ -321,7 +317,7 @@ + * @static + * @return {Number} + **/ +- Ease.circIn = function(t) { ++ createjs.Ease.circIn = function(t) { + return -(Math.sqrt(1-t*t)- 1); + }; + +@@ -331,7 +327,7 @@ + * @static + * @return {Number} + **/ +- Ease.circOut = function(t) { ++ createjs.Ease.circOut = function(t) { + return Math.sqrt(1-(--t)*t); + }; + +@@ -341,7 +337,7 @@ + * @static + * @return {Number} + **/ +- Ease.circInOut = function(t) { ++ createjs.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); + }; +@@ -352,8 +348,8 @@ + * @static + * @return {Number} + **/ +- Ease.bounceIn = function(t) { +- return 1-Ease.bounceOut(1-t); ++ createjs.Ease.bounceIn = function(t) { ++ return 1-createjs.Ease.bounceOut(1-t); + }; + + /** +@@ -362,7 +358,7 @@ + * @static + * @return {Number} + **/ +- Ease.bounceOut = function(t) { ++ createjs.Ease.bounceOut = function(t) { + if (t < 1/2.75) { + return (7.5625*t*t); + } else if (t < 2/2.75) { +@@ -380,9 +376,9 @@ + * @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; ++ createjs.Ease.bounceInOut = function(t) { ++ if (t<0.5) return createjs.Ease.bounceIn (t*2) * .5; ++ return createjs.Ease.bounceOut(t*2-1)*0.5+0.5; + }; + + /** +@@ -393,7 +389,7 @@ + * @static + * @return {Function} + **/ +- Ease.getElasticIn = function(amplitude,period) { ++ createjs.Ease.getElasticIn = function(amplitude,period) { + var pi2 = Math.PI*2; + return function(t) { + if (t==0 || t==1) return t; +@@ -407,7 +403,7 @@ + * @static + * @return {Number} + **/ +- Ease.elasticIn = Ease.getElasticIn(1,0.3); ++ createjs.Ease.elasticIn = createjs.Ease.getElasticIn(1,0.3); + + /** + * Configurable elastic ease. +@@ -417,7 +413,7 @@ + * @static + * @return {Function} + **/ +- Ease.getElasticOut = function(amplitude,period) { ++ createjs.Ease.getElasticOut = function(amplitude,period) { + var pi2 = Math.PI*2; + return function(t) { + if (t==0 || t==1) return t; +@@ -431,7 +427,7 @@ + * @static + * @return {Number} + **/ +- Ease.elasticOut = Ease.getElasticOut(1,0.3); ++ createjs.Ease.elasticOut = createjs.Ease.getElasticOut(1,0.3); + + /** + * Configurable elastic ease. +@@ -441,7 +437,7 @@ + * @static + * @return {Function} + **/ +- Ease.getElasticInOut = function(amplitude,period) { ++ createjs.Ease.getElasticInOut = function(amplitude,period) { + var pi2 = Math.PI*2; + return function(t) { + var s = period/pi2 * Math.asin(1/amplitude); +@@ -455,8 +451,8 @@ + * @static + * @return {Number} + **/ +- Ease.elasticInOut = Ease.getElasticInOut(1,0.3*1.5); ++ createjs.Ease.elasticInOut = createjs.Ease.getElasticInOut(1,0.3*1.5); ++ ++ + +- createjs.Ease = Ease; + +-}()); +diff -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + /** + * A TweenJS plugin for working with motion guides. +@@ -68,7 +64,7 @@ + * @class MotionGuidePlugin + * @constructor + **/ +- function MotionGuidePlugin() { ++ createjs.MotionGuidePlugin = function() { + throw("MotionGuidePlugin cannot be instantiated.") + }; + +@@ -79,32 +75,32 @@ + * @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 +109,7 @@ + * @method install + * @static + **/ +- MotionGuidePlugin.install = function() { ++ createjs.MotionGuidePlugin.install = function() { + createjs.Tween.installPlugin(MotionGuidePlugin, ["guide", "x", "y", "rotation"]); + return createjs.Tween.IGNORE; + }; +@@ -123,7 +119,7 @@ + * @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 +134,12 @@ + * @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 +187,18 @@ + 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 +207,7 @@ + * @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 +252,13 @@ + * @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 +275,13 @@ + /** + * 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 +322,6 @@ + return target; + }; + +- createjs.MotionGuidePlugin = MotionGuidePlugin; ++ ++ + +-}()); +diff -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js TweenJS-0.6.2/src/tweenjs/SamplePlugin.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/SamplePlugin.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // 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 +41,7 @@ + * @class SamplePlugin + * @constructor + **/ +- function SamplePlugin() { ++ createjs.SamplePlugin = function() { + throw("SamplePlugin cannot be instantiated.") + }; + +@@ -56,7 +52,7 @@ + * @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 +60,7 @@ + * @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 +71,12 @@ + * @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 +89,14 @@ + * @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 +105,7 @@ + * @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 +116,13 @@ + * 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 +131,6 @@ + }; + + +- createjs.SamplePlugin = SamplePlugin; ++ ++ + +-}()); +diff -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js TweenJS-0.6.2/src/tweenjs/Timeline.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/Timeline.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,11 +31,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +- +-(function() { +- "use strict"; + + + // constructor +@@ -57,10 +52,10 @@ + * <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 ++ * @extends createjs.EventDispatcher + * @constructor + **/ +- function Timeline(tweens, labels, props) { ++ createjs.Timeline = function(tweens, labels, props) { + this.EventDispatcher_constructor(); + + // public properties: +@@ -176,10 +171,10 @@ + + }; + +- var p = createjs.extend(Timeline, createjs.EventDispatcher); ++ + + // TODO: deprecated +- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. ++ // createjs.Timeline.prototype.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. + + + // events: +@@ -199,7 +194,7 @@ + * @param {Tween} ...tween The tween(s) to add. Accepts multiple arguments. + * @return {Tween} The first tween that was passed in. + **/ +- p.addTween = function(tween) { ++ createjs.Timeline.prototype.addTween = function(tween) { + var l = arguments.length; + if (l > 1) { + for (var i=0; i<l; i++) { this.addTween(arguments[i]); } +@@ -221,7 +216,7 @@ + * @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) { ++ createjs.Timeline.prototype.removeTween = function(tween) { + var l = arguments.length; + if (l > 1) { + var good = true; +@@ -247,7 +242,7 @@ + * @param {String} label The label name. + * @param {Number} position The position this label represents. + **/ +- p.addLabel = function(label, position) { ++ createjs.Timeline.prototype.addLabel = function(label, position) { + this._labels[label] = position; + var list = this._labelList; + if (list) { +@@ -262,7 +257,7 @@ + * @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) { ++ createjs.Timeline.prototype.setLabels = function(o) { + this._labels = o ? o : {}; + }; + +@@ -271,7 +266,7 @@ + * @method getLabels + * @return {Array[Object]} A sorted array of objects with label and position properties. + **/ +- p.getLabels = function() { ++ createjs.Timeline.prototype.getLabels = function() { + var list = this._labelList; + if (!list) { + list = this._labelList = []; +@@ -296,7 +291,7 @@ + * @method getCurrentLabel + * @return {String} The name of the current label or null if there is no label + **/ +- p.getCurrentLabel = function() { ++ createjs.Timeline.prototype.getCurrentLabel = function() { + var labels = this.getLabels(); + var pos = this.position; + var l = labels.length; +@@ -313,7 +308,7 @@ + * @param {String|Number} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) + * or label to jump to. + **/ +- p.gotoAndPlay = function(positionOrLabel) { ++ createjs.Timeline.prototype.gotoAndPlay = function(positionOrLabel) { + this.setPaused(false); + this._goto(positionOrLabel); + }; +@@ -324,7 +319,7 @@ + * @param {String|Number} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label + * to jump to. + **/ +- p.gotoAndStop = function(positionOrLabel) { ++ createjs.Timeline.prototype.gotoAndStop = function(positionOrLabel) { + this.setPaused(true); + this._goto(positionOrLabel); + }; +@@ -338,7 +333,7 @@ + * @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) { ++ createjs.Timeline.prototype.setPosition = function(value, actionsMode) { + var t = this._calcPosition(value); + var end = !this.loop && value >= this.duration; + if (t == this._prevPos) { return end; } +@@ -358,7 +353,7 @@ + * @method setPaused + * @param {Boolean} value Indicates whether the tween should be paused (`true`) or played (`false`). + **/ +- p.setPaused = function(value) { ++ createjs.Timeline.prototype.setPaused = function(value) { + this._paused = !!value; + createjs.Tween._register(this, !value); + }; +@@ -368,7 +363,7 @@ + * but this method is useful if you modify a tween after it was added to the timeline. + * @method updateDuration + **/ +- p.updateDuration = function() { ++ createjs.Timeline.prototype.updateDuration = function() { + this.duration = 0; + for (var i=0,l=this._tweens.length; i<l; i++) { + var tween = this._tweens[i]; +@@ -383,7 +378,7 @@ + * @method tick + * @param {Number} delta The time to advance in milliseconds (or ticks if useTicks is true). + **/ +- p.tick = function(delta) { ++ createjs.Timeline.prototype.tick = function(delta) { + this.setPosition(this._prevPosition+delta); + }; + +@@ -393,7 +388,7 @@ + * @method resolve + * @param {String|Number} positionOrLabel A numeric position value or label string. + **/ +- p.resolve = function(positionOrLabel) { ++ createjs.Timeline.prototype.resolve = function(positionOrLabel) { + var pos = Number(positionOrLabel); + if (isNaN(pos)) { pos = this._labels[positionOrLabel]; } + return pos; +@@ -404,7 +399,7 @@ + * @method toString + * @return {String} a string representation of the instance. + **/ +- p.toString = function() { ++ createjs.Timeline.prototype.toString = function() { + return "[Timeline]"; + }; + +@@ -412,7 +407,7 @@ + * @method clone + * @protected + **/ +- p.clone = function() { ++ createjs.Timeline.prototype.clone = function() { + throw("Timeline can not be cloned.") + }; + +@@ -422,7 +417,7 @@ + * @param {String | Number} positionOrLabel + * @protected + **/ +- p._goto = function(positionOrLabel) { ++ createjs.Timeline.prototype._goto = function(positionOrLabel) { + var pos = this.resolve(positionOrLabel); + if (pos != null) { this.setPosition(pos); } + }; +@@ -433,12 +428,12 @@ + * @return {Number} + * @protected + **/ +- p._calcPosition = function(value) { ++ createjs.Timeline.prototype._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 -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js TweenJS-0.6.2/src/tweenjs/Tween.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/Tween.js 2016-05-31 11:03:07.000000000 +0200 +@@ -70,10 +70,6 @@ + // TODO: evaluate a way to decouple paused from tick registration. + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + + // constructor +@@ -113,17 +109,17 @@ + * <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> 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 "change" event.</LI> + * </UL> + * @param {Object} [pluginData] An object containing data for use by installed plugins. See individual + * plugins' documentation for details. +- * @extends EventDispatcher ++ * @extends createjs.EventDispatcher + * @constructor + */ +- function Tween(target, props, pluginData) { ++ createjs.Tween = function(target, props, pluginData) { + + // public properties: + /** +@@ -160,11 +156,11 @@ + * 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; ++ * mycreatejs.Tween.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/> ++ * mycreatejs.Tween.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. +@@ -288,7 +284,7 @@ + this._inited = false; + + /** +- * Indicates whether the tween is currently registered with Tween. ++ * Indicates whether the tween is currently registered with createjs.Tween. + * @property _registered + * @type {boolean} + * @default false +@@ -302,18 +298,18 @@ + this.ignoreGlobalPause = props.ignoreGlobalPause; + this.loop = props.loop; + props.onChange && this.addEventListener("change", props.onChange); +- if (props.override) { Tween.removeTweens(target); } ++ if (props.override) { createjs.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); } ++ if (props&&props.position!=null) { this.setPosition(props.position, createjs.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. ++ // createjs.Tween.prototype.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. + + + // static properties +@@ -324,7 +320,7 @@ + * @default 0 + * @static + */ +- Tween.NONE = 0; ++ createjs.Tween.NONE = 0; + + /** + * Constant defining the loop actionsMode for use with setPosition. +@@ -333,7 +329,7 @@ + * @default 1 + * @static + */ +- Tween.LOOP = 1; ++ createjs.Tween.LOOP = 1; + + /** + * Constant defining the reverse actionsMode for use with setPosition. +@@ -342,7 +338,7 @@ + * @default 2 + * @static + */ +- Tween.REVERSE = 2; ++ createjs.Tween.REVERSE = 2; + + /** + * Constant returned by plugins to tell the tween not to use default assignment. +@@ -350,7 +346,7 @@ + * @type Object + * @static + */ +- Tween.IGNORE = {}; ++ createjs.Tween.IGNORE = {}; + + /** + * @property _listeners +@@ -358,7 +354,7 @@ + * @static + * @protected + */ +- Tween._tweens = []; ++ createjs.Tween._tweens = []; + + /** + * @property _plugins +@@ -366,7 +362,7 @@ + * @static + * @protected + */ +- Tween._plugins = {}; ++ createjs.Tween._plugins = {}; + + + // static methods +@@ -395,13 +391,13 @@ + * @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)`. ++ * same as calling `createjs.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); } ++ createjs.Tween.get = function(target, props, pluginData, override) { ++ if (override) { createjs.Tween.removeTweens(target); } + return new Tween(target, props, pluginData); + }; + +@@ -415,8 +411,8 @@ + * 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. ++ createjs.Tween.tick = function(delta, paused) { ++ var tweens = createjs.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; } +@@ -427,7 +423,7 @@ + /** + * 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. ++ * No other events are handled in createjs.Tween. + * @method handleEvent + * @param {Object} event An event object passed in by the {{#crossLink "EventDispatcher"}}{{/crossLink}}. Will + * usually be of type "tick". +@@ -435,7 +431,7 @@ + * @static + * @since 0.4.2 + */ +- Tween.handleEvent = function(event) { ++ createjs.Tween.handleEvent = function(event) { + if (event.type == "tick") { + this.tick(event.delta, event.paused); + } +@@ -448,9 +444,9 @@ + * @param {Object} target The target object to remove existing tweens from. + * @static + */ +- Tween.removeTweens = function(target) { ++ createjs.Tween.removeTweens = function(target) { + if (!target.tweenjs_count) { return; } +- var tweens = Tween._tweens; ++ var tweens = createjs.Tween._tweens; + for (var i=tweens.length-1; i>=0; i--) { + var tween = tweens[i]; + if (tween._target == target) { +@@ -467,8 +463,8 @@ + * @static + * @since 0.4.1 + */ +- Tween.removeAllTweens = function() { +- var tweens = Tween._tweens; ++ createjs.Tween.removeAllTweens = function() { ++ var tweens = createjs.Tween._tweens; + for (var i= 0, l=tweens.length; i<l; i++) { + var tween = tweens[i]; + tween._paused = true; +@@ -485,9 +481,9 @@ + * @return {Boolean} If there are active tweens. + * @static + */ +- Tween.hasActiveTweens = function(target) { ++ createjs.Tween.hasActiveTweens = function(target) { + if (target) { return target.tweenjs_count != null && !!target.tweenjs_count; } +- return Tween._tweens && !!Tween._tweens.length; ++ return createjs.Tween._tweens && !!createjs.Tween._tweens.length; + }; + + /** +@@ -498,10 +494,10 @@ + * @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) { ++ createjs.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++) { ++ for (var i=0,l=properties.length,p=createjs.Tween._plugins;i<l;i++) { + var n = properties[i]; + if (!p[n]) { p[n] = [plugin]; } + else { +@@ -522,14 +518,14 @@ + * @static + * @protected + */ +- Tween._register = function(tween, value) { ++ createjs.Tween._register = function(tween, value) { + var target = tween._target; +- var tweens = Tween._tweens; ++ var tweens = createjs.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; } ++ if (!createjs.Tween._inited && createjs.Ticker) { createjs.Ticker.addEventListener("tick", Tween); createjs.Tween._inited = true; } + } else if (!value && tween._registered) { + if (target) { target.tweenjs_count--; } + var i = tweens.length; +@@ -567,7 +563,7 @@ + * affecting the same target at different times. + * @return {Tween} This tween instance (for chaining calls). + **/ +- p.wait = function(duration, passive) { ++ createjs.Tween.prototype.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}); +@@ -589,7 +585,7 @@ + * class for a list of built-in ease functions. + * @return {Tween} This tween instance (for chaining calls). + */ +- p.to = function(props, duration, ease) { ++ createjs.Tween.prototype.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))}); + }; +@@ -599,7 +595,7 @@ + * <h4>Example</h4> + * + * //would call myFunction() after 1 second. +- * myTween.wait(1000).call(myFunction); ++ * mycreatejs.Tween.wait(1000).call(myFunction); + * + * @method call + * @param {Function} callback The function to call. +@@ -609,7 +605,7 @@ + * scope. + * @return {Tween} This tween instance (for chaining calls). + */ +- p.call = function(callback, params, scope) { ++ createjs.Tween.prototype.call = function(callback, params, scope) { + return this._addAction({f:callback, p:params ? params : [this], o:scope ? scope : this._target}); + }; + +@@ -619,14 +615,14 @@ + * target. + * <h4>Example</h4> + * +- * myTween.wait(1000).set({visible:false},foo); ++ * mycreatejs.Tween.wait(1000).set({visible:false},foo); + * + * @method set + * @param {Object} props The properties to set (ex. `{visible:false}`). + * @param {Object} [target] The target to set the properties on. If omitted, they will be set on the tween's target. + * @return {Tween} This tween instance (for chaining calls). + */ +- p.set = function(props, target) { ++ createjs.Tween.prototype.set = function(props, target) { + return this._addAction({f:this._set, o:this, p:[props, target ? target : this._target]}); + }; + +@@ -634,13 +630,13 @@ + * Queues an action to play (unpause) the specified tween. This enables you to sequence multiple tweens. + * <h4>Example</h4> + * +- * myTween.to({x:100},500).play(otherTween); ++ * mycreatejs.Tween.to({x:100},500).play(otherTween); + * + * @method play + * @param {Tween} tween The tween to play. + * @return {Tween} This tween instance (for chaining calls). + */ +- p.play = function(tween) { ++ createjs.Tween.prototype.play = function(tween) { + if (!tween) { tween = this; } + return this.call(tween.setPaused, [false], tween); + }; +@@ -651,7 +647,7 @@ + * @param {Tween} tween The tween to pause. If null, it pauses this tween. + * @return {Tween} This tween instance (for chaining calls) + */ +- p.pause = function(tween) { ++ createjs.Tween.prototype.pause = function(tween) { + if (!tween) { tween = this; } + return this.call(tween.setPaused, [true], tween); + }; +@@ -671,7 +667,7 @@ + * @return {Boolean} Returns `true` if the tween is complete (ie. the full tween has run & {{#crossLink "Tween/loop:property"}}{{/crossLink}} + * is `false`). + */ +- p.setPosition = function(value, actionsMode) { ++ createjs.Tween.prototype.setPosition = function(value, actionsMode) { + if (value < 0) { value = 0; } + if (actionsMode == null) { actionsMode = 1; } + +@@ -733,7 +729,7 @@ + * @method tick + * @param {Number} delta The time to advance in milliseconds (or ticks if `useTicks` is `true`). + */ +- p.tick = function(delta) { ++ createjs.Tween.prototype.tick = function(delta) { + if (this._paused) { return; } + this.setPosition(this._prevPosition+delta); + }; +@@ -744,25 +740,25 @@ + * @param {Boolean} [value=true] Indicates whether the tween should be paused (`true`) or played (`false`). + * @return {Tween} This tween instance (for chaining calls) + */ +- p.setPaused = function(value) { ++ createjs.Tween.prototype.setPaused = function(value) { + if (this._paused === !!value) { return this; } + this._paused = !!value; +- Tween._register(this, !value); ++ createjs.Tween._register(this, !value); + return this; + }; + + // tiny api (primarily for tool output): +- p.w = p.wait; +- p.t = p.to; +- p.c = p.call; +- p.s = p.set; ++ createjs.Tween.prototype.w = createjs.Tween.prototype.wait; ++ createjs.Tween.prototype.t = createjs.Tween.prototype.to; ++ createjs.Tween.prototype.c = createjs.Tween.prototype.call; ++ createjs.Tween.prototype.s = createjs.Tween.prototype.set; + + /** + * Returns a string representation of this object. + * @method toString + * @return {String} a string representation of the instance. + */ +- p.toString = function() { ++ createjs.Tween.prototype.toString = function() { + return "[Tween]"; + }; + +@@ -770,7 +766,7 @@ + * @method clone + * @protected + */ +- p.clone = function() { ++ createjs.Tween.prototype.clone = function() { + throw("Tween can not be cloned.") + }; + +@@ -781,7 +777,7 @@ + * @param {Number} ratio + * @protected + */ +- p._updateTargetProps = function(step, ratio) { ++ createjs.Tween.prototype._updateTargetProps = function(step, ratio) { + var p0,p1,v,v0,v1,arr; + if (!step && ratio == 1) { + // GDS: when does this run? Just at the very end? Shouldn't. +@@ -807,10 +803,10 @@ + } + + var ignore = false; +- if (arr = Tween._plugins[n]) { ++ if (arr = createjs.Tween._plugins[n]) { + for (var i=0,l=arr.length;i<l;i++) { + var v2 = arr[i].tween(this, n, v, p0, p1, ratio, !!step&&p0==p1, !step); +- if (v2 == Tween.IGNORE) { ignore = true; } ++ if (v2 == createjs.Tween.IGNORE) { ignore = true; } + else { v = v2; } + } + } +@@ -826,7 +822,7 @@ + * @param {Boolean} includeStart + * @protected + */ +- p._runActions = function(startPos, endPos, includeStart) { ++ createjs.Tween.prototype._runActions = function(startPos, endPos, includeStart) { + var sPos = startPos; + var ePos = endPos; + var i = -1; +@@ -853,14 +849,14 @@ + * @param {Object} o + * @protected + */ +- p._appendQueueProps = function(o) { ++ createjs.Tween.prototype._appendQueueProps = function(o) { + var arr,oldValue,i, l, injectProps; + for (var n in o) { + if (this._initQueueProps[n] === undefined) { + oldValue = this._target[n]; + + // init plugins: +- if (arr = Tween._plugins[n]) { ++ if (arr = createjs.Tween._plugins[n]) { + for (i=0,l=arr.length;i<l;i++) { + oldValue = arr[i].init(this, n, oldValue); + } +@@ -873,7 +869,7 @@ + + for (var n in o) { + oldValue = this._curQueueProps[n]; +- if (arr = Tween._plugins[n]) { ++ if (arr = createjs.Tween._plugins[n]) { + injectProps = injectProps||{}; + for (i=0, l=arr.length;i<l;i++) { + // TODO: remove the check for .step in the next version. It's here for backwards compatibility. +@@ -891,7 +887,7 @@ + * @param {Object} props + * @protected + */ +- p._cloneProps = function(props) { ++ createjs.Tween.prototype._cloneProps = function(props) { + var o = {}; + for (var n in props) { + o[n] = props[n]; +@@ -904,7 +900,7 @@ + * @param {Object} o + * @protected + */ +- p._addStep = function(o) { ++ createjs.Tween.prototype._addStep = function(o) { + if (o.d > 0) { + this._steps.push(o); + o.t = this.duration; +@@ -918,7 +914,7 @@ + * @param {Object} o + * @protected + */ +- p._addAction = function(o) { ++ createjs.Tween.prototype._addAction = function(o) { + o.t = this.duration; + this._actions.push(o); + return this; +@@ -930,12 +926,12 @@ + * @param {Object} o + * @protected + */ +- p._set = function(props, o) { ++ createjs.Tween.prototype._set = function(props, o) { + for (var n in props) { + o[n] = props[n]; + } + }; + +- createjs.Tween = createjs.promote(Tween, "EventDispatcher"); ++ ++ + +-}()); +diff -ur ../target/downloads/TweenJS-0.6.2/src/tweenjs/version.js TweenJS-0.6.2/src/tweenjs/version.js +--- ../target/downloads/TweenJS-0.6.2/src/tweenjs/version.js 2015-12-04 09:20:42.000000000 +0100 ++++ TweenJS-0.6.2/src/tweenjs/version.js 2016-05-31 11:03:07.000000000 +0200 +@@ -1,10 +1,6 @@ + /** + * @module TweenJS + */ +-this.createjs = this.createjs || {}; +- +-(function() { +- "use strict"; + + /** + * Static class holding library specific information such as the version and buildDate of +@@ -29,4 +25,4 @@ + **/ + s.buildDate = /*=date*/""; // injected by build process + +-})(); ++
