http://git-wip-us.apache.org/repos/asf/flex-typedefs/blob/cc561239/createjs/src/main/patch/easeljs2.patch ---------------------------------------------------------------------- diff --git a/createjs/src/main/patch/easeljs2.patch b/createjs/src/main/patch/easeljs2.patch new file mode 100644 index 0000000..fc7d380 --- /dev/null +++ b/createjs/src/main/patch/easeljs2.patch @@ -0,0 +1,8636 @@ +diff -ur ../target/downloads/EaselJS-0.8.0/src/createjs/events/Event.js EaselJS-0.8.0/src/createjs/events/Event.js +--- ../target/downloads/EaselJS-0.8.0/src/createjs/events/Event.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/createjs/events/Event.js 2016-05-31 11:03:07.000000000 +0200 +@@ -39,10 +39,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + // constructor: + /** +@@ -57,7 +53,7 @@ + * @param {Boolean} cancelable Indicates whether the default behaviour of this event can be cancelled. + * @constructor + **/ +- function Event(type, bubbles, cancelable) { ++ createjs.Event = function(type, bubbles, cancelable) { + + + // public properties: +@@ -169,7 +165,7 @@ + */ + this.removed = false; + } +- var p = Event.prototype; ++ + + /** + * <strong>REMOVED</strong>. Removed in favor of using `MySuperClass_constructor`. +@@ -182,7 +178,7 @@ + * @protected + * @deprecated + */ +- // p.initialize = function() {}; // searchable for devs wondering where it is. ++ // createjs.Event.prototype.initialize = function() {}; // searchable for devs wondering where it is. + + // public methods: + /** +@@ -190,7 +186,7 @@ + * Mirrors the DOM event standard. + * @method preventDefault + **/ +- p.preventDefault = function() { ++ createjs.Event.prototype.preventDefault = function() { + this.defaultPrevented = this.cancelable&&true; + }; + +@@ -199,7 +195,7 @@ + * Mirrors the DOM event standard. + * @method stopPropagation + **/ +- p.stopPropagation = function() { ++ createjs.Event.prototype.stopPropagation = function() { + this.propagationStopped = true; + }; + +@@ -209,7 +205,7 @@ + * Mirrors the DOM event standard. + * @method stopImmediatePropagation + **/ +- p.stopImmediatePropagation = function() { ++ createjs.Event.prototype.stopImmediatePropagation = function() { + this.immediatePropagationStopped = this.propagationStopped = true; + }; + +@@ -223,7 +219,7 @@ + * + * @method remove + **/ +- p.remove = function() { ++ createjs.Event.prototype.remove = function() { + this.removed = true; + }; + +@@ -232,7 +228,7 @@ + * @method clone + * @return {Event} a clone of the Event instance. + **/ +- p.clone = function() { ++ createjs.Event.prototype.clone = function() { + return new Event(this.type, this.bubbles, this.cancelable); + }; + +@@ -244,7 +240,7 @@ + * @return {Event} Returns the instance the method is called on (useful for chaining calls.) + * @chainable + */ +- p.set = function(props) { ++ createjs.Event.prototype.set = function(props) { + for (var n in props) { this[n] = props[n]; } + return this; + }; +@@ -254,9 +250,9 @@ + * @method toString + * @return {String} a string representation of the instance. + **/ +- p.toString = function() { ++ createjs.Event.prototype.toString = function() { + return "[Event (type="+this.type+")]"; + }; + +- createjs.Event = Event; +-}()); ++ ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/createjs/events/EventDispatcher.js EaselJS-0.8.0/src/createjs/events/EventDispatcher.js +--- ../target/downloads/EaselJS-0.8.0/src/createjs/events/EventDispatcher.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/createjs/events/EventDispatcher.js 2016-05-31 11:03:07.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + + // constructor: +@@ -60,7 +56,7 @@ + * <h4>Example</h4> + * Add EventDispatcher capabilities to the "MyClass" class. + * +- * EventDispatcher.initialize(MyClass.prototype); ++ * createjs.EventDispatcher.initialize(MyClass.prototype); + * + * Add an event (see {{#crossLink "EventDispatcher/addEventListener"}}{{/crossLink}}). + * +@@ -87,7 +83,7 @@ + * @class EventDispatcher + * @constructor + **/ +- function EventDispatcher() { ++ createjs.EventDispatcher = function() { + + + // private properties: +@@ -105,7 +101,7 @@ + **/ + this._captureListeners = null; + } +- var p = EventDispatcher.prototype; ++ + + /** + * <strong>REMOVED</strong>. Removed in favor of using `MySuperClass_constructor`. +@@ -118,30 +114,30 @@ + * @protected + * @deprecated + */ +- // p.initialize = function() {}; // searchable for devs wondering where it is. ++ // createjs.EventDispatcher.prototype.initialize = function() {}; // searchable for devs wondering where it is. + + + // static public methods: + /** + * Static initializer to mix EventDispatcher methods into a target object or prototype. + * +- * EventDispatcher.initialize(MyClass.prototype); // add to the prototype of the class +- * EventDispatcher.initialize(myObject); // add to a specific instance ++ * createjs.EventDispatcher.initialize(MyClass.prototype); // add to the prototype of the class ++ * createjs.EventDispatcher.initialize(myObject); // add to a specific instance + * + * @method initialize + * @static + * @param {Object} target The target object to inject EventDispatcher methods into. This can be an instance or a + * prototype. + **/ +- EventDispatcher.initialize = function(target) { +- target.addEventListener = p.addEventListener; +- target.on = p.on; +- target.removeEventListener = target.off = p.removeEventListener; +- target.removeAllEventListeners = p.removeAllEventListeners; +- target.hasEventListener = p.hasEventListener; +- target.dispatchEvent = p.dispatchEvent; +- target._dispatchEvent = p._dispatchEvent; +- target.willTrigger = p.willTrigger; ++ createjs.EventDispatcher.initialize = function(target) { ++ target.addEventListener = createjs.EventDispatcher.prototype.addEventListener; ++ target.on = createjs.EventDispatcher.prototype.on; ++ target.removeEventListener = target.off = createjs.EventDispatcher.prototype.removeEventListener; ++ target.removeAllEventListeners = createjs.EventDispatcher.prototype.removeAllEventListeners; ++ target.hasEventListener = createjs.EventDispatcher.prototype.hasEventListener; ++ target.dispatchEvent = createjs.EventDispatcher.prototype.dispatchEvent; ++ target._dispatchEvent = createjs.EventDispatcher.prototype._dispatchEvent; ++ target.willTrigger = createjs.EventDispatcher.prototype.willTrigger; + }; + + +@@ -164,7 +160,7 @@ + * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. + * @return {Function | Object} Returns the listener for chaining or assignment. + **/ +- p.addEventListener = function(type, listener, useCapture) { ++ createjs.EventDispatcher.prototype.addEventListener = function(type, listener, useCapture) { + var listeners; + if (useCapture) { + listeners = this._captureListeners = this._captureListeners||{}; +@@ -209,7 +205,7 @@ + * @param {Boolean} [useCapture=false] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. + * @return {Function} Returns the anonymous function that was created and assigned as the listener. This is needed to remove the listener later using .removeEventListener. + **/ +- p.on = function(type, listener, scope, once, data, useCapture) { ++ createjs.EventDispatcher.prototype.on = function(type, listener, scope, once, data, useCapture) { + if (listener.handleEvent) { + scope = scope||listener; + listener = listener.handleEvent; +@@ -237,7 +233,7 @@ + * @param {Function | Object} listener The listener function or object. + * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. + **/ +- p.removeEventListener = function(type, listener, useCapture) { ++ createjs.EventDispatcher.prototype.removeEventListener = function(type, listener, useCapture) { + var listeners = useCapture ? this._captureListeners : this._listeners; + if (!listeners) { return; } + var arr = listeners[type]; +@@ -260,7 +256,7 @@ + * @param {Function | Object} listener The listener function or object. + * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. + **/ +- p.off = p.removeEventListener; ++ createjs.EventDispatcher.prototype.off = createjs.EventDispatcher.prototype.removeEventListener; + + /** + * Removes all listeners for the specified type, or all listeners of all types. +@@ -276,7 +272,7 @@ + * @method removeAllEventListeners + * @param {String} [type] The string type of the event. If omitted, all listeners for all types will be removed. + **/ +- p.removeAllEventListeners = function(type) { ++ createjs.EventDispatcher.prototype.removeAllEventListeners = function(type) { + if (!type) { this._listeners = this._captureListeners = null; } + else { + if (this._listeners) { delete(this._listeners[type]); } +@@ -302,7 +298,7 @@ + * dispatchEvent will construct an Event instance with the specified type. + * @return {Boolean} Returns the value of eventObj.defaultPrevented. + **/ +- p.dispatchEvent = function(eventObj) { ++ createjs.EventDispatcher.prototype.dispatchEvent = function(eventObj) { + if (typeof eventObj == "string") { + // won't bubble, so skip everything if there's no listeners: + var listeners = this._listeners; +@@ -339,7 +335,7 @@ + * @param {String} type The string type of the event. + * @return {Boolean} Returns true if there is at least one listener for the specified event. + **/ +- p.hasEventListener = function(type) { ++ createjs.EventDispatcher.prototype.hasEventListener = function(type) { + var listeners = this._listeners, captureListeners = this._captureListeners; + return !!((listeners && listeners[type]) || (captureListeners && captureListeners[type])); + }; +@@ -355,7 +351,7 @@ + * @param {String} type The string type of the event. + * @return {Boolean} Returns `true` if there is at least one listener for the specified event. + **/ +- p.willTrigger = function(type) { ++ createjs.EventDispatcher.prototype.willTrigger = function(type) { + var o = this; + while (o) { + if (o.hasEventListener(type)) { return true; } +@@ -368,7 +364,7 @@ + * @method toString + * @return {String} a string representation of the instance. + **/ +- p.toString = function() { ++ createjs.EventDispatcher.prototype.toString = function() { + return "[EventDispatcher]"; + }; + +@@ -380,7 +376,7 @@ + * @param {Object} eventPhase + * @protected + **/ +- p._dispatchEvent = function(eventObj, eventPhase) { ++ createjs.EventDispatcher.prototype._dispatchEvent = function(eventObj, eventPhase) { + var l, listeners = (eventPhase==1) ? this._captureListeners : this._listeners; + if (eventObj && listeners) { + var arr = listeners[eventObj.type]; +@@ -403,5 +399,5 @@ + }; + + +- createjs.EventDispatcher = EventDispatcher; +-}()); ++ ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/createjs/utils/Ticker.js EaselJS-0.8.0/src/createjs/utils/Ticker.js +--- ../target/downloads/EaselJS-0.8.0/src/createjs/utils/Ticker.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/createjs/utils/Ticker.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + + // constructor: +@@ -43,7 +39,7 @@ + * event to be notified when a set time interval has elapsed. + * + * Note that the interval that the tick event is called is a target interval, and may be broadcast at a slower interval +- * when under high CPU load. The Ticker class uses a static interface (ex. `Ticker.framerate = 30;`) and ++ * when under high CPU load. The Ticker class uses a static interface (ex. `createjs.Ticker.framerate = 30;`) and + * can not be instantiated. + * + * <h4>Example</h4> +@@ -60,7 +56,7 @@ + * @uses EventDispatcher + * @static + **/ +- function Ticker() { ++ createjs.Ticker = function() { + throw "Ticker cannot be instantiated."; + } + +@@ -84,7 +80,7 @@ + * @default "synched" + * @readonly + **/ +- Ticker.RAF_SYNCHED = "synched"; ++ createjs.Ticker.RAF_SYNCHED = "synched"; + + /** + * In this mode, Ticker passes through the requestAnimationFrame heartbeat, ignoring the target framerate completely. +@@ -99,7 +95,7 @@ + * @default "raf" + * @readonly + **/ +- Ticker.RAF = "raf"; ++ createjs.Ticker.RAF = "raf"; + + /** + * In this mode, Ticker uses the setTimeout API. This provides predictable, adaptive frame timing, but does not +@@ -110,7 +106,7 @@ + * @default "timer" + * @readonly + **/ +- Ticker.TIMEOUT = "timeout"; ++ createjs.Ticker.TIMEOUT = "timeout"; + + + // static events: +@@ -147,7 +143,7 @@ + * @type {Boolean} + * @default false + **/ +- Ticker.useRAF = false; ++ createjs.Ticker.useRAF = false; + + /** + * Specifies the timing api (setTimeout or requestAnimationFrame) and mode to use. See +@@ -156,9 +152,9 @@ + * @property timingMode + * @static + * @type {String} +- * @default Ticker.TIMEOUT ++ * @default createjs.Ticker.TIMEOUT + **/ +- Ticker.timingMode = null; ++ createjs.Ticker.timingMode = null; + + /** + * Specifies a maximum value for the delta property in the tick event object. This is useful when building time +@@ -175,7 +171,7 @@ + * @type {number} + * @default 0 + */ +- Ticker.maxDelta = 0; ++ createjs.Ticker.maxDelta = 0; + + /** + * When the ticker is paused, all listeners will still receive a tick event, but the <code>paused</code> property of the event will be false. +@@ -197,21 +193,21 @@ + * @type {Boolean} + * @default false + **/ +- Ticker.paused = false; ++ createjs.Ticker.paused = false; + + + // mix-ins: + // EventDispatcher methods: +- Ticker.removeEventListener = null; +- Ticker.removeAllEventListeners = null; +- Ticker.dispatchEvent = null; +- Ticker.hasEventListener = null; +- Ticker._listeners = null; ++ createjs.Ticker.removeEventListener = null; ++ createjs.Ticker.removeAllEventListeners = null; ++ createjs.Ticker.dispatchEvent = null; ++ createjs.Ticker.hasEventListener = null; ++ createjs.Ticker._listeners = null; + createjs.EventDispatcher.initialize(Ticker); // inject EventDispatcher methods. +- Ticker._addEventListener = Ticker.addEventListener; +- Ticker.addEventListener = function() { +- !Ticker._inited&&Ticker.init(); +- return Ticker._addEventListener.apply(Ticker, arguments); ++ createjs.Ticker._addEventListener = createjs.Ticker.addEventListener; ++ createjs.Ticker.addEventListener = function() { ++ !createjs.Ticker._inited&&createjs.Ticker.init(); ++ return createjs.Ticker._addEventListener.apply(Ticker, arguments); + }; + + +@@ -222,7 +218,7 @@ + * @type {Boolean} + * @protected + **/ +- Ticker._inited = false; ++ createjs.Ticker._inited = false; + + /** + * @property _startTime +@@ -230,7 +226,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._startTime = 0; ++ createjs.Ticker._startTime = 0; + + /** + * @property _pausedTime +@@ -238,7 +234,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._pausedTime=0; ++ createjs.Ticker._pausedTime=0; + + /** + * The number of ticks that have passed +@@ -247,7 +243,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._ticks = 0; ++ createjs.Ticker._ticks = 0; + + /** + * The number of ticks that have passed while Ticker has been paused +@@ -256,7 +252,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._pausedTicks = 0; ++ createjs.Ticker._pausedTicks = 0; + + /** + * @property _interval +@@ -264,7 +260,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._interval = 50; ++ createjs.Ticker._interval = 50; + + /** + * @property _lastTime +@@ -272,7 +268,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._lastTime = 0; ++ createjs.Ticker._lastTime = 0; + + /** + * @property _times +@@ -280,7 +276,7 @@ + * @type {Array} + * @protected + **/ +- Ticker._times = null; ++ createjs.Ticker._times = null; + + /** + * @property _tickTimes +@@ -288,7 +284,7 @@ + * @type {Array} + * @protected + **/ +- Ticker._tickTimes = null; ++ createjs.Ticker._tickTimes = null; + + /** + * Stores the timeout or requestAnimationFrame id. +@@ -297,7 +293,7 @@ + * @type {Number} + * @protected + **/ +- Ticker._timerId = null; ++ createjs.Ticker._timerId = null; + + /** + * True if currently using requestAnimationFrame, false if using setTimeout. This may be different than timingMode +@@ -307,7 +303,7 @@ + * @type {Boolean} + * @protected + **/ +- Ticker._raf = true; ++ createjs.Ticker._raf = true; + + + // static getter / setters: +@@ -318,10 +314,10 @@ + * @param {Number} interval + * @deprecated + **/ +- Ticker.setInterval = function(interval) { +- Ticker._interval = interval; +- if (!Ticker._inited) { return; } +- Ticker._setupTick(); ++ createjs.Ticker.setInterval = function(interval) { ++ createjs.Ticker._interval = interval; ++ if (!createjs.Ticker._inited) { return; } ++ createjs.Ticker._setupTick(); + }; + + /** +@@ -331,8 +327,8 @@ + * @return {Number} + * @deprecated + **/ +- Ticker.getInterval = function() { +- return Ticker._interval; ++ createjs.Ticker.getInterval = function() { ++ return createjs.Ticker._interval; + }; + + /** +@@ -342,8 +338,8 @@ + * @param {Number} value + * @deprecated + **/ +- Ticker.setFPS = function(value) { +- Ticker.setInterval(1000/value); ++ createjs.Ticker.setFPS = function(value) { ++ createjs.Ticker.setInterval(1000/value); + }; + + /** +@@ -353,66 +349,42 @@ + * @return {Number} + * @deprecated + **/ +- Ticker.getFPS = function() { +- return 1000/Ticker._interval; ++ createjs.Ticker.getFPS = function() { ++ return 1000/createjs.Ticker._interval; + }; + +- /** +- * Indicates the target time (in milliseconds) between ticks. Default is 50 (20 FPS). +- * Note that actual time between ticks may be more than specified depending on CPU load. +- * This property is ignored if the ticker is using the `RAF` timing mode. +- * @property interval +- * @static +- * @type {Number} +- **/ +- +- /** +- * Indicates the target frame rate in frames per second (FPS). Effectively just a shortcut to `interval`, where +- * `framerate == 1000/interval`. +- * @property framerate +- * @static +- * @type {Number} +- **/ +- try { +- Object.defineProperties(Ticker, { +- interval: { get: Ticker.getInterval, set: Ticker.setInterval }, +- framerate: { get: Ticker.getFPS, set: Ticker.setFPS } +- }); +- } catch (e) { console.log(e); } +- +- + // public static methods: + /** + * Starts the tick. This is called automatically when the first listener is added. + * @method init + * @static + **/ +- Ticker.init = function() { +- if (Ticker._inited) { return; } +- Ticker._inited = true; +- Ticker._times = []; +- Ticker._tickTimes = []; +- Ticker._startTime = Ticker._getTime(); +- Ticker._times.push(Ticker._lastTime = 0); +- Ticker.interval = Ticker._interval; ++ createjs.Ticker.init = function() { ++ if (createjs.Ticker._inited) { return; } ++ createjs.Ticker._inited = true; ++ createjs.Ticker._times = []; ++ createjs.Ticker._tickTimes = []; ++ createjs.Ticker._startTime = createjs.Ticker._getTime(); ++ createjs.Ticker._times.push(createjs.Ticker._lastTime = 0); ++ createjs.Ticker.interval = createjs.Ticker._interval; + }; + + /** +- * Stops the Ticker and removes all listeners. Use init() to restart the Ticker. ++ * Stops the Ticker and removes all listeners. Use init() to restart the createjs.Ticker. + * @method reset + * @static + **/ +- Ticker.reset = function() { +- if (Ticker._raf) { ++ createjs.Ticker.reset = function() { ++ if (createjs.Ticker._raf) { + var f = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame; +- f&&f(Ticker._timerId); ++ f&&f(createjs.Ticker._timerId); + } else { +- clearTimeout(Ticker._timerId); ++ clearTimeout(createjs.Ticker._timerId); + } +- Ticker.removeAllEventListeners("tick"); +- Ticker._timerId = Ticker._times = Ticker._tickTimes = null; +- Ticker._startTime = Ticker._lastTime = Ticker._ticks = 0; +- Ticker._inited = false; ++ createjs.Ticker.removeAllEventListeners("tick"); ++ createjs.Ticker._timerId = createjs.Ticker._times = createjs.Ticker._tickTimes = null; ++ createjs.Ticker._startTime = createjs.Ticker._lastTime = createjs.Ticker._ticks = 0; ++ createjs.Ticker._inited = false; + }; + + /** +@@ -432,12 +404,12 @@ + * Defaults to the number of ticks per second. To get only the last tick's time, pass in 1. + * @return {Number} The average time spent in a tick in milliseconds. + **/ +- Ticker.getMeasuredTickTime = function(ticks) { +- var ttl=0, times=Ticker._tickTimes; ++ createjs.Ticker.getMeasuredTickTime = function(ticks) { ++ var ttl=0, times=createjs.Ticker._tickTimes; + if (!times || times.length < 1) { return -1; } + + // by default, calculate average for the past ~1 second: +- ticks = Math.min(times.length, ticks||(Ticker.getFPS()|0)); ++ ticks = Math.min(times.length, ticks||(createjs.Ticker.getFPS()|0)); + for (var i=0; i<ticks; i++) { ttl += times[i]; } + return ttl/ticks; + }; +@@ -451,12 +423,12 @@ + * @return {Number} The actual frames / ticks per second. Depending on performance, this may differ + * from the target frames per second. + **/ +- Ticker.getMeasuredFPS = function(ticks) { +- var times = Ticker._times; ++ createjs.Ticker.getMeasuredFPS = function(ticks) { ++ var times = createjs.Ticker._times; + if (!times || times.length < 2) { return -1; } + + // by default, calculate fps for the past ~1 second: +- ticks = Math.min(times.length-1, ticks||(Ticker.getFPS()|0)); ++ ticks = Math.min(times.length-1, ticks||(createjs.Ticker.getFPS()|0)); + return 1000/((times[0]-times[ticks])/ticks); + }; + +@@ -467,9 +439,9 @@ + * @param {Boolean} value + * @deprecated + **/ +- Ticker.setPaused = function(value) { ++ createjs.Ticker.setPaused = function(value) { + // TODO: deprecated. +- Ticker.paused = value; ++ createjs.Ticker.paused = value; + }; + + /** +@@ -479,9 +451,9 @@ + * @return {Boolean} + * @deprecated + **/ +- Ticker.getPaused = function() { ++ createjs.Ticker.getPaused = function() { + // TODO: deprecated. +- return Ticker.paused; ++ return createjs.Ticker.paused; + }; + + /** +@@ -494,8 +466,8 @@ + * If false, the value returned will be total time elapsed since the first tick event listener was added. + * @return {Number} Number of milliseconds that have elapsed since Ticker was initialized or -1. + **/ +- Ticker.getTime = function(runTime) { +- return Ticker._startTime ? Ticker._getTime() - (runTime ? Ticker._pausedTime : 0) : -1; ++ createjs.Ticker.getTime = function(runTime) { ++ return createjs.Ticker._startTime ? createjs.Ticker._getTime() - (runTime ? createjs.Ticker._pausedTime : 0) : -1; + }; + + /** +@@ -505,12 +477,12 @@ + * @param runTime {Boolean} [runTime=false] If true, the runTime property will be returned instead of time. + * @returns {number} The time or runTime property from the most recent tick event or -1. + */ +- Ticker.getEventTime = function(runTime) { +- return Ticker._startTime ? (Ticker._lastTime || Ticker._startTime) - (runTime ? Ticker._pausedTime : 0) : -1; ++ createjs.Ticker.getEventTime = function(runTime) { ++ return createjs.Ticker._startTime ? (createjs.Ticker._lastTime || createjs.Ticker._startTime) - (runTime ? createjs.Ticker._pausedTime : 0) : -1; + }; + + /** +- * Returns the number of ticks that have been broadcast by Ticker. ++ * Returns the number of ticks that have been broadcast by createjs.Ticker. + * @method getTicks + * @static + * @param {Boolean} pauseable Indicates whether to include ticks that would have been broadcast +@@ -519,8 +491,8 @@ + * value. The default value is false. + * @return {Number} of ticks that have been broadcast. + **/ +- Ticker.getTicks = function(pauseable) { +- return Ticker._ticks - (pauseable ? Ticker._pausedTicks : 0); ++ createjs.Ticker.getTicks = function(pauseable) { ++ return createjs.Ticker._ticks - (pauseable ? createjs.Ticker._pausedTicks : 0); + }; + + +@@ -530,13 +502,13 @@ + * @static + * @protected + **/ +- Ticker._handleSynch = function() { +- Ticker._timerId = null; +- Ticker._setupTick(); ++ createjs.Ticker._handleSynch = function() { ++ createjs.Ticker._timerId = null; ++ createjs.Ticker._setupTick(); + + // run if enough time has elapsed, with a little bit of flexibility to be early: +- if (Ticker._getTime() - Ticker._lastTime >= (Ticker._interval-1)*0.97) { +- Ticker._tick(); ++ if (createjs.Ticker._getTime() - createjs.Ticker._lastTime >= (createjs.Ticker._interval-1)*0.97) { ++ createjs.Ticker._tick(); + } + }; + +@@ -545,10 +517,10 @@ + * @static + * @protected + **/ +- Ticker._handleRAF = function() { +- Ticker._timerId = null; +- Ticker._setupTick(); +- Ticker._tick(); ++ createjs.Ticker._handleRAF = function() { ++ createjs.Ticker._timerId = null; ++ createjs.Ticker._setupTick(); ++ createjs.Ticker._tick(); + }; + + /** +@@ -556,10 +528,10 @@ + * @static + * @protected + **/ +- Ticker._handleTimeout = function() { +- Ticker._timerId = null; +- Ticker._setupTick(); +- Ticker._tick(); ++ createjs.Ticker._handleTimeout = function() { ++ createjs.Ticker._timerId = null; ++ createjs.Ticker._setupTick(); ++ createjs.Ticker._tick(); + }; + + /** +@@ -567,20 +539,20 @@ + * @static + * @protected + **/ +- Ticker._setupTick = function() { +- if (Ticker._timerId != null) { return; } // avoid duplicates ++ createjs.Ticker._setupTick = function() { ++ if (createjs.Ticker._timerId != null) { return; } // avoid duplicates + +- var mode = Ticker.timingMode||(Ticker.useRAF&&Ticker.RAF_SYNCHED); +- if (mode == Ticker.RAF_SYNCHED || mode == Ticker.RAF) { ++ var mode = createjs.Ticker.timingMode||(createjs.Ticker.useRAF&&createjs.Ticker.RAF_SYNCHED); ++ if (mode == createjs.Ticker.RAF_SYNCHED || mode == createjs.Ticker.RAF) { + var f = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame; + if (f) { +- Ticker._timerId = f(mode == Ticker.RAF ? Ticker._handleRAF : Ticker._handleSynch); +- Ticker._raf = true; ++ createjs.Ticker._timerId = f(mode == createjs.Ticker.RAF ? createjs.Ticker._handleRAF : createjs.Ticker._handleSynch); ++ createjs.Ticker._raf = true; + return; + } + } +- Ticker._raf = false; +- Ticker._timerId = setTimeout(Ticker._handleTimeout, Ticker._interval); ++ createjs.Ticker._raf = false; ++ createjs.Ticker._timerId = setTimeout(createjs.Ticker._handleTimeout, createjs.Ticker._interval); + }; + + /** +@@ -588,33 +560,33 @@ + * @static + * @protected + **/ +- Ticker._tick = function() { +- var paused = Ticker.paused; +- var time = Ticker._getTime(); +- var elapsedTime = time-Ticker._lastTime; +- Ticker._lastTime = time; +- Ticker._ticks++; ++ createjs.Ticker._tick = function() { ++ var paused = createjs.Ticker.paused; ++ var time = createjs.Ticker._getTime(); ++ var elapsedTime = time-createjs.Ticker._lastTime; ++ createjs.Ticker._lastTime = time; ++ createjs.Ticker._ticks++; + + if (paused) { +- Ticker._pausedTicks++; +- Ticker._pausedTime += elapsedTime; ++ createjs.Ticker._pausedTicks++; ++ createjs.Ticker._pausedTime += elapsedTime; + } + +- if (Ticker.hasEventListener("tick")) { ++ if (createjs.Ticker.hasEventListener("tick")) { + var event = new createjs.Event("tick"); +- var maxDelta = Ticker.maxDelta; ++ var maxDelta = createjs.Ticker.maxDelta; + event.delta = (maxDelta && elapsedTime > maxDelta) ? maxDelta : elapsedTime; + event.paused = paused; + event.time = time; +- event.runTime = time-Ticker._pausedTime; +- Ticker.dispatchEvent(event); ++ event.runTime = time-createjs.Ticker._pausedTime; ++ createjs.Ticker.dispatchEvent(event); + } + +- Ticker._tickTimes.unshift(Ticker._getTime()-time); +- while (Ticker._tickTimes.length > 100) { Ticker._tickTimes.pop(); } ++ createjs.Ticker._tickTimes.unshift(createjs.Ticker._getTime()-time); ++ while (createjs.Ticker._tickTimes.length > 100) { createjs.Ticker._tickTimes.pop(); } + +- Ticker._times.unshift(time); +- while (Ticker._times.length > 100) { Ticker._times.pop(); } ++ createjs.Ticker._times.unshift(time); ++ while (createjs.Ticker._times.length > 100) { createjs.Ticker._times.pop(); } + }; + + /** +@@ -623,10 +595,10 @@ + * @protected + **/ + var now = window.performance && (performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow); +- Ticker._getTime = function() { +- return ((now&&now.call(performance))||(new Date().getTime())) - Ticker._startTime; ++ createjs.Ticker._getTime = function() { ++ return ((now&&now.call(performance))||(new Date().getTime())) - createjs.Ticker._startTime; + }; + + +- createjs.Ticker = Ticker; +-}()); ++ ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/createjs/utils/extend.js EaselJS-0.8.0/src/createjs/utils/extend.js +--- ../target/downloads/EaselJS-0.8.0/src/createjs/utils/extend.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/createjs/utils/extend.js 2016-05-31 11:03:07.000000000 +0200 +@@ -31,7 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; ++ + + /** + * @class Utility Methods +@@ -52,11 +52,10 @@ + * + * @method extend + * @param {Function} subclass The subclass. +- * @param {Function} superclass The superclass to extend. ++ * @param {Function} superclass The superclass to createjs.extend. + * @return {Function} Returns the subclass's new prototype. + */ + createjs.extend = function(subclass, superclass) { +- "use strict"; + + function o() { this.constructor = subclass; } + o.prototype = superclass.prototype; +diff -ur ../target/downloads/EaselJS-0.8.0/src/createjs/utils/indexOf.js EaselJS-0.8.0/src/createjs/utils/indexOf.js +--- ../target/downloads/EaselJS-0.8.0/src/createjs/utils/indexOf.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/createjs/utils/indexOf.js 2016-05-31 11:03:07.000000000 +0200 +@@ -31,7 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; ++ + + /** + * @class Utility Methods +@@ -49,7 +49,6 @@ + * @return {Number} The first index of searchElement in array. + */ + createjs.indexOf = function (array, searchElement){ +- "use strict"; + + for (var i = 0,l=array.length; i < l; i++) { + if (searchElement === array[i]) { +diff -ur ../target/downloads/EaselJS-0.8.0/src/createjs/utils/promote.js EaselJS-0.8.0/src/createjs/utils/promote.js +--- ../target/downloads/EaselJS-0.8.0/src/createjs/utils/promote.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/createjs/utils/promote.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,7 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; ++ + + /** + * @class Utility Methods +@@ -75,7 +75,6 @@ + * @return {Function} Returns the subclass. + */ + createjs.promote = function(subclass, prefix) { +- "use strict"; + + var subP = subclass.prototype, supP = (Object.getPrototypeOf&&Object.getPrototypeOf(subP))||subP.__proto__; + if (supP) { +diff -ur ../target/downloads/EaselJS-0.8.0/src/easeljs/display/Bitmap.js EaselJS-0.8.0/src/easeljs/display/Bitmap.js +--- ../target/downloads/EaselJS-0.8.0/src/easeljs/display/Bitmap.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/easeljs/display/Bitmap.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,11 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- +- /** ++/** + * A Bitmap represents an Image, Canvas, or Video in the display list. A Bitmap can be instantiated using an existing + * HTML element, or a string. + * +@@ -57,13 +53,13 @@ + * </ol> + * + * @class Bitmap +- * @extends DisplayObject ++ * @extends createjs.DisplayObject + * @constructor + * @param {Image | HTMLCanvasElement | HTMLVideoElement | String} imageOrUri The source object or URI to an image to + * display. This can be either an Image, Canvas, or Video object, or a string URI to an image file to load and use. + * If it is a URI, a new Image object will be constructed and assigned to the .image property. + **/ +- function Bitmap(imageOrUri) { ++ createjs.Bitmap = function(imageOrUri) { + this.DisplayObject_constructor(); + + +@@ -90,7 +86,7 @@ + */ + this.sourceRect = null; + } +- var p = createjs.extend(Bitmap, createjs.DisplayObject); ++ + + + // public methods: +@@ -100,7 +96,7 @@ + * @method initialize + * @deprecated in favour of `createjs.promote()` + **/ +- p.initialize = Bitmap; // TODO: deprecated. ++ createjs.Bitmap.prototype.initialize = Bitmap; // TODO: deprecated. + + /** + * Returns true or false indicating whether the display object would be visible if drawn to a canvas. +@@ -110,7 +106,7 @@ + * @method isVisible + * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas + **/ +- p.isVisible = function() { ++ createjs.Bitmap.prototype.isVisible = function() { + var hasContent = this.cacheCanvas || (this.image && (this.image.complete || this.image.getContext || this.image.readyState >= 2)); + return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); + }; +@@ -127,7 +123,7 @@ + * into itself). + * @return {Boolean} + **/ +- p.draw = function(ctx, ignoreCache) { ++ createjs.Bitmap.prototype.draw = function(ctx, ignoreCache) { + if (this.DisplayObject_draw(ctx, ignoreCache) || !this.image) { return true; } + var img = this.image, rect = this.sourceRect; + if (rect) { +@@ -145,7 +141,7 @@ + }; + + //Note, the doc sections below document using the specified APIs (from DisplayObject) from +- //Bitmap. This is why they have no method implementations. ++ //createjs.Bitmap. This is why they have no method implementations. + + /** + * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. +@@ -180,7 +176,7 @@ + /** + * Docced in superclass. + */ +- p.getBounds = function() { ++ createjs.Bitmap.prototype.getBounds = function() { + var rect = this.DisplayObject_getBounds(); + if (rect) { return rect; } + var o = this.sourceRect || this.image; +@@ -193,7 +189,7 @@ + * @method clone + * @return {Bitmap} a clone of the Bitmap instance. + **/ +- p.clone = function() { ++ createjs.Bitmap.prototype.clone = function() { + var o = new Bitmap(this.image); + if (this.sourceRect) { o.sourceRect = this.sourceRect.clone(); } + this._cloneProps(o); +@@ -205,10 +201,10 @@ + * @method toString + * @return {String} a string representation of the instance. + **/ +- p.toString = function() { ++ createjs.Bitmap.prototype.toString = function() { + return "[Bitmap (name="+ this.name +")]"; + }; + + +- createjs.Bitmap = createjs.promote(Bitmap, "DisplayObject"); +-}()); ++ ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/easeljs/display/BitmapText.js EaselJS-0.8.0/src/easeljs/display/BitmapText.js +--- ../target/downloads/EaselJS-0.8.0/src/easeljs/display/BitmapText.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/easeljs/display/BitmapText.js 2016-05-31 11:03:07.000000000 +0200 +@@ -26,11 +26,6 @@ + * OTHER DEALINGS IN THE SOFTWARE. + */ + +-this.createjs = this.createjs || {}; +- +-(function () { +- "use strict"; +- + + // constructor: + /** +@@ -42,12 +37,12 @@ + * <strong>Important:</strong> BitmapText extends Container, but is not designed to be used as one. + * As such, methods like addChild and removeChild are disabled. + * @class BitmapText +- * @extends DisplayObject ++ * @extends createjs.DisplayObject + * @param {String} [text=""] The text to display. +- * @param {SpriteSheet} [spriteSheet=null] The spritesheet that defines the character glyphs. ++ * @param {createjs.SpriteSheet} [spriteSheet=null] The spritesheet that defines the character glyphs. + * @constructor + **/ +- function BitmapText(text, spriteSheet) { ++ createjs.BitmapText = function(text, spriteSheet) { + this.Container_constructor(); + + +@@ -122,7 +117,7 @@ + **/ + this._oldProps = {text:0,spriteSheet:0,lineHeight:0,letterSpacing:0,spaceWidth:0}; + } +- var p = createjs.extend(BitmapText, createjs.Container); ++ + + /** + * <strong>REMOVED</strong>. Removed in favor of using `MySuperClass_constructor`. +@@ -135,7 +130,7 @@ + * @protected + * @deprecated + */ +- // p.initialize = function() {}; // searchable for devs wondering where it is. ++ // createjs.BitmapText.prototype.initialize = function() {}; // searchable for devs wondering where it is. + + // static properties: + /** +@@ -147,7 +142,7 @@ + * @static + * @default 100 + **/ +- BitmapText.maxPoolSize = 100; ++ createjs.BitmapText.maxPoolSize = 100; + + /** + * Sprite object pool. +@@ -155,14 +150,14 @@ + * @static + * @private + */ +- BitmapText._spritePool = []; ++ createjs.BitmapText._spritePool = []; + + + // public methods: + /** + * Docced in superclass. + **/ +- p.draw = function(ctx, ignoreCache) { ++ createjs.BitmapText.prototype.draw = function(ctx, ignoreCache) { + if (this.DisplayObject_draw(ctx, ignoreCache)) { return; } + this._updateText(); + this.Container_draw(ctx, ignoreCache); +@@ -171,7 +166,7 @@ + /** + * Docced in superclass. + **/ +- p.getBounds = function() { ++ createjs.BitmapText.prototype.getBounds = function() { + this._updateText(); + return this.Container_getBounds(); + }; +@@ -183,36 +178,36 @@ + * @method isVisible + * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas + **/ +- p.isVisible = function() { ++ createjs.BitmapText.prototype.isVisible = function() { + var hasContent = this.cacheCanvas || (this.spriteSheet && this.spriteSheet.complete && this.text); + return !!(this.visible && this.alpha > 0 && this.scaleX !== 0 && this.scaleY !== 0 && hasContent); + }; + +- p.clone = function() { ++ createjs.BitmapText.prototype.clone = function() { + return this._cloneProps(new BitmapText(this.text, this.spriteSheet)); + }; + + /** +- * <strong>Disabled in BitmapText.</strong> ++ * <strong>Disabled in createjs.BitmapText.</strong> + * @method addChild + **/ + /** +- * <strong>Disabled in BitmapText.</strong> ++ * <strong>Disabled in createjs.BitmapText.</strong> + * @method addChildAt + **/ + /** +- * <strong>Disabled in BitmapText.</strong> ++ * <strong>Disabled in createjs.BitmapText.</strong> + * @method removeChild + **/ + /** +- * <strong>Disabled in BitmapText.</strong> ++ * <strong>Disabled in createjs.BitmapText.</strong> + * @method removeChildAt + **/ + /** +- * <strong>Disabled in BitmapText.</strong> ++ * <strong>Disabled in createjs.BitmapText.</strong> + * @method removeAllChildren + **/ +- p.addChild = p.addChildAt = p.removeChild = p.removeChildAt = p.removeAllChildren = function() {}; ++ createjs.BitmapText.prototype.addChild = createjs.BitmapText.prototype.addChildAt = createjs.BitmapText.prototype.removeChild = createjs.BitmapText.prototype.removeChildAt = createjs.BitmapText.prototype.removeAllChildren = function() {}; + + + // private methods: +@@ -222,7 +217,7 @@ + * @return {BitmapText} o + * @protected + **/ +- p._cloneProps = function(o) { ++ createjs.BitmapText.prototype._cloneProps = function(o) { + this.DisplayObject__cloneProps(o); + o.lineHeight = this.lineHeight; + o.letterSpacing = this.letterSpacing; +@@ -233,11 +228,11 @@ + /** + * @method _getFrameIndex + * @param {String} character +- * @param {SpriteSheet} spriteSheet ++ * @param {createjs.SpriteSheet} spriteSheet + * @return {Number} + * @protected + **/ +- p._getFrameIndex = function(character, spriteSheet) { ++ createjs.BitmapText.prototype._getFrameIndex = function(character, spriteSheet) { + var c, o = spriteSheet.getAnimation(character); + if (!o) { + (character != (c = character.toUpperCase())) || (character != (c = character.toLowerCase())) || (c=null); +@@ -249,32 +244,32 @@ + /** + * @method _getFrame + * @param {String} character +- * @param {SpriteSheet} spriteSheet ++ * @param {createjs.SpriteSheet} spriteSheet + * @return {Object} + * @protected + **/ +- p._getFrame = function(character, spriteSheet) { ++ createjs.BitmapText.prototype._getFrame = function(character, spriteSheet) { + var index = this._getFrameIndex(character, spriteSheet); + return index == null ? index : spriteSheet.getFrame(index); + }; + + /** + * @method _getLineHeight +- * @param {SpriteSheet} ss ++ * @param {createjs.SpriteSheet} ss + * @return {Number} + * @protected + **/ +- p._getLineHeight = function(ss) { ++ createjs.BitmapText.prototype._getLineHeight = function(ss) { + var frame = this._getFrame("1",ss) || this._getFrame("T",ss) || this._getFrame("L",ss) || ss.getFrame(0); + return frame ? frame.rect.height : 1; + }; + /** + * @method _getSpaceWidth +- * @param {SpriteSheet} ss ++ * @param {createjs.SpriteSheet} ss + * @return {Number} + * @protected + **/ +- p._getSpaceWidth = function(ss) { ++ createjs.BitmapText.prototype._getSpaceWidth = function(ss) { + var frame = this._getFrame("1",ss) || this._getFrame("l",ss) || this._getFrame("e",ss) || this._getFrame("a",ss) || ss.getFrame(0); + return frame ? frame.rect.width : 1; + }; +@@ -283,9 +278,9 @@ + * @method _drawText + * @protected + **/ +- p._updateText = function() { ++ createjs.BitmapText.prototype._updateText = function() { + var x=0, y=0, o=this._oldProps, change=false, spaceW=this.spaceWidth, lineH=this.lineHeight, ss=this.spriteSheet; +- var pool=BitmapText._spritePool, kids=this.children, childIndex=0, numKids=kids.length, sprite; ++ var pool=createjs.BitmapText._spritePool, kids=this.children, childIndex=0, numKids=kids.length, sprite; + + for (var n in o) { + if (o[n] != this[n]) { +@@ -335,9 +330,8 @@ + sprite.parent = null; + numKids--; + } +- if (pool.length > BitmapText.maxPoolSize) { pool.length = BitmapText.maxPoolSize; } ++ if (pool.length > createjs.BitmapText.maxPoolSize) { pool.length = createjs.BitmapText.maxPoolSize; } + }; + + +- createjs.BitmapText = createjs.promote(BitmapText, "Container"); +-}()); +\ No newline at end of file ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/easeljs/display/Container.js EaselJS-0.8.0/src/easeljs/display/Container.js +--- ../target/downloads/EaselJS-0.8.0/src/easeljs/display/Container.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/easeljs/display/Container.js 2016-05-31 11:03:08.000000000 +0200 +@@ -27,10 +27,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + + // constructor: +@@ -39,7 +35,7 @@ + * group arm, leg, torso and head {{#crossLink "Bitmap"}}{{/crossLink}} instances together into a Person Container, and + * transform them as a group, while still being able to move the individual parts relative to each other. Children of + * containers have their <code>transform</code> and <code>alpha</code> properties concatenated with their parent +- * Container. ++ * createjs.Container. + * + * For example, a {{#crossLink "Shape"}}{{/crossLink}} with x=100 and alpha=0.5, placed in a Container with <code>x=50</code> + * and <code>alpha=0.7</code> will be rendered to the canvas at <code>x=150</code> and <code>alpha=0.35</code>. +@@ -52,10 +48,10 @@ + * container.x = 100; + * + * @class Container +- * @extends DisplayObject ++ * @extends createjs.DisplayObject + * @constructor + **/ +- function Container() { ++ createjs.Container = function() { + this.DisplayObject_constructor(); + + // public properties: +@@ -81,7 +77,7 @@ + this.mouseChildren = true; + + /** +- * If false, the tick will not be propagated to children of this Container. This can provide some performance benefits. ++ * If false, the tick will not be propagated to children of this createjs.Container. This can provide some performance benefits. + * In addition to preventing the "tick" event from being dispatched, it will also prevent tick related updates + * on some display objects (ex. Sprite & MovieClip frame advancing, DOMElement visibility handling). + * @property tickChildren +@@ -90,7 +86,7 @@ + **/ + this.tickChildren = true; + } +- var p = createjs.extend(Container, createjs.DisplayObject); ++ + + + // getter / setters: +@@ -100,7 +96,7 @@ + * @return {Number} + * @deprecated + **/ +- p.getNumChildren = function() { ++ createjs.Container.prototype.getNumChildren = function() { + return this.children.length; + }; + +@@ -110,11 +106,7 @@ + * @type {Number} + * @readonly + **/ +- try { +- Object.defineProperties(p, { +- numChildren: { get: p.getNumChildren } +- }); +- } catch (e) {} ++createjs.Container.prototype.numChildren; + + + // public methods: +@@ -124,7 +116,7 @@ + * @method initialize + * @deprecated in favour of `createjs.promote()` + **/ +- p.initialize = Container; // TODO: deprecated. ++ createjs.Container.prototype.initialize = Container; // TODO: deprecated. + + /** + * Returns true or false indicating whether the display object would be visible if drawn to a canvas. +@@ -134,7 +126,7 @@ + * @method isVisible + * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas + **/ +- p.isVisible = function() { ++ createjs.Container.prototype.isVisible = function() { + var hasContent = this.cacheCanvas || this.children.length; + return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); + }; +@@ -150,7 +142,7 @@ + * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back + * into itself). + **/ +- p.draw = function(ctx, ignoreCache) { ++ createjs.Container.prototype.draw = function(ctx, ignoreCache) { + if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } + + // this ensures we don't have issues with display list changes that occur during a draw: +@@ -180,10 +172,10 @@ + * container.addChild(bitmapInstance, shapeInstance, textInstance); + * + * @method addChild +- * @param {DisplayObject} child The display object to add. +- * @return {DisplayObject} The child that was added, or the last child if multiple children were added. ++ * @param {createjs.DisplayObject} child The display object to add. ++ * @return {createjs.DisplayObject} The child that was added, or the last child if multiple children were added. + **/ +- p.addChild = function(child) { ++ createjs.Container.prototype.addChild = function(child) { + if (child == null) { return child; } + var l = arguments.length; + if (l > 1) { +@@ -199,7 +191,7 @@ + + /** + * Adds a child to the display list at the specified index, bumping children at equal or greater indexes up one, and +- * setting its parent to this Container. ++ * setting its parent to this createjs.Container. + * + * <h4>Example</h4> + * +@@ -217,11 +209,11 @@ + * This would also bump otherShape's index up by one. Fails silently if the index is out of range. + * + * @method addChildAt +- * @param {DisplayObject} child The display object to add. ++ * @param {createjs.DisplayObject} child The display object to add. + * @param {Number} index The index to add the child at. +- * @return {DisplayObject} Returns the last child that was added, or the last child if multiple children were added. ++ * @return {createjs.DisplayObject} Returns the last child that was added, or the last child if multiple children were added. + **/ +- p.addChildAt = function(child, index) { ++ createjs.Container.prototype.addChildAt = function(child, index) { + var l = arguments.length; + var indx = arguments[l-1]; // can't use the same name as the index param or it replaces arguments[1] + if (indx < 0 || indx > this.children.length) { return arguments[l-2]; } +@@ -250,10 +242,10 @@ + * + * Returns true if the child (or children) was removed, or false if it was not in the display list. + * @method removeChild +- * @param {DisplayObject} child The child to remove. ++ * @param {createjs.DisplayObject} child The child to remove. + * @return {Boolean} true if the child (or children) was removed, or false if it was not in the display list. + **/ +- p.removeChild = function(child) { ++ createjs.Container.prototype.removeChild = function(child) { + var l = arguments.length; + if (l > 1) { + var good = true; +@@ -279,7 +271,7 @@ + * @param {Number} index The index of the child to remove. + * @return {Boolean} true if the child (or children) was removed, or false if any index was out of range. + **/ +- p.removeChildAt = function(index) { ++ createjs.Container.prototype.removeChildAt = function(index) { + var l = arguments.length; + if (l > 1) { + var a = []; +@@ -306,7 +298,7 @@ + * + * @method removeAllChildren + **/ +- p.removeAllChildren = function() { ++ createjs.Container.prototype.removeAllChildren = function() { + var kids = this.children; + while (kids.length) { this.removeChildAt(0); } + }; +@@ -320,9 +312,9 @@ + * + * @method getChildAt + * @param {Number} index The index of the child to return. +- * @return {DisplayObject} The child at the specified index. Returns null if there is no child at the index. ++ * @return {createjs.DisplayObject} The child at the specified index. Returns null if there is no child at the index. + **/ +- p.getChildAt = function(index) { ++ createjs.Container.prototype.getChildAt = function(index) { + return this.children[index]; + }; + +@@ -330,9 +322,9 @@ + * Returns the child with the specified name. + * @method getChildByName + * @param {String} name The name of the child to return. +- * @return {DisplayObject} The child with the specified name. ++ * @return {createjs.DisplayObject} The child with the specified name. + **/ +- p.getChildByName = function(name) { ++ createjs.Container.prototype.getChildByName = function(name) { + var kids = this.children; + for (var i=0,l=kids.length;i<l;i++) { + if(kids[i].name == name) { return kids[i]; } +@@ -356,7 +348,7 @@ + * @param {Function} sortFunction the function to use to sort the child list. See JavaScript's <code>Array.sort</code> + * documentation for details. + **/ +- p.sortChildren = function(sortFunction) { ++ createjs.Container.prototype.sortChildren = function(sortFunction) { + this.children.sort(sortFunction); + }; + +@@ -368,10 +360,10 @@ + * var index = container.getChildIndex(child); + * + * @method getChildIndex +- * @param {DisplayObject} child The child to return the index of. ++ * @param {createjs.DisplayObject} child The child to return the index of. + * @return {Number} The index of the specified child. -1 if the child is not found. + **/ +- p.getChildIndex = function(child) { ++ createjs.Container.prototype.getChildIndex = function(child) { + return createjs.indexOf(this.children, child); + }; + +@@ -381,7 +373,7 @@ + * @param {Number} index1 + * @param {Number} index2 + **/ +- p.swapChildrenAt = function(index1, index2) { ++ createjs.Container.prototype.swapChildrenAt = function(index1, index2) { + var kids = this.children; + var o1 = kids[index1]; + var o2 = kids[index2]; +@@ -392,12 +384,12 @@ + + /** + * Swaps the specified children's depth in the display list. Fails silently if either child is not a child of this +- * Container. ++ * createjs.Container. + * @method swapChildren +- * @param {DisplayObject} child1 +- * @param {DisplayObject} child2 ++ * @param {createjs.DisplayObject} child1 ++ * @param {createjs.DisplayObject} child2 + **/ +- p.swapChildren = function(child1, child2) { ++ createjs.Container.prototype.swapChildren = function(child1, child2) { + var kids = this.children; + var index1,index2; + for (var i=0,l=kids.length;i<l;i++) { +@@ -412,11 +404,11 @@ + + /** + * Changes the depth of the specified child. Fails silently if the child is not a child of this container, or the index is out of range. +- * @param {DisplayObject} child ++ * @param {createjs.DisplayObject} child + * @param {Number} index + * @method setChildIndex + **/ +- p.setChildIndex = function(child, index) { ++ createjs.Container.prototype.setChildIndex = function(child, index) { + var kids = this.children, l=kids.length; + if (child.parent != this || index < 0 || index >= l) { return; } + for (var i=0;i<l;i++) { +@@ -431,10 +423,10 @@ + * Returns true if the specified display object either is this container or is a descendent (child, grandchild, etc) + * of this container. + * @method contains +- * @param {DisplayObject} child The DisplayObject to be checked. ++ * @param {createjs.DisplayObject} child The DisplayObject to be checked. + * @return {Boolean} true if the specified display object either is this container or is a descendent. + **/ +- p.contains = function(child) { ++ createjs.Container.prototype.contains = function(child) { + while (child) { + if (child == this) { return true; } + child = child.parent; +@@ -452,7 +444,7 @@ + * @return {Boolean} A Boolean indicating whether there is a visible section of a DisplayObject that overlaps the specified + * coordinates. + **/ +- p.hitTest = function(x, y) { ++ createjs.Container.prototype.hitTest = function(x, y) { + // TODO: optimize to use the fast cache check where possible. + return (this.getObjectUnderPoint(x, y) != null); + }; +@@ -482,7 +474,7 @@ + * @param {Number} [mode=0] The mode to use to determine which display objects to include. 0-all, 1-respect mouseEnabled/mouseChildren, 2-only mouse opaque objects. + * @return {Array} An Array of DisplayObjects under the specified coordinates. + **/ +- p.getObjectsUnderPoint = function(x, y, mode) { ++ createjs.Container.prototype.getObjectsUnderPoint = function(x, y, mode) { + var arr = []; + var pt = this.localToGlobal(x, y); + this._getObjectsUnderPoint(pt.x, pt.y, arr, mode>0, mode==1); +@@ -497,9 +489,9 @@ + * @param {Number} x The x position in the container to test. + * @param {Number} y The y position in the container to test. + * @param {Number} mode The mode to use to determine which display objects to include. 0-all, 1-respect mouseEnabled/mouseChildren, 2-only mouse opaque objects. +- * @return {DisplayObject} The top-most display object under the specified coordinates. ++ * @return {createjs.DisplayObject} The top-most display object under the specified coordinates. + **/ +- p.getObjectUnderPoint = function(x, y, mode) { ++ createjs.Container.prototype.getObjectUnderPoint = function(x, y, mode) { + var pt = this.localToGlobal(x, y); + return this._getObjectsUnderPoint(pt.x, pt.y, null, mode>0, mode==1); + }; +@@ -507,7 +499,7 @@ + /** + * Docced in superclass. + */ +- p.getBounds = function() { ++ createjs.Container.prototype.getBounds = function() { + return this._getBounds(null, true); + }; + +@@ -515,19 +507,19 @@ + /** + * Docced in superclass. + */ +- p.getTransformedBounds = function() { ++ createjs.Container.prototype.getTransformedBounds = function() { + return this._getBounds(); + }; + + /** +- * Returns a clone of this Container. Some properties that are specific to this instance's current context are ++ * Returns a clone of this createjs.Container. Some properties that are specific to this instance's current context are + * reverted to their defaults (for example .parent). + * @method clone + * @param {Boolean} recursive If true, all of the descendants of this container will be cloned recursively. If false, the + * properties of the container will be cloned, but the new instance will not have any children. +- * @return {Container} A clone of the current Container instance. ++ * @return {createjs.Container} A clone of the current Container instance. + **/ +- p.clone = function(recursive) { ++ createjs.Container.prototype.clone = function(recursive) { + var o = this._cloneProps(new Container()); + if (recursive) { this._cloneChildren(o); } + return o; +@@ -538,7 +530,7 @@ + * @method toString + * @return {String} a string representation of the instance. + **/ +- p.toString = function() { ++ createjs.Container.prototype.toString = function() { + return "[Container (name="+ this.name +")]"; + }; + +@@ -549,7 +541,7 @@ + * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. + * @protected + **/ +- p._tick = function(evtObj) { ++ createjs.Container.prototype._tick = function(evtObj) { + if (this.tickChildren) { + for (var i=this.children.length-1; i>=0; i--) { + var child = this.children[i]; +@@ -563,9 +555,9 @@ + * Recursively clones all children of this container, and adds them to the target container. + * @method cloneChildren + * @protected +- * @param {Container} o The target container. ++ * @param {createjs.Container} o The target container. + **/ +- p._cloneChildren = function(o) { ++ createjs.Container.prototype._cloneChildren = function(o) { + if (o.children.length) { o.removeAllChildren(); } + var arr = o.children; + for (var i=0, l=this.children.length; i<l; i++) { +@@ -583,10 +575,10 @@ + * @param {Boolean} mouse If true, it will respect mouse interaction properties like mouseEnabled, mouseChildren, and active listeners. + * @param {Boolean} activeListener If true, there is an active mouse event listener on a parent object. + * @param {Number} currentDepth Indicates the current depth of the search. +- * @return {DisplayObject} ++ * @return {createjs.DisplayObject} + * @protected + **/ +- p._getObjectsUnderPoint = function(x, y, arr, mouse, activeListener, currentDepth) { ++ createjs.Container.prototype._getObjectsUnderPoint = function(x, y, arr, mouse, activeListener, currentDepth) { + currentDepth = currentDepth || 0; + if (!currentDepth && !this._testMask(this, x, y)) { return null; } + var mtx, ctx = createjs.DisplayObject._hitTestContext; +@@ -631,13 +623,13 @@ + + /** + * @method _testMask +- * @param {DisplayObject} target ++ * @param {createjs.DisplayObject} target + * @param {Number} x + * @param {Number} y + * @return {Boolean} Indicates whether the x/y is within the masked region. + * @protected + **/ +- p._testMask = function(target, x, y) { ++ createjs.Container.prototype._testMask = function(target, x, y) { + var mask = target.mask; + if (!mask || !mask.graphics || mask.graphics.isEmpty()) { return true; } + +@@ -662,12 +654,12 @@ + + /** + * @method _getBounds +- * @param {Matrix2D} matrix ++ * @param {createjs.Matrix2D} matrix + * @param {Boolean} ignoreTransform If true, does not apply this object's transform. +- * @return {Rectangle} ++ * @return {createjs.Rectangle} + * @protected + **/ +- p._getBounds = function(matrix, ignoreTransform) { ++ createjs.Container.prototype._getBounds = function(matrix, ignoreTransform) { + var bounds = this.DisplayObject_getBounds(); + if (bounds) { return this._transformBounds(bounds, matrix, ignoreTransform); } + +@@ -686,5 +678,4 @@ + }; + + +- createjs.Container = createjs.promote(Container, "DisplayObject"); +-}()); +\ No newline at end of file ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/easeljs/display/DOMElement.js EaselJS-0.8.0/src/easeljs/display/DOMElement.js +--- ../target/downloads/EaselJS-0.8.0/src/easeljs/display/DOMElement.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/easeljs/display/DOMElement.js 2016-05-31 11:03:08.000000000 +0200 +@@ -31,10 +31,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + + // constructor: +@@ -66,11 +62,11 @@ + * } + * + * @class DOMElement +- * @extends DisplayObject ++ * @extends createjs.DisplayObject + * @constructor + * @param {HTMLElement} htmlElement A reference or id for the DOM element to manage. + */ +- function DOMElement(htmlElement) { ++ createjs.DOMElement = function(htmlElement) { + this.DisplayObject_constructor(); + + if (typeof(htmlElement)=="string") { htmlElement = document.getElementById(htmlElement); } +@@ -98,10 +94,10 @@ + */ + this._oldProps = null; + } +- var p = createjs.extend(DOMElement, createjs.DisplayObject); ++ + + // TODO: deprecated +- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. ++ // createjs.DOMElement.prototype.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. + + + // public methods: +@@ -112,7 +108,7 @@ + * @method isVisible + * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas + */ +- p.isVisible = function() { ++ createjs.DOMElement.prototype.isVisible = function() { + return this.htmlElement != null; + }; + +@@ -127,59 +123,59 @@ + * into itself). + * @return {Boolean} + */ +- p.draw = function(ctx, ignoreCache) { ++ createjs.DOMElement.prototype.draw = function(ctx, ignoreCache) { + // this relies on the _tick method because draw isn't called if the parent is not visible. + // the actual update happens in _handleDrawEnd + return true; + }; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method cache + */ +- p.cache = function() {}; ++ createjs.DOMElement.prototype.cache = function() {}; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method uncache + */ +- p.uncache = function() {}; ++ createjs.DOMElement.prototype.uncache = function() {}; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method updateCache + */ +- p.updateCache = function() {}; ++ createjs.DOMElement.prototype.updateCache = function() {}; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method hitTest + */ +- p.hitTest = function() {}; ++ createjs.DOMElement.prototype.hitTest = function() {}; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method localToGlobal + */ +- p.localToGlobal = function() {}; ++ createjs.DOMElement.prototype.localToGlobal = function() {}; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method globalToLocal + */ +- p.globalToLocal = function() {}; ++ createjs.DOMElement.prototype.globalToLocal = function() {}; + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @method localToLocal + */ +- p.localToLocal = function() {}; ++ createjs.DOMElement.prototype.localToLocal = function() {}; + + /** + * DOMElement cannot be cloned. Throws an error. + * @method clone + */ +- p.clone = function() { ++ createjs.DOMElement.prototype.clone = function() { + throw("DOMElement cannot be cloned.") + }; + +@@ -188,7 +184,7 @@ + * @method toString + * @return {String} a string representation of the instance. + */ +- p.toString = function() { ++ createjs.DOMElement.prototype.toString = function() { + return "[DOMElement (name="+ this.name +")]"; + }; + +@@ -217,7 +213,7 @@ + */ + + /** +- * Not applicable to DOMElement. ++ * Not applicable to createjs.DOMElement. + * @event tick + */ + +@@ -229,7 +225,7 @@ + * function. + * @protected + */ +- p._tick = function(evtObj) { ++ createjs.DOMElement.prototype._tick = function(evtObj) { + var stage = this.getStage(); + stage&&stage.on("drawend", this._handleDrawEnd, this, true); + this.DisplayObject__tick(evtObj); +@@ -240,7 +236,7 @@ + * @param {Event} evt + * @protected + */ +- p._handleDrawEnd = function(evt) { ++ createjs.DOMElement.prototype._handleDrawEnd = function(evt) { + var o = this.htmlElement; + if (!o) { return; } + var style = o.style; +@@ -269,5 +265,5 @@ + }; + + +- createjs.DOMElement = createjs.promote(DOMElement, "DisplayObject"); +-}()); ++ ++ +diff -ur ../target/downloads/EaselJS-0.8.0/src/easeljs/display/DisplayObject.js EaselJS-0.8.0/src/easeljs/display/DisplayObject.js +--- ../target/downloads/EaselJS-0.8.0/src/easeljs/display/DisplayObject.js 2014-12-19 11:08:04.000000000 +0100 ++++ EaselJS-0.8.0/src/easeljs/display/DisplayObject.js 2016-05-31 11:03:08.000000000 +0200 +@@ -56,7 +56,7 @@ + * + * //Create a stage by getting a reference to the canvas + * stage = new createjs.Stage("demoCanvas"); +- * //Create a Shape DisplayObject. ++ * //Create a Shape createjs.DisplayObject. + * circle = new createjs.Shape(); + * circle.graphics.beginFill("red").drawCircle(0, 0, 40); + * //Set position of Shape instance. +@@ -119,10 +119,6 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; + + + // constructor: +@@ -133,10 +129,10 @@ + * methods that are shared between all display objects, such as transformation properties (x, y, scaleX, scaleY, etc), + * caching, and mouse handlers. + * @class DisplayObject +- * @extends EventDispatcher ++ * @extends createjs.EventDispatcher + * @constructor + **/ +- function DisplayObject() { ++ createjs.DisplayObject = function() { + this.EventDispatcher_constructor(); + + +@@ -216,7 +212,7 @@ + * to one. + * @property parent + * @final +- * @type {Container} ++ * @type {createjs.Container} + * @default null + * @readonly + **/ +@@ -286,7 +282,7 @@ + * A shadow object that defines the shadow to render on this display object. Set to `null` to remove a shadow. If + * null, this property is inherited from the parent container. + * @property shadow +- * @type {Shadow} ++ * @type {createjs.Shadow} + * @default null + **/ + this.shadow = null; +@@ -319,7 +315,7 @@ + * If set, defines the transformation for this display object, overriding all other transformation properties + * (x, y, rotation, scale, skew). + * @property transformMatrix +- * @type {Matrix2D} ++ * @type {createjs.Matrix2D} + * @default null + **/ + this.transformMatrix = null; +@@ -376,7 +372,7 @@ + * + * Note that hitArea is NOT currently used by the `hitTest()` method, nor is it supported for {{#crossLink "Stage"}}{{/crossLink}}. + * @property hitArea +- * @type {DisplayObject} ++ * @type {createjs.DisplayObject} + * @default null + */ + this.hitArea = null; +@@ -452,7 +448,7 @@ + /** + * @property _props + * @protected +- * @type {DisplayObject} ++ * @type {createjs.DisplayObject} + * @default null + **/ + this._props = new createjs.DisplayProps(); +@@ -460,7 +456,7 @@ + /** + * @property _rectangle + * @protected +- * @type {Rectangle} ++ * @type {createjs.Rectangle} + * @default null + **/ + this._rectangle = new createjs.Rectangle(); +@@ -468,15 +464,15 @@ + /** + * @property _bounds + * @protected +- * @type {Rectangle} ++ * @type {createjs.Rectangle} + * @default null + **/ + this._bounds = null; + } +- var p = createjs.extend(DisplayObject, createjs.EventDispatcher); ++ + + // TODO: deprecated +- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. ++ // createjs.DisplayObject.prototype.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. + + // static properties: + /** +@@ -486,7 +482,7 @@ + * @static + * @type {Array} + **/ +- DisplayObject._MOUSE_EVENTS = ["click","dblclick","mousedown","mouseout","mouseover","pressmove","pressup","rollout","rollover"]; ++ createjs.DisplayObject._MOUSE_EVENTS = ["click","dblclick","mousedown","mouseout","mouseover","pressmove","pressup","rollout","rollover"]; + + /** + * Suppresses errors generated when using features like hitTest, mouse events, and {{#crossLink "getObjectsUnderPoint"}}{{/crossLink}} +@@ -496,7 +492,7 @@ + * @type {Boolean} + * @default false + **/ +- DisplayObject.suppressCrossDomainErrors = false; ++ createjs.DisplayObject.suppressCrossDomainErrors = false; + + /** + * @property _snapToPixelEnabled +@@ -505,7 +501,7 @@ + * @type {Boolean} + * @default false + **/ +- DisplayObject._snapToPixelEnabled = false; // stage.snapToPixelEnabled is temporarily copied here during a draw to provide global access. ++ createjs.DisplayObject._snapToPixelEnabled = false; // stage.snapToPixelEnabled is temporarily copied here during a draw to provide global access. + + /** + * @property _hitTestCanvas +@@ -521,8 +517,8 @@ + **/ + var canvas = createjs.createCanvas?createjs.createCanvas():document.createElement("canvas"); // prevent errors on load in browsers without canvas. + if (canvas.getContext) { +- DisplayObject._hitTestCanvas = canvas; +- DisplayObject._hitTestContext = canvas.getContext("2d"); ++ createjs.DisplayObject._hitTestCanvas = canvas; ++ createjs.DisplayObject._hitTestContext = canvas.getContext("2d"); + canvas.width = canvas.height = 1; + } + +@@ -532,7 +528,7 @@ + * @static + * @protected + **/ +- DisplayObject._nextCacheID = 1; ++ createjs.DisplayObject._nextCacheID = 1; + + + // events: +@@ -658,10 +654,10 @@ + /** + * Use the {{#crossLink "DisplayObject/stage:property"}}{{/crossLink}} property instead. + * @method getStage +- * @return {Stage} ++ * @return {createjs.Stage} + * @deprecated + **/ +- p.getStage = function() { ++ createjs.DisplayObject.prototype.getStage = function() { + // uses dynamic access to avoid circular dependencies; + var o = this, _Stage = createjs["Stage"]; + while (o.parent) { o = o.parent; } +@@ -672,14 +668,10 @@ + /** + * Returns the Stage instance that this display object will be rendered on, or null if it has not been added to one. + * @property stage +- * @type {Stage} ++ * @type {createjs.Stage} + * @readonly + **/ +- try { +- Object.defineProperties(p, { +- stage: { get: p.getStage } +- }); +- } catch (e) {} ++createjs.DisplayObject.prototype.stage; + + + // public methods: +@@ -691,7 +683,7 @@ + * @method isVisible + * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas + **/ +- p.isVisible = function() { ++ createjs.DisplayObject.prototype.isVisible = function() { + return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0); + }; + +@@ -706,7 +698,7 @@ + * used for drawing the cache (to prevent it from simply drawing an existing cache back into itself). + * @return {Boolean} + **/ +- p.draw = function(ctx, ignoreCache) { ++ createjs.DisplayObject.prototype.draw = function(ctx, ignoreCache) { + var cacheCanvas = this.cacheCanvas; + if (ignoreCache || !cacheCanvas) { return false; } + var scale = this._cacheScale; +@@ -720,7 +712,7 @@ + * @method updateContext + * @param {CanvasRenderingContext2D} ctx The canvas 2D to update. + **/ +- p.updateContext = function(ctx) { ++ createjs.DisplayObject.prototype.updateContext = function(ctx) { + var o=this, mask=o.mask, mtx= o._props.matrix; + + if (mask && mask.graphics && !mask.graphics.isEmpty()) { +@@ -736,7 +728,7 @@ + + this.getMatrix(mtx); + var tx = mtx.tx, ty = mtx.ty; +- if (DisplayObject._snapToPixelEnabled && o.snapToPixel) { ++ if (createjs.DisplayObject._snapToPixelEnabled && o.snapToPixel) { + tx = tx + (tx < 0 ? -0.5 : 0.5) | 0; + ty = ty + (ty < 0 ? -0.5 : 0.5) | 0; + } +@@ -777,7 +769,7 @@ + * myShape.cache(0,0,100,100,2) then the resulting cacheCanvas will be 200x200 px. This lets you scale and rotate + * cached elements with greater fidelity. Default is 1. + **/ +- p.cache = function(x, y, width, height, scale) { ++ createjs.DisplayObject.prototype.cache = function(x, y, width, height, scale) { + // draw to canvas. + scale = scale||1; + if (!this.cacheCanvas) { this.cacheCanvas = createjs.createCanvas?createjs.createCanvas():document.createElement("canvas"); } +@@ -808,7 +800,7 @@ + * <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#compositing";> + * whatwg spec on compositing</a>. + **/ +- p.updateCache = function(compositeOperation) { ++ createjs.DisplayObject.prototype.updateCache = function(compositeOperation) { + var cacheCanvas = this.cacheCanvas; + if (!cacheCanvas) { throw "cache() must be called before updateCache()"; } + var scale = this._cacheScale, offX = this._cacheOffsetX*scale, offY = this._cacheOffsetY*scale; +@@ -835,14 +827,14 @@ + // TODO: filters and cache scale don't play well together at present. + this._applyFilters(); + ctx.restore(); +- this.cacheID = DisplayObject._nextCacheID++; ++ this.cacheID = createjs.DisplayObject._nextCacheID++; + }; + + /** + * Clears the current cache. See {{#crossLink "DisplayObject/cache"}}{{/crossLink}} for more information. + * @method uncache + **/ +- p.uncache = function() { ++ createjs.DisplayObject.prototype.uncache = function() { + this._cacheDataURL = this.cacheCanvas = null; + this.cacheID = this._cacheOffsetX = this._cacheOffsetY = this._filterOffsetX = this._filterOffsetY = 0; + this._cacheScale = 1; +@@ -854,7 +846,7 @@ + * @method getCacheDataURL + * @return {String} The image data url for the cache. + **/ +- p.getCacheDataURL = function() { ++ createjs.DisplayObject.prototype.getCacheDataURL = function() { + if (!this.cacheCanvas) { return null; } + if (this.cacheID != this._cacheDataURLID) { this._cacheDataURL = this.cacheCanvas.toDataURL(); } + return this._cacheDataURL; +@@ -871,17 +863,17 @@ + * displayObject.x = 300; + * displayObject.y = 200; + * stage.addChild(displayObject); +- * var point = myDisplayObject.localToGlobal(100, 100); ++ * var point = mycreatejs.DisplayObject.localToGlobal(100, 100); + * // Results in x=400, y=300 + * + * @method localToGlobal + * @param {Number} x The x position in the source display object to transform. + * @param {Number} y The y position in the source display object to transform. +- * @param {Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. +- * @return {Point} A Point instance with x and y properties correlating to the transformed coordinates ++ * @param {createjs.Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. ++ * @return {createjs.Point} A Point instance with x and y properties correlating to the transformed coordinates + * on the stage. + **/ +- p.localToGlobal = function(x, y, pt) { ++ createjs.DisplayObject.prototype.localToGlobal = function(x, y, pt) { + return this.getConcatenatedMatrix(this._props.matrix).transformPoint(x,y, pt||new createjs.Point()); + }; + +@@ -896,17 +888,17 @@ + * displayObject.x = 300; + * displayObject.y = 200; + * stage.addChild(displayObject); +- * var point = myDisplayObject.globalToLocal(100, 100); ++ * var point = mycreatejs.DisplayObject.globalToLocal(100, 100); + * // Results in x=-200, y=-100 + * + * @method globalToLocal + * @param {Number} x The x position on the stage to transform. + * @param {Number} y The y position on the stage to transform. +- * @param {Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. +- * @return {Point} A Point instance with x and y properties correlating to the transformed position in the ++ * @param {createjs.Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. ++ * @return {createjs.Point} A Point instance with x and y properties correlating to the transformed position in the + * display object's coordinate space. + **/ +- p.globalToLocal = function(x, y, pt) { ++ createjs.DisplayObject.prototype.globalToLocal = function(x, y, pt) { + return this.getConcatenatedMatrix(this._props.matrix).invert().transformPoint(x,y, pt||new createjs.Point()); + }; + +@@ -922,12 +914,12 @@ + * @method localToLocal + * @param {Number} x The x position in the source display object to transform. + * @param {Number} y The y position on the source display object to transform. +- * @param {DisplayObject} target The target display object to which the coordinates will be transformed. +- * @param {Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. +- * @return {Point} Returns a Point instance with x and y properties correlating to the transformed position ++ * @param {createjs.DisplayObject} target The target display object to which the coordinates will be transformed. ++ * @param {createjs.Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. ++ * @return {createjs.Point} Returns a Point instance with x and y properties correlating to the transformed position + * in the target's coordinate space. + **/ +- p.localToLocal = function(x, y, target, pt) { ++ createjs.DisplayObject.prototype.localToLocal = function(x, y, target, pt) { + pt = this.localToGlobal(x, y, pt); + return target.globalToLocal(pt.x, pt.y, pt); + }; +@@ -950,10 +942,10 @@ + * @param {Number} [skewY=0] The vertical skew factor + * @param {Number} [regX=0] The horizontal registration point in pixels + * @param {Number} [regY=0] The vertical registration point in pixels +- * @return {DisplayObject} Returns this instance. Useful for chaining commands. ++ * @return {createjs.DisplayObject} Returns this instance. Useful for chaining commands. + * @chainable + */ +- p.setTransform = function(x, y, scaleX, scaleY, rotation, skewX, skewY, regX, regY) { ++ createjs.DisplayObject.prototype.setTransform = function(x, y, scaleX, scaleY, rotation, skewX, skewY, regX, regY) { + this.x = x || 0; + this.y = y || 0; + this.scaleX = scaleX == null ? 1 : scaleX; +@@ -969,11 +961,11 @@ + /** + * Returns a matrix based on this object's current transform. + * @method getMatrix +- * @param {Matrix2D} matrix Optional. A Matrix2D object to populate with the calculated values. If null, a new ++ * @param {createjs.Matrix2D} matrix Optional. A Matrix2D object to populate with the calculated values. If null, a new + * Matrix object is returned. +- * @return {Matrix2D} A matrix representing this display object's transform. ++ * @return {createjs.Matrix2D} A matrix representing this display object's transform. + **/ +- p.getMatrix = function(matrix) { ++ createjs.DisplayObject.prototype.getMatrix = function(matrix) { + var o = this, mtx = matrix&&matrix.identity() || new createjs.Matrix2D(); + return o.transformMatrix ? mtx.copy(o.transformMatrix) : mtx.appendTransform(o.x, o.y, o.scaleX, o.scaleY, o.rotation, o.skewX, o.skewY, o.regX, o.regY); + }; +@@ -984,11 +976,11 @@ + * be used to transform positions between coordinate spaces, such as with {{#crossLink "DisplayObject/localToGlobal"}}{{/crossLink}} + * and {{#crossLink "DisplayObject/globalToLocal"}}{{/crossLink}}. + * @method getConcatenatedMatrix +- * @param {Matrix2D} [matrix] A {{#crossLink "Matrix2D"}}{{/crossLink}} object to populate with the calculated values. ++ * @param {createjs.Matrix2D} [matrix] A {{#crossLink "Matrix2D"}}{{/crossLink}} object to populate with the calculated values. + * If null, a new Matrix2D object is returned. +- * @return {Matrix2D} The combined matrix. ++ * @return {createjs.Matrix2D} The combined matrix. + **/ +- p.getConcatenatedMatrix = function(matrix) { ++ createjs.DisplayObject.prototype.getConcatenatedMatrix = function(matrix) { + var o = this, mtx = this.getMatrix(matrix); + while (o = o.parent) { + mtx.prependMatrix(o.getMatrix(o._props.matrix)); +@@ -1000,11 +992,11 @@ + * Generates a DisplayProps object representing the combined display properties of the object and all of its + * parent Containers up to the highest level ancestor (usually the {{#crossLink "Stage"}}{{/crossLink}}). + * @method getConcatenatedDisplayProps +- * @param {DisplayProps} [props] A {{#crossLink "DisplayProps"}}{{/crossLink}} object to populate with the calculated values. ++ * @param {createjs.DisplayProps} [props] A {{#crossLink "DisplayProps"}}{{/crossLink}} object to populate with the calculated values. + * If null, a new DisplayProps object is returned. +- * @return {DisplayProps} The combined display properties. ++ * @return {createjs.DisplayProps} The combined display properties. + **/ +- p.getConcatenatedDisplayProps = function(props) { ++ createjs.DisplayObject.prototype.getConcatenatedDisplayProps = function(props) { + props = props ? props.identity() : new createjs.DisplayProps(); + var o = this, mtx = o.getMatrix(props.matrix); + do { +@@ -1035,8 +1027,8 @@ + * @return {Boolean} A Boolean indicating whether a visible portion of the DisplayObject intersect the specified + * local Point. + */ +- p.hitTest = function(x, y) { +- var ctx = DisplayObject._hitTestContext; ++ createjs.DisplayObject.prototype.hitTest = function(x, y) { ++ var ctx = createjs.DisplayObject._hitTestContext; + ctx.setTransform(1, 0, 0, 1, -x, -y); + this.draw(ctx); + +@@ -1056,10 +1048,10 @@ + * + * @method set + * @param {Object} props A generic object containing properties to copy to the DisplayObject instance. +- * @return {DisplayObject} Returns the instance the method is called on (useful for chaining calls.) ++ * @return {createjs.DisplayObject} Returns the instance the method is called on (useful for chaining calls.) + * @chainable + */ +- p.set = function(props) { ++ createjs.DisplayObject.prototype.set = function(props) { + for (var n in props) { this[n] = props[n]; } + return this; + }; +@@ -1117,10 +1109,10 @@ + * myRect.copy(obj.getBounds()); + * + * @method getBounds +- * @return {Rectangle} A Rectangle instance representing the bounds, or null if bounds are not available for this ++ * @return {createjs.Rectangle} A Rectangle instance representing the bounds, or null if bounds are not available for this + * object. + **/ +- p.getBounds = function() { ++ createjs.DisplayObject.prototype.getBounds = function() { + if (this._bounds) { return this._rectangle.copy(this._bounds); } + var cacheCanvas = this.cacheCanvas; + if (cacheCanvas) { +@@ -1143,9 +1135,9 @@ + * + * Container instances calculate aggregate bounds for all children that return bounds via getBounds. + * @method getTransformedBounds +- * @return {Rectangle} A Rectangle instance representing the bounds, or null if bounds are not available for this object. ++ * @return {createjs.Rectangle} A Rectangle instance representing the bounds, or null if bounds are not available for this object. + **/ +- p.getTransformedBounds = function() { ++ createjs.DisplayObject.prototype.getTransformedBounds = function() { + return this._getBounds(); + }; + +@@ -1162,19 +1154,19 @@ + * @param {Number} width The width of the bounds. + * @param {Number} height The height of the bounds. + **/ +- p.setBounds = function(x, y, width, height) { ++ createjs.DisplayObject.prototype.setBounds = function(x, y, width, height) { + if (x == null) { this._bounds = x; } + this._bounds = (this._bounds || new createjs.Rectangle()).setValues(x, y, width, height); + }; + + /** +- * Returns a clone of this DisplayObject. Some properties that are specific to this instance's current context are ++ * Returns a clone of this createjs.DisplayObject. Some properties that are specific to this instance's current context are + * reverted to their defaults (for example .parent). Caches are not maintained across clones, and some elements + * are copied by reference (masks, individual filter instances, hit area) + * @method clone +- * @return {DisplayObject} A clone of the current DisplayObject instance. ++ * @return {createjs.DisplayObject} A clone of the current DisplayObject instance. + **/ +- p.clone = function() { ++ createjs.DisplayObject.prototype.clone = function() { + return this._cloneProps(new DisplayObject()); + }; + +@@ -1183,7 +1175,7 @@ + * @method toString + * @return {String} a string representation of the instance. + **/ +- p.toString = function() { ++ createjs.DisplayObject.prototype.toString = function() { + return "[DisplayObject (name="+ this.name +")]"; + }; + +@@ -1192,12 +1184,12 @@ + // separated so it can be used more easily in subclasses: + /** + * @method _cloneProps +- * @param {DisplayObject} o The DisplayObject instance which will have properties from the current DisplayObject ++ * @param {createjs.DisplayObject} o The DisplayObject instance which will have properties from the current DisplayObject + * instance copied into. +- * @return {DisplayObject} o ++ * @return {createjs.DisplayObject} o + * @protected + **/ +- p._cloneProps = function(o) { ++ createjs.DisplayObject.prototype._cloneProps = function(o) { + o.alpha = this.alpha; + o.mouseEnabled = this.mouseEnabled; + o.tickEnabled = this.tickEnabled; +@@ -1227,9 +1219,9 @@ + * @method _applyShadow + * @protected + * @param {CanvasRenderingContext2D} ctx +- * @param {Shadow} shadow ++ * @param {createjs.Shadow} shadow + **/ +- p._applyShadow = function(ctx, shadow) { ++ createjs.DisplayObject.prototype._applyShadow = function(ctx, shadow) { + shadow = shadow || Shadow.identity; + ctx.shadowColor = shadow.color; + ctx.shadowOffsetX = shadow.offsetX; +@@ -1243,7 +1235,7 @@ + * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. + * @protected + **/ +- p._tick = function(evtObj) { ++ createjs.DisplayObject.prototype._tick = function(evtObj) { + // because tick can be really performance sensitive, check for listeners before calling dispatchEvent. + var ls = this._listeners; + if (ls && ls["tick"]) { +@@ -1260,11 +1252,11 @@ + * @param {CanvasRenderingContext2D} ctx + * @return {Boolean} + **/ +- p._testHit = function(ctx) { ++ createjs.DisplayObject.prototype._testHit = function(ctx) { + try { + var hit = ctx.getImageData(0, 0, 1, 1).data[3] > 1; + } catch (e) { +- if (!DisplayObject.suppressCrossDomainErrors) { ++ if (!createjs.DisplayObject.suppressCrossDomainErrors) { + throw "An error has occurred. This is most likely due to security restrictions on reading canvas pixel data with local or cross-domain images."; + } + } +@@ -1275,7 +1267,7 @@ + * @method _applyFilters + * @protected + **/ +- p._applyFilters = function() { ++ createjs.DisplayObject.prototype._applyFilters = function() { + if (!this.filters || this.filters.length == 0 || !this.cacheCanvas) { return; } + var l = this.filters.length; + var ctx = this.cacheCanvas.getContext("2d"); +@@ -1288,10 +1280,10 @@ + + /** + * @method _getFilterBounds +- * @return {Rectangle} ++ * @return {createjs.Rectangle} + * @protected + **/ +- p._getFilterBounds = function(rect) { ++ createjs.DisplayObject.prototype._getFilterBounds = function(rect) { + var l, filters = this.filters, bounds = this._rectangle.setValues(0,0,0,0); + if (!filters || !(l=filters.length)) { return bounds; } + +@@ -1304,24 +1296,24 @@ + + /** + * @method _getBounds +- * @param {Matrix2D} matrix ++ * @param {createjs.Matrix2D} matrix + * @param {Boolean} ignoreTransform If true, does not apply this object's transform. +- * @return {Rectangle} ++ * @return {createjs.Rectangle} + * @protected + **/ +- p._getBounds = function(matrix, ignoreTransform){ ++ createjs.DisplayObject.prototype._getBounds = function(matrix, ignoreTransform){ + return this._transformBounds(this.getBounds(), matrix, ignoreTransform); + }; + + /** + * @method _transformBounds +- * @param {Rectangle} bounds +- * @param {Matrix2D} matrix ++ * @param {createjs.Rectangle} bounds ++ * @param {createjs.Matrix2D} matrix + * @param {Boolean} ignoreTransform +- * @return {Rectangle} ++ * @return {createjs.Rectangle} + * @protected + **/ +- p._transformBounds = funct
<TRUNCATED>
