/*!
 * pixi-animate - v1.3.3
 * Compiled Mon, 08 Jan 2018 01:44:52 UTC
 *
 * pixi-animate is licensed under the MIT License.
 * http://www.opensource.org/licenses/mit-license
 */
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.pixiAnimate = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _AnimatorTimeline = require("./AnimatorTimeline");

var _AnimatorTimeline2 = _interopRequireDefault(_AnimatorTimeline);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Static collection of timelines
var timelines = [];

/**
 * Play animation via start/stop frame labels
 * @class Animator
 * @memberof PIXI.animate
 */

var Animator = function () {
    function Animator() {
        _classCallCheck(this, Animator);
    }

    /**
     * Play an animation by frame labels. For instance, play animation sequence from
     * "idle" to "idle_stop" or "idle_loop". If no event label is provided, will
     * play the entire duration of the MovieClip.
     * @method PIXI.animate.Animator#play
     * @static
     * @param {PIXI.animate.MovieClip} instance Movie clip to play.
     * @param {String|Function} [label] The frame label event to call, if no event is provided
     *        will use the entire length of the MovieClip. Can also be the callback.
     * @param {Function} [callback] Optional callback when complete
     * @return {PIXI.animate.AnimatorTimeline} Timeline object for stopping or getting progress.
     */
    Animator.play = function play(instance, label, callback) {
        var loop = false;
        var start = void 0,
            end = void 0;
        var labelIsFunction = typeof label === "function";
        if (label === undefined || labelIsFunction) {
            start = 0;
            end = instance.totalFrames - 1;
            if (labelIsFunction) {
                callback = label;
            }
        } else {
            start = instance.labelsMap[label];
            end = instance.labelsMap[label + this.STOP_LABEL];
            if (end === undefined) {
                end = instance.labelsMap[label + this.LOOP_LABEL];
                loop = true;
            }
            if (start === undefined) {
                throw new Error("No start label matching '" + label + "'");
            } else if (end === undefined) {
                throw new Error("No end label matching '" + label + "'");
            }
        }
        return this.fromTo(instance, start, end, loop, callback);
    };

    /**
     * Play an animation from the current frame to an end frame or label.
     * @method PIXI.animate.Animator#to
     * @static
     * @param {PIXI.animate.MovieClip} instance Movie clip to play.
     * @param {String|Number} end The end frame or label.
     * @param {Function} [callback] Optional callback when complete
     * @return {PIXI.animate.AnimatorTimeline} Timeline object for stopping or getting progress.
     */


    Animator.to = function to(instance, end, callback) {
        return this.fromTo(instance, instance.currentFrame, end, false, callback);
    };

    /**
     * Play a MovieClip from a start to end frame.
     * @method PIXI.animate.Animator#fromTo
     * @static
     * @param {PIXI.animate.MovieClip} instance Movie clip to play.
     * @param {Number|String} start The starting frame index or label.
     * @param {Number|String} end The ending frame index or label.
     * @param {Boolean} [loop=false] If the animation should loop.
     * @param {Function} [callback] Optional callback when complete
     * @return {PIXI.animate.AnimatorTimeline} Timeline object for stopping or getting progress.
     */


    Animator.fromTo = function fromTo(instance, start, end, loop, callback) {

        if (typeof start === "string") {
            var startLabel = start;
            start = instance.labelsMap[startLabel];
            if (start === undefined) {
                throw new Error("No start label matching '" + startLabel + "'");
            }
        }
        if (typeof end === "string") {
            var endLabel = end;
            end = instance.labelsMap[endLabel];
            if (end === undefined) {
                throw new Error("No end label matching '" + endLabel + "'");
            }
        }
        if (start < 0) {
            throw new Error('Start frame is out of bounds');
        }
        if (end >= instance.totalFrames) {
            throw new Error('End frame is out of bounds');
        }
        if (start >= end) {
            throw new Error('End frame is before start frame');
        }

        // Stop any animation that's playing
        this.stop(instance);

        loop = !!loop;

        // Add a new timeline
        var timeline = _AnimatorTimeline2.default.create(instance, start, end, loop, callback);
        this._timelines.push(timeline);

        // Set the current frame
        if (instance.currentFrame !== start) {
            instance.gotoAndPlay(start);
        } else {
            instance.play();
        }
        return timeline;
    };

    /**
     * Stop the animation by instance.
     * @method PIXI.animate.Animator#stop
     * @static
     * @param {PIXI.animate.MovieClip} instance Movie clip to play.
     */


    Animator.stop = function stop(instance) {
        for (var i = 0, len = this._timelines.length; i < len; i++) {
            var timeline = this._timelines[i];
            if (timeline.instance === instance) {
                this._internalStop(timeline);
                break;
            }
        }
    };

    /**
     * Stop all the currently playing animations.
     * @method PIXI.animate.Animator#stopAll
     * @static
     */


    Animator.stopAll = function stopAll() {
        for (var i = this._timelines.length - 1; i >= 0; i--) {
            this._internalStop(this._timelines[i]);
        }
    };

    /**
     * Stop the animation
     * @method PIXI.animate.Animator#_internalStop
     * @private
     * @static
     * @param {PIXI.animate.AnimatorTimeline} timeline Timeline to stop.
     */


    Animator._internalStop = function _internalStop(timeline) {
        this._timelines.splice(this._timelines.indexOf(timeline), 1);
        timeline.instance.stop();
        timeline.destroy();
    };

    _createClass(Animator, null, [{
        key: "_timelines",


        /**
         * The collection of timelines
         * @name {Array<PIXI.animate.AnimatorTimeline>} PIXI.animate.Animator#_timelines
         * @private
         * @static
         */
        get: function get() {
            return timelines;
        }

        /**
         * Suffix added to label for a stop.
         * @name {String} PIXI.animate.Animator.STOP_LABEL
         * @static
         * @default "_stop"
         */

    }, {
        key: "STOP_LABEL",
        get: function get() {
            return "_stop";
        }

        /**
         * Suffix added to label for a loop.
         * @name {String} PIXI.animate.Animator.LOOP_LABEL
         * @static
         * @default "_loop"
         */

    }, {
        key: "LOOP_LABEL",
        get: function get() {
            return "_loop";
        }
    }]);

    return Animator;
}();

module.exports = Animator;

},{"./AnimatorTimeline":2}],2:[function(require,module,exports){
"use strict";

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var pool = [];

/**
 * Represents a single animation play.
 * @class AnimatorTimeline
 * @memberof PIXI.animate
 */

var AnimatorTimeline = function () {
    function AnimatorTimeline() {
        _classCallCheck(this, AnimatorTimeline);

        this._update = this.update.bind(this);
        this.init(null, 0, 0, false, null);
    }

    /**
     * The pool of timelines to use
     * @method PIXI.animate.AnimatorTimeline#init
     * @param {PIXI.animate.MovieClip} instance
     * @param {Number} start
     * @param {Number} end
     * @param {Boolean} loop
     * @param {Function} callback
     * @private
     */


    AnimatorTimeline.prototype.init = function init(instance, start, end, loop, callback) {

        /**
         * Instance of clip to play.
         * @name PIXI.animate.AnimatorTimeline#instance
         * @type {PIXI.animate.MovieClip}
         * @readOnly
         */
        this.instance = instance;

        /**
         * `true` if the timeline is suppose to loop.
         * @name PIXI.animate.AnimatorTimeline#loop
         * @type {Boolean}
         * @readOnly
         */
        this.loop = loop;

        /**
         * Frame number of the starting farme.
         * @name PIXI.animate.AnimatorTimeline#start
         * @type {int}
         * @readOnly
         */
        this.start = start;

        /**
         * Frame number of the ending frame.
         * @name PIXI.animate.AnimatorTimeline#end
         * @type {int}
         * @readOnly
         */
        this.end = end;

        /**
         * Callback called when completed (non-looping animation).
         * @name PIXI.animate.AnimatorTimeline#callback
         * @type {Function}
         * @readOnly
         */
        this.callback = callback;

        if (instance) {
            instance.gotoAndStop(start);
            instance._beforeUpdate = this._update;
        }
    };

    /**
     * Don't use after this
     * @method PIXI.animate.AnimatorTimeline#destroy
     * @private
     */


    AnimatorTimeline.prototype.destroy = function destroy() {
        this.instance._beforeUpdate = null;
        this.init(null, 0, 0, false, null);
        AnimatorTimeline._pool.push(this);
    };

    /**
     * Is the animation complete
     * @method PIXI.animate.AnimatorTimeline#update
     * @param {PIXI.animate.MovieClip} instance
     * @return {Function} Callback to do after updateTimeline
     * @private
     */


    AnimatorTimeline.prototype.update = function update(instance) {
        var completed = void 0;
        if (instance.currentFrame >= this.end) {

            // In case we over-shoot the current frame becuase of low FPS
            instance.currentFrame = this.end;

            if (this.loop) {
                // Update timeline so we get actions at the end frame
                instance._updateTimeline();
                instance.gotoAndPlay(this.start);
            } else {
                instance.stop();
                if (this.callback) {
                    completed = this.callback;
                }
                this.stop(); // cleanup timeline
            }
        }
        return completed;
    };

    /**
     * Stop the animation, cannot be reused.
     * @method PIXI.animate.AnimatorTimeline#stop
     */


    AnimatorTimeline.prototype.stop = function stop() {
        PIXI.animate.Animator._internalStop(this);
    };

    /**
     * The progress from 0 to 1 of the playback.
     * @name PIXI.animate.AnimatorTimeline#progress
     * @type {Number}
     * @readOnly
     */


    /**
     * Create a new timeline
     * @method PIXI.animate.AnimatorTimeline.create
     * @static
     * @param {PIXI.animate.MovieClip} instance
     * @param {Number} start
     * @param {Number} end
     * @param {Boolean} loop
     * @param {Function} callback
     * @return {PIXI.animate.AnimatorTimeline}
     */
    AnimatorTimeline.create = function create(instance, start, end, loop, callback) {
        var timeline;
        if (this._pool.length) {
            timeline = this._pool.pop();
        } else {
            timeline = new AnimatorTimeline();
        }
        timeline.init(instance, start, end, loop, callback);
        return timeline;
    };

    _createClass(AnimatorTimeline, [{
        key: "progress",
        get: function get() {
            var progress = (this.instance.currentFrame - this.start) / (this.end - this.start);
            return Math.max(0, Math.min(1, progress)); // clamp
        }

        /**
         * The pool of timelines to use
         * @name PIXI.animate.AnimatorTimeline._pool
         * @type {Array<PIXI.animate.AnimatorTimeline>}
         * @static
         * @private
         */

    }], [{
        key: "_pool",
        get: function get() {
            return pool;
        }
    }]);

    return AnimatorTimeline;
}();

module.exports = AnimatorTimeline;

},{}],3:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _Timeline = require('./Timeline');

var _Timeline2 = _interopRequireDefault(_Timeline);

var _utils = require('./utils');

var _utils2 = _interopRequireDefault(_utils);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Container = PIXI.Container;
var SharedTicker = PIXI.ticker.shared;

/**
 * Provide timeline playback of movieclip
 * @memberof PIXI.animate
 * @class MovieClip
 * @extends PIXI.Container
 * @constructor
 * @param {Object|int} [options] The options object or the mode to play
 * @param {int} [options.mode=0] The playback mode default is independent (0),
 * @param {int} [options.startPosition=0] The starting frame
 * @param {Boolean} [options.loop=true] If playback is looped
 * @param {Object} [options.labels] The frame labels map of label to frames
 * @param {int} [options.duration] The duration, if no duration is provided, auto determines length
 * @param {int} [options.framerate=24] The framerate to use for independent mode
 */

var MovieClip = function (_Container) {
    _inherits(MovieClip, _Container);

    function MovieClip(options, duration, loop, framerate, labels) {
        _classCallCheck(this, MovieClip);

        // Default options
        var _this = _possibleConstructorReturn(this, _Container.call(this));

        options = options === undefined ? {} : options;

        // Options can also be the mode
        if (typeof options === 'number') {
            options = {
                mode: options || MovieClip.INDEPENDENT,
                duration: duration || 0,
                loop: loop === undefined ? true : loop,
                labels: labels || {},
                framerate: framerate || 0,
                startPosition: 0
            };
        } else {
            // Apply defaults to options
            options = Object.assign({
                mode: MovieClip.INDEPENDENT,
                startPosition: 0,
                loop: true,
                labels: {},
                duration: 0,
                framerate: 0
            }, options);
        }

        /**
         * Controls how this MovieClip advances its time. Must be one of 0 (INDEPENDENT), 1 (SINGLE_FRAME), or 2 (SYNCHED).
         * See each constant for a description of the behaviour.
         * @name PIXI.animate.MovieClip#mode
         * @type int
         * @default null
         */
        _this.mode = options.mode;

        /**
         * Specifies what the first frame to play in this movieclip, or the only frame to display if mode is SINGLE_FRAME.
         * @name PIXI.animate.MovieClip#startPosition
         * @type Number
         * @default 0
         */
        _this.startPosition = options.startPosition;

        /**
         * Indicates whether this MovieClip should loop when it reaches the end of its timeline.
         * @name PIXI.animate.MovieClip#loop
         * @type Boolean
         * @default true
         */
        _this.loop = !!options.loop;

        /**
         * The current frame of the movieclip.
         * @name PIXI.animate.MovieClip#currentFrame
         * @type Number
         * @default 0
         * @readOnly
         */
        _this.currentFrame = 0;

        /**
         * The collection of private labels
         * @name PIXI.animate.MovieClip#_labels
         * @type Array
         * @private
         */
        _this._labels = [];

        /**
         * The collection of private labels
         * @name PIXI.animate.MovieClip#_labelDict
         * @type Object
         * @private
         */
        _this._labelDict = options.labels;
        if (options.labels) {
            for (var name in options.labels) {
                var label = {
                    label: name,
                    position: options.labels[name]
                };
                _this._labels.push(label);
            }
            _this._labels.sort(function (a, b) {
                return a.position - b.position;
            });
        }

        /**
         * If true, this movieclip will animate automatically whenever it is on the stage.
         * @name PIXI.animate.MovieClip#selfAdvance
         * @type Boolean
         * @default true
         */
        _this.selfAdvance = true;

        /**
         * If true, the MovieClip's position will not advance when ticked.
         * @name PIXI.animate.MovieClip#paused
         * @type Boolean
         * @default false
         */
        _this.paused = false;

        /**
         * If true, actions in this MovieClip's tweens will be run when the playhead advances.
         * @name PIXI.animate.MovieClip#actionsEnabled
         * @type Boolean
         * @default true
         */
        _this.actionsEnabled = true;

        /**
         * If true, the MovieClip will automatically be reset to its first frame whenever the timeline adds
         * it back onto the display list. This only applies to MovieClip instances with mode=INDEPENDENT.
         * <br><br>
         * For example, if you had a character animation with a 'body' child MovieClip instance
         * with different costumes on each frame, you could set body.autoReset = false, so that
         * you can manually change the frame it is on, without worrying that it will be reset
         * automatically.
         * @name PIXI.animate.MovieClip#autoReset
         * @type Boolean
         * @default true
         */
        _this.autoReset = true;

        /**
         * @name PIXI.animate.MovieClip#_synchOffset
         * @type Number
         * @default 0
         * @private
         */
        _this._synchOffset = 0;

        /**
         * @name PIXI.animate.MovieClip#_prevPos
         * @type Number
         * @default -1
         * @private
         */
        _this._prevPos = -1; // TODO: evaluate using a ._reset Boolean prop instead of -1.

        /**
         * Note - changed from default: When the MovieClip is framerate independent, this is the time
         * elapsed from frame 0 in seconds.
         * @name PIXI.animate.MovieClip#_t
         * @type Number
         * @default 0
         * @private
         */
        _this._t = 0;

        /**
         * By default MovieClip instances advance one frame per tick. Specifying a framerate for the MovieClip
         * will cause it to advance based on elapsed time between ticks as appropriate to maintain the target
         * framerate.
         *
         * @name PIXI.animate.MovieClip#_framerate
         * @type {Number}
         * @default 0
         * @protected
         */
        _this._framerate = options.framerate;

        /**
         * The total time in seconds for the animation. This is changed when setting the framerate.
         * @name PIXI.animate.MovieClip#_duration
         * @type Number
         * @default 0
         * @private
         */
        _this._duration = 0;

        /**
         * The total duration in frames for the animation.
         * @name PIXI.animate.MovieClip#_totalFrames
         * @type Number
         * @default 0
         * @private
         */
        _this._totalFrames = options.duration;

        /**
         * Standard tween timelines for all objects. Each element in the _timelines array
         * is a Timeline object - an array of tweens for one target, in order of occurrence.
         * @name PIXI.animate.MovieClip#_timelines
         * @type Array
         * @protected
         */
        _this._timelines = [];

        /**
         * Array of child timelines denoting if a child is actively a child of this movieclip
         * on any given frame. Each element in the _timedChildTimelines is an array with a 'target'
         * property, and is an array of boolean values indexed by frame.
         * @name PIXI.animate.MovieClip#_timedChildTimelines
         * @type {Array}
         * @protected
         */
        _this._timedChildTimelines = [];

        /**
         * Array to depth sort timed children
         * @name PIXI.animate.MovieClip#_depthSorted
         * @type {Array}
         * @private
         */
        _this._depthSorted = [];

        /**
         * Array of frame scripts, indexed by frame.
         * @name PIXI.animate.MovieClip#_actions
         * @type {Array}
         * @protected
         */
        _this._actions = [];

        /**
         * Optional callback fired before timeline is updated.
         * Can be used to clamp or update the currentFrame.
         * @name PIXI.animate.MovieClip#_beforeUpdate
         * @type {Function}
         * @private
         */
        _this._beforeUpdate = null;

        if (_this.mode === MovieClip.INDEPENDENT) {
            _this._tickListener = _this._tickListener.bind(_this);
            _this._onAdded = _this._onAdded.bind(_this);
            _this._onRemoved = _this._onRemoved.bind(_this);
            _this.on('added', _this._onAdded);
            _this.on('removed', _this._onRemoved);
        }

        if (options.framerate) {
            _this.framerate = options.framerate;
        }

        //save often used methods on the instance so that they can be fetched slightly faster
        //than if they had to be fetched from the prototype
        _this.advance = _this.advance;
        _this._updateTimeline = _this._updateTimeline;
        _this._setTimelinePosition = _this._setTimelinePosition;
        _this._goto = _this._goto;
        return _this;
    }

    MovieClip.prototype._onAdded = function _onAdded() {
        if (!this._framerate) {
            this.framerate = this.parentFramerate;
        }
        SharedTicker.add(this._tickListener);
    };

    MovieClip.prototype._tickListener = function _tickListener(tickerDeltaTime) {
        if (this.paused || !this.selfAdvance) {
            //see if the movieclip needs to be updated even though it isn't animating
            if (this._prevPos < 0) {
                this._goto(this.currentFrame);
            }
            return;
        }
        var seconds = tickerDeltaTime / SharedTicker.speed / PIXI.settings.TARGET_FPMS / 1000;
        this.advance(seconds);
    };

    MovieClip.prototype._onRemoved = function _onRemoved() {
        SharedTicker.remove(this._tickListener);
    };

    /**
     * Returns an array of objects with label and position (aka frame) properties, sorted by position.
     * @name PIXI.animate.MovieClip#labels
     * @type {Array}
     * @readonly
     */


    /**
     * Extend the timeline to the last frame.
     * @method PIXI.animate.MovieClip#_autoExtend
     * @private
     * @param {int} endFrame
     */
    MovieClip.prototype._autoExtend = function _autoExtend(endFrame) {
        if (this._totalFrames < endFrame) {
            this._totalFrames = endFrame;
        }
    };

    /**
     * Convert values of properties
     * @method PIXI.animate.MovieClip#_parseProperties
     * @private
     * @param {Object} properties
     */


    MovieClip.prototype._parseProperties = function _parseProperties(properties) {
        // Convert any string colors to uints
        if (typeof properties.t === 'string') {
            properties.t = _utils2.default.hexToUint(properties.t);
        } else if (typeof properties.v === 'number') {
            properties.v = !!properties.v;
        }
    };

    /**
     * Get a timeline for a child, synced timeline.
     * @method PIXI.animate.MovieClip#_getChildTimeline
     * @private
     * @param {PIXI.animate.MovieClip} instance
     * @return {PIXI.animate.Timeline}
     */


    MovieClip.prototype._getChildTimeline = function _getChildTimeline(instance) {
        for (var i = this._timelines.length - 1; i >= 0; --i) {
            if (this._timelines[i].target === instance) {
                return this._timelines[i];
            }
        }
        var timeline = new _Timeline2.default(instance);
        this._timelines.push(timeline);
        return timeline;
    };

    /**
     * Add mask or masks
     * @method PIXI.animate.MovieClip#addTimedMask
     * @param {PIXI.DisplayObject} instance Instance to mask
     * @param {Object} keyframes The map of frames to mask objects
     * @return {PIXI.animate.MovieClip} instance of clip for chaining
     */


    MovieClip.prototype.addTimedMask = function addTimedMask(instance, keyframes) {
        for (var i in keyframes) {
            this.addKeyframe(instance, {
                m: keyframes[i]
            }, parseInt(i, 10));
        }

        // Set the initial position/add
        this._setTimelinePosition(this.currentFrame, this.currentFrame, true);
        return this;
    };

    /**
     * Shortcut alias for `addTimedMask`
     * @method PIXI.animate.MovieClip#am
     * @param {PIXI.DisplayObject} instance Instance to mask
     * @param {Object} keyframes The map of frames to mask objects
     * @return {PIXI.animate.MovieClip} instance of clip for chaining
     */


    MovieClip.prototype.am = function am(instance, keyframes) {
        return this.addTimedMask(instance, keyframes);
    };

    /**
     * Add a tween to the clip
     * @method PIXI.animate.MovieClip#addTween
     * @param {PIXI.DisplayObject} instance The clip to tween
     * @param {Object} properties The property or property to tween
     * @param {int} startFrame The frame to start tweening
     * @param {int} [duration=0] Number of frames to tween. If 0, then the properties are set
     *                           with no tweening.
     * @param {Function} [ease] An optional easing function that takes the tween time from 0-1.
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.addTween = function addTween(instance, properties, startFrame, duration, ease) {

        var timeline = this._getChildTimeline(instance);
        this._parseProperties(properties);
        timeline.addTween(properties, startFrame, duration, ease);
        this._autoExtend(startFrame + duration);
        return this;
    };

    /**
     * Add a tween to the clip
     * @method PIXI.animate.MovieClip#addKeyframe
     * @param {PIXI.DisplayObject} instance The clip to tween
     * @param {Object} properties The property or property to tween
     * @param {int} startFrame The frame to start tweening
     * @param {int} [duration=0] Number of frames to tween. If 0, then the properties are set
     *                           with no tweening.
     * @param {Function} [ease] An optional easing function that takes the tween time from 0-1.
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.addKeyframe = function addKeyframe(instance, properties, startFrame) {

        var timeline = this._getChildTimeline(instance);
        this._parseProperties(properties);
        timeline.addKeyframe(properties, startFrame);
        this._autoExtend(startFrame);
        return this;
    };

    /**
     * Alias for method `addTimedChild`
     * @method PIXI.animate.MovieClip#at
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.at = function at(instance, startFrame, duration, keyframes) {
        return this.addTimedChild(instance, startFrame, duration, keyframes);
    };

    /**
     * Add a child to show for a certain number of frames before automatic removal.
     * @method PIXI.animate.MovieClip#addTimedChild
     * @param {PIXI.DisplayObject} instance The clip to show
     * @param {int} startFrame The starting frame
     * @param {int} [duration=1] The number of frames to display the child before removing it.
     * @param {String|Array} [keyframes] The collection of static keyframes to add
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.addTimedChild = function addTimedChild(instance, startFrame, duration, keyframes) {

        if (startFrame === undefined) // jshint ignore:line
            {
                startFrame = 0;
            }
        if (duration === undefined || duration < 1) // jshint ignore:line
            {
                duration = this._totalFrames || 1;
            }

        // Add the starting offset for synced movie clips
        if (instance.mode === MovieClip.SYNCHED) {
            instance.parentStartPosition = startFrame;
        }

        //add tweening info about this child's presence on stage
        //when the child is (re)added, if it has 'autoReset' set to true, then it
        //should be set back to frame 0
        var timeline = void 0,
            i = void 0;
        //get existing timeline
        for (i = this._timedChildTimelines.length - 1; i >= 0; --i) {
            if (this._timedChildTimelines[i].target === instance) {
                timeline = this._timedChildTimelines[i];
                break;
            }
        }
        //if there wasn't one, make a new one
        if (!timeline) {
            timeline = [];
            timeline.target = instance;
            this._timedChildTimelines.push(timeline);
        }

        // Fill the timeline with keyframe booleans
        _utils2.default.fillFrames(timeline, startFrame, duration);

        // Update the total frames if the instance extends our current
        // total frames for this movieclip
        if (this._totalFrames < startFrame + duration) {
            this._totalFrames = startFrame + duration;
        }

        // Add the collection of keyframes
        if (keyframes) {
            if (typeof keyframes === "string") {
                keyframes = _utils2.default.deserializeKeyframes(keyframes);
            }
            // Convert the keyframes object into
            // individual properties
            var lastFrame = {};
            for (var _i in keyframes) {
                lastFrame = Object.assign({}, lastFrame, keyframes[_i]);
                this.addKeyframe(instance, lastFrame, parseInt(_i, 10));
            }
            this._getChildTimeline(instance).extendLastFrame(startFrame + duration);
        }

        // Set the initial position/add
        this._setTimelinePosition(startFrame, this.currentFrame, true);

        return this;
    };

    /**
     * Short cut for `addAction`
     * @method PIXI.animate.MovieClip#aa
     * @param {Function} callback The clip call on a certain frame
     * @param {int|String} startFrame The starting frame index or label
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.aa = function aa(callback, startFrame) {
        return this.addAction(callback, startFrame);
    };

    /**
     * Handle frame actions, callback is bound to the instance of the MovieClip.
     * @method PIXI.animate.MovieClip#addAction
     * @param {Function} callback The clip call on a certain frame
     * @param {int|String} startFrame The starting frame index or label
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.addAction = function addAction(callback, startFrame) {

        if (typeof startFrame === 'string') {
            var index = this._labelDict[startFrame];
            if (index === undefined) {
                throw 'The label \'' + startFrame + '\' does not exist on this timeline';
            }
            startFrame = index;
        }

        var actions = this._actions;
        //ensure that the movieclip timeline is long enough to support the target frame
        if (actions.length <= startFrame) {
            actions.length = startFrame + 1;
        }
        if (this._totalFrames < startFrame) {
            this._totalFrames = startFrame;
        }
        //add the action
        if (actions[startFrame]) {
            actions[startFrame].push(callback);
        } else {
            actions[startFrame] = [callback];
        }
        return this;
    };

    /**
     * Short cut for `playSound`
     * @method PIXI.animate.MovieClip#ps
     * @param {String} alias The name of the Sound
     * @param {Boolean} [loop=false] The loop property of the sound
     * @param {MovieClip} context The MovieClip the sound originates from
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.ps = function ps(alias, loop) {
        return this.playSound(alias, loop);
    };

    /**
     * Handle sounds.
     * @method PIXI.animate.MovieClip#playSound
     * @param {String} alias The name of the Sound
     * @param {Boolean} [loop=false] The loop property of the sound
     * @param {MovieClip} context The MovieClip the sound originates from
     * @return {PIXI.animate.MovieClip}
     */


    MovieClip.prototype.playSound = function playSound(alias, loop) {
        PIXI.animate.sound.emit('play', alias, !!loop, this);
        return this;
    };

    /**
     * Sets paused to false.
     * @method PIXI.animate.MovieClip#play
     */


    MovieClip.prototype.play = function play() {
        this.paused = false;
    };

    /**
     * Sets paused to true.
     * @method PIXI.animate.MovieClip#stop
     */


    MovieClip.prototype.stop = function stop() {
        this.paused = true;
    };

    /**
     * Advances this movie clip to the specified position or label and sets paused to false.
     * @method PIXI.animate.MovieClip#gotoAndPlay
     * @param {String|Number} positionOrLabel The animation name or frame number to go to.
     */


    MovieClip.prototype.gotoAndPlay = function gotoAndPlay(positionOrLabel) {
        this.paused = false;
        this._goto(positionOrLabel);
    };

    /**
     * Advances this movie clip to the specified position or label and sets paused to true.
     * @method PIXI.animate.MovieClip#gotoAndStop
     * @param {String|Number} positionOrLabel The animation or frame name to go to.
     */


    MovieClip.prototype.gotoAndStop = function gotoAndStop(positionOrLabel) {
        this.paused = true;
        this._goto(positionOrLabel);
    };

    /**
     * Get the close parent with a valid framerate. If no parent, returns the default framerate.
     * @name PIXI.animate.MovieClip#parentFramerate
     * @type {Number}
     * @readOnly
     */


    /**
     * Advances the playhead. This occurs automatically each tick by default.
     * @method PIXI.animate.MovieClip#advance
     * @param [time] {Number} The amount of time in seconds to advance by. Only applicable if framerate is set.
     */
    MovieClip.prototype.advance = function advance(time) {

        // Handle any other cases where starting to play
        // and no framerate has been set yet
        if (!this._framerate) {
            this.framerate = this.parentFramerate;
        }

        if (time) {
            this._t += time;
        }
        if (this._t > this._duration) {
            this._t = this.loop ? this._t - this._duration : this._duration;
        }
        //add a tiny amount to account for potential floating point errors
        this.currentFrame = Math.floor(this._t * this._framerate + 0.00000001);
        //final error checking
        if (this.currentFrame >= this._totalFrames) {
            this.currentFrame = this._totalFrames - 1;
        }
        var afterUpdateOnce = void 0;
        if (this._beforeUpdate) {
            afterUpdateOnce = this._beforeUpdate(this);
        }
        //update all tweens & actions in the timeline
        this._updateTimeline();

        // Do the animator callback here
        if (afterUpdateOnce) {
            afterUpdateOnce();
        }
    };

    /**
     * @method PIXI.animate.MovieClip#_goto
     * @param {String|Number} positionOrLabel The animation name or frame number to go to.
     * @protected
     */


    MovieClip.prototype._goto = function _goto(positionOrLabel) {
        var pos = typeof positionOrLabel === 'string' ? this._labelDict[positionOrLabel] : positionOrLabel;
        if (pos === undefined) // jshint ignore:line
            {
                return;
            }
        // prevent _updateTimeline from overwriting the new position because of a reset:
        this._prevPos = NaN;
        this.currentFrame = pos;

        // Handle the case where trying to play but haven't
        // added to the stage yet
        if (!this._framerate) {
            this.framerate = this.parentFramerate;
        }

        //update the elapsed time if a time based movieclip
        if (this._framerate > 0) {
            this._t = pos / this._framerate;
        } else {
            this._t = 0;
        }
        this._updateTimeline();
    };

    /**
     * @method PIXI.animate.MovieClip#_reset
     * @private
     */


    MovieClip.prototype._reset = function _reset() {
        this._prevPos = -1;
        this._t = 0;
        this.currentFrame = 0;
    };

    /**
     * @method PIXI.animate.MovieClip#_updateTimeline
     * @protected
     */


    MovieClip.prototype._updateTimeline = function _updateTimeline() {
        var synched = this.mode !== MovieClip.INDEPENDENT;

        if (synched) {
            this.currentFrame = this.startPosition + (this.mode === MovieClip.SINGLE_FRAME ? 0 : this._synchOffset);
            if (this.currentFrame >= this._totalFrames) {
                this.currentFrame %= this._totalFrames;
            }
        }

        if (this._prevPos === this.currentFrame) {
            return;
        }

        // update timeline position, ignoring actions if this is a graphic.
        this._setTimelinePosition(this._prevPos, this.currentFrame, synched ? false : this.actionsEnabled);

        this._prevPos = this.currentFrame;
    };

    /**
     * Set the timeline position
     * @method PIXI.animate.MovieClip#_setTimelinePosition
     * @protected
     * @param {int} startFrame
     * @param {int} currentFrame
     * @param {Boolean} doActions
     */


    MovieClip.prototype._setTimelinePosition = function _setTimelinePosition(startFrame, currentFrame, doActions) {
        //handle all tweens
        var i = void 0,
            j = void 0,
            length = void 0,
            _timelines = this._timelines;
        for (i = _timelines.length - 1; i >= 0; --i) {
            var timeline = _timelines[i];
            for (j = 0, length = timeline.length; j < length; ++j) {
                var tween = timeline[j];
                //if the tween contains part of the timeline that we are travelling through
                if (currentFrame >= tween.startFrame && currentFrame <= tween.endFrame) {
                    // set the position within that tween
                    //and break the loop to move onto the next timeline
                    tween.setPosition(currentFrame);
                    break;
                }
            }
        }

        var timedChildTimelines = this._timedChildTimelines;
        var depthSorted = this._depthSorted;
        for (i = 0, length = timedChildTimelines.length; i < length; ++i) {
            var target = timedChildTimelines[i].target;
            var shouldBeChild = timedChildTimelines[i][currentFrame];
            //if child should be on stage and is not:
            if (shouldBeChild) {
                // Add to the depthSorted object so we can
                // check that items are property drawn later
                depthSorted.push(target);
                if (target.parent !== this) {
                    // add the target if it's not there already
                    this.addChild(target);
                    if (target.mode === MovieClip.INDEPENDENT && target.autoReset) {
                        target._reset();
                    }
                }
            } else if (!shouldBeChild && target.parent === this) {
                this.removeChild(target);
            }
        }

        // Properly depth sort the children
        for (i = 0, length = depthSorted.length; i < length; i++) {
            var _target = depthSorted[i];
            var currentIndex = this.children.indexOf(_target);
            if (currentIndex !== i) {
                this.addChildAt(_target, i);
            }
        }

        // Clear the temporary depth sorting array
        depthSorted.length = 0;

        //go through all children and update synched movieclips that are not single frames
        var children = this.children,
            child = void 0;
        for (i = 0, length = children.length; i < length; ++i) {
            child = children[i];
            if (child.mode === MovieClip.SYNCHED) {
                child._synchOffset = currentFrame - child.parentStartPosition;
                child._updateTimeline();
            }
        }

        //handle actions
        if (doActions) {
            var actions = this._actions;
            //handle looping around
            var needsLoop = false;
            if (currentFrame < startFrame) {
                length = actions.length;
                needsLoop = true;
            } else {
                length = Math.min(currentFrame + 1, actions.length);
            }
            for (i = startFrame >= 0 ? startFrame + 1 : currentFrame; i < length; ++i) {
                if (actions[i]) {
                    var frameActions = actions[i];
                    for (j = 0; j < frameActions.length; ++j) {
                        frameActions[j].call(this);
                    }
                }
                //handle looping around
                if (needsLoop && i === length - 1) {
                    i = 0;
                    length = currentFrame + 1;
                    needsLoop = false;
                }
            }
        }
    };

    MovieClip.prototype.destroy = function destroy(destroyChildren) {
        if (this._tickListener) {
            SharedTicker.remove(this._tickListener);
            this._tickListener = null;
        }
        var hiddenChildren = [];
        var timelines = this._timelines;
        if (timelines) {
            for (var i = 0; i < timelines.length; i++) {
                var timeline = timelines[i];
                hiddenChildren.push(timeline.target);
                timeline._currentProps = null;
                timeline.length = 0;
            }
        }
        timelines = this._timedChildTimelines;
        if (timelines) {
            for (var _i2 = 0; _i2 < timelines.length; _i2++) {
                var _timeline = timelines[_i2];
                if (hiddenChildren.indexOf(_timeline.target) < 0) {
                    hiddenChildren.push(_timeline.target);
                }
                _timeline._currentProps = null;
                _timeline.length = 0;
            }
        }
        // Destroy all the children
        for (var _i3 = 0; _i3 < hiddenChildren.length; _i3++) {
            // Don't destroy children in the display list
            if (this.children.indexOf(hiddenChildren[_i3]) < 0) {
                hiddenChildren[_i3].destroy(destroyChildren);
            }
        }
        hiddenChildren.length = 0;
        this._actions = null;
        this._timelines = null;
        this._depthSorted = null;
        this._timedChildTimelines = null;
        this._beforeUpdate = null;
        this._labels = null;
        this._labelDict = null;
        _Container.prototype.destroy.call(this, destroyChildren);
    };

    _createClass(MovieClip, [{
        key: 'labels',
        get: function get() {
            return this._labels;
        }

        /**
         * Returns a dictionary of labels where key is the label and value is the frame.
         * @name PIXI.animate.MovieClip#labelsMap
         * @type {Object}
         * @readonly
         */

    }, {
        key: 'labelsMap',
        get: function get() {
            return this._labelDict;
        }

        /**
         * Returns the name of the label on or immediately before the current frame.
         * @name PIXI.animate.MovieClip#currentLabel
         * @type {String}
         * @readonly
         */

    }, {
        key: 'currentLabel',
        get: function get() {
            var labels = this._labels;
            var current = null;
            for (var i = 0, len = labels.length; i < len; ++i) {
                if (labels[i].position <= this.currentFrame) {
                    current = labels[i].label;
                } else {
                    break;
                }
            }
            return current;
        }

        /**
         * When the MovieClip is framerate independent, this is the time elapsed from frame 0 in seconds.
         * @name PIXI.animate.MovieClip#elapsedTime
         * @type Number
         * @default 0
         * @public
         */

    }, {
        key: 'elapsedTime',
        get: function get() {
            return this._t;
        },
        set: function set(value) {
            this._t = value;
        }

        /**
         * By default MovieClip instances advance one frame per tick. Specifying a framerate for the MovieClip
         * will cause it to advance based on elapsed time between ticks as appropriate to maintain the target
         * framerate.
         *
         * For example, if a MovieClip with a framerate of 10 is placed on a Stage being updated at 40fps, then the MovieClip will
         * advance roughly one frame every 4 ticks. This will not be exact, because the time between each tick will
         * vary slightly between frames.
         *
         * This feature is dependent on the tick event object (or an object with an appropriate 'delta' property) being
         * passed into {{#crossLink 'Stage/update'}}{{/crossLink}}.
         * @name PIXI.animate.MovieClip#framerate
         * @type {Number}
         * @default 0
         */

    }, {
        key: 'framerate',
        get: function get() {
            return this._framerate;
        },
        set: function set(value) {
            if (value > 0) {
                this._framerate = value;
                this._duration = value ? this._totalFrames / value : 0;
                this._t = this.currentFrame / value;
            } else {
                this._t = this._framerate = this._duration = 0;
            }
        }

        /**
         * Get the total number of frames (duration) of this MovieClip
         * @name PIXI.animate.MovieClip#totalFrames
         * @type {Number}
         * @default 0
         * @readOnly
         */

    }, {
        key: 'totalFrames',
        get: function get() {
            return this._totalFrames;
        }
    }, {
        key: 'parentFramerate',
        get: function get() {
            var o = this,
                fps = o._framerate;
            while ((o = o.parent) && !fps) {
                if (o.mode === MovieClip.INDEPENDENT) {
                    fps = o._framerate;
                }
            }
            return fps || MovieClip.DEFAULT_FRAMERATE;
        }
    }]);

    return MovieClip;
}(Container);

/**
 * The MovieClip will advance independently of its parent, even if its parent is paused.
 * This is the default mode.
 * @name PIXI.animate.MovieClip.INDEPENDENT
 * @static
 * @type String
 * @default 0
 * @readonly
 */


MovieClip.INDEPENDENT = 0;

/**
 * The MovieClip will only display a single frame (as determined by the startPosition property).
 * @name PIXI.animate.MovieClip.SINGLE_FRAME
 * @static
 * @type String
 * @default 1
 * @readonly
 */
MovieClip.SINGLE_FRAME = 1;

/**
 * The MovieClip will be advanced only when its parent advances and will be synched to the position of
 * the parent MovieClip.
 * @name PIXI.animate.MovieClip.SYNCHED
 * @static
 * @type String
 * @default 2
 * @readonly
 */
MovieClip.SYNCHED = 2;

/**
 * The default framerate if none is specified or there's not parent clip with a framerate.
 * @name PIXI.animate.MovieClip.DEFAULT_FRAMERATE
 * @static
 * @type Number
 * @default 24
 * @readonly
 */
MovieClip.DEFAULT_FRAMERATE = 24;

/**
 * Extend a container
 * @method PIXI.animate.MovieClip.extend
 * @static
 * @param {PIXI.animate.MovieClip} child The child function
 * @return {PIXI.animate.MovieClip} The child
 */
/**
 * Extend a container (alias for `extend`)
 * @method PIXI.animate.MovieClip.e
 * @static
 * @param {PIXI.animate.MovieClip} child The child function
 * @return {PIXI.animate.MovieClip} The child
 */
MovieClip.extend = MovieClip.e = function (child) {
    child.prototype = Object.create(MovieClip.prototype);
    child.prototype.__parent = MovieClip.prototype;
    child.prototype.constructor = child;
    return child;
};

// Assign to namespace
exports.default = MovieClip;

},{"./Timeline":7,"./utils":12}],4:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _load2 = require('./load');

var _load3 = _interopRequireDefault(_load2);

var _sound = require('./sound');

var _sound2 = _interopRequireDefault(_sound);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Extends the PIXI.Application class to provide easy loading.
 * ```
 * const scene = new PIXI.animate.Scene();
 * scene.load(lib.StageName);
 * ```
 * @class Scene
 * @memberof PIXI.animate
 * @param {Number} [width=800] Stage width
 * @param {Number} [height=600] Stage height
 * @param {Object} [renderOptions] See PIXI.Application for more info.
 * @param {Boolean} [noWebGL=false] Disable WebGL
 */
var Scene = function (_PIXI$Application) {
	_inherits(Scene, _PIXI$Application);

	function Scene(width, height, renderOptions, noWebGL) {
		_classCallCheck(this, Scene);

		/**
   * Reference to the global sound object
   * @name PIXI.animate.Scene#sound
   * @type {PIXI.animate.sound}
   * @readOnly
   */
		var _this = _possibleConstructorReturn(this, _PIXI$Application.call(this, width, height, renderOptions, noWebGL));

		_this.sound = _sound2.default;

		/**
   * The stage object created.
   * @name PIXI.animate.Scene#instance
   * @type {PIXI.animate.MovieClip}
   * @readOnly
   */
		_this.instance = null;
		return _this;
	}

	/**
  * Load a stage scene and add it to the stage.
  * @method PIXI.animate.Scene#load
  * @param {Function} StageRef Reference to the stage class.
  * @param {Function} [complete] Callback when finished loading.
  * @param {String} [basePath] Optional base directory to prepend to assets.
  * @return {PIXI.loaders.Loader} instance of PIXI resource loader
  */


	Scene.prototype.load = function load(StageRef, complete, basePath) {
		var _this2 = this;

		return (0, _load3.default)(StageRef, this.stage, function (instance) {
			_this2.instance = instance;
			if (complete) {
				complete(instance);
			}
		}, basePath);
	};

	/**
  * Destroy and don't use after calling.
  * @method PIXI.animate.Scene#destroy
  * @param {Boolean} [removeView=false] `true` to remove canvas element.
  */


	Scene.prototype.destroy = function destroy(removeView) {
		if (this.instance) {
			this.instance.destroy(true);
			this.instance = null;
		}
		_PIXI$Application.prototype.destroy.call(this, removeView);
	};

	return Scene;
}(PIXI.Application);

exports.default = Scene;

},{"./load":10,"./sound":11}],5:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _utils = require('./utils');

var _utils2 = _interopRequireDefault(_utils);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Contains the collection of graphics data
 * @memberof PIXI.animate
 * @class ShapesCache
 */
var ShapesCache = {};

/**
 * Add an item or itesm to the cache
 * @method PIXI.animate.ShapesCache.add
 * @static
 * @param {String} prop  The id of graphic or the map of graphics to add
 * @param {String|Array<Array>} items Collection of draw commands
 */
Object.defineProperty(ShapesCache, 'add', {
    enumerable: false,
    value: function value(prop, items) {

        // Decode string to map of files
        if (typeof items === "string") {
            items = _utils2.default.deserializeShapes(items);
        }

        // Convert all hex string colors (animate) to int (pixi.js)
        for (var i = 0; i < items.length; i++) {
            var item = items[i];
            for (var j = 0; j < item.length; j++) {
                var arg = item[j];
                if (typeof arg === 'string' && arg[0] === '#') {
                    item[j] = _utils2.default.hexToUint(arg);
                }
            }
        }
        ShapesCache[prop] = items;
    }
});

/**
 * Get the graphic from cache
 * @method  PIXI.animate.ShapesCache.fromCache
 * @static
 * @param  {String} id The cache id
 * @return {Array} Series of graphic draw commands
 */
Object.defineProperty(ShapesCache, 'fromCache', {
    enumerable: false,
    value: function value(id) {
        return ShapesCache[id] || null;
    }
});

/**
 * Remove the graphic from cache
 * @method  PIXI.animate.ShapesCache.remove
 * @static
 * @param  {String|Object} id The cache id or map
 */
Object.defineProperty(ShapesCache, 'remove', {
    enumerable: false,
    value: function value(id) {
        if ((typeof id === 'undefined' ? 'undefined' : _typeof(id)) === "object") {
            for (var name in id) {
                ShapesCache.remove(name);
            }
            return;
        }
        if (ShapesCache[id]) {
            ShapesCache[id].length = 0;
            delete ShapesCache[id];
        }
    }
});

/**
 * Remove all graphics from cache
 * @method  PIXI.animate.ShapesCache.removeAll
 * @static
 */
Object.defineProperty(ShapesCache, 'removeAll', {
    enumerable: false,
    value: function value() {
        for (var id in ShapesCache) {
            ShapesCache.remove(id);
        }
    }
});

// Assign to namespace
exports.default = ShapesCache;

},{"./utils":12}],6:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _ShapesCache = require('./ShapesCache');

var _ShapesCache2 = _interopRequireDefault(_ShapesCache);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * The middleware for PIXI's ResourceLoader to be able to 
 * load Flash symbols such as graphics and images.
 * @memberof PIXI.animate
 * @class SymbolLoader
 * @private
 */
var SymbolLoader = function SymbolLoader() {
    return function (resource, next) {
        var url = resource.url;
        var data = resource.data;

        if (!data) {
            next();
        } else if (url.search(/\.shapes\.(json|txt)$/i) > -1) {
            _ShapesCache2.default.add(resource.name, data);
        } else if (data.nodeName && data.nodeName === 'IMG') {
            // Add individual images to the texture cache by their
            // short symbol name, not the URL
            PIXI.Texture.addTextureToCache(resource.texture, resource.name);
        }
        next();
    };
};

// Assign to the loader
PIXI.loaders.Loader.addPixiMiddleware(SymbolLoader);

exports.default = SymbolLoader;

},{"./ShapesCache":5}],7:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _Tween = require('./Tween');

var _Tween2 = _interopRequireDefault(_Tween);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * The Timeline class represents a
 * @memberof PIXI.animate
 * @class Timeline
 * @param {PIXI.DisplayObject} Target The target for this string of tweens.
 * @extends Array
 * @constructor
 */
var Timeline = function Timeline(target) {
    Array.call(this);

    /**
     * The target DisplayObject.
     * @name PIXI.animate.Timeline#target
     * @type {PIXI.DisplayObject}
     */
    this.target = target;

    /**
     * Current properties in the tween, to make building the timeline more
     * efficient.
     * @name PIXI.animate.Timeline#_currentProps
     * @type {Object}
     * @private
     */
    this._currentProps = {};
};

var p = Timeline.prototype = Object.create(Array.prototype);

/**
 * Adds one or more tweens (or timelines) to this timeline. The tweens will be paused (to remove them from the normal ticking system)
 * and managed by this timeline. Adding a tween to multiple timelines will result in unexpected behaviour.
 * @method PIXI.animate.Timeline#addTween
 * @param tween The tween(s) to add. Accepts multiple arguments.
 * @return Tween The first tween that was passed in.
 */
p.addTween = function (properties, startFrame, duration, ease) {
    this.extendLastFrame(startFrame - 1);
    //ownership of startProps is passed to the new Tween - this object should not be reused
    var startProps = {};
    var prop = void 0;
    //figure out what the starting values for this tween should be
    for (prop in properties) {
        //if we have already set that property in an earlier tween, use the ending value
        if (this._currentProps.hasOwnProperty(prop)) {
            startProps[prop] = this._currentProps[prop];
        }
        //otherwise, get the current value
        else {
                var startValue = startProps[prop] = this.getPropFromShorthand(prop);
                //go through previous tweens to set the value so that when the timeline loops
                //around, the values are set properly - having each tween know what came before
                //allows us to set to a specific frame without running through the entire timeline
                for (var i = this.length - 1; i >= 0; --i) {
                    this[i].startProps[prop] = startValue;
                    this[i].endProps[prop] = startValue;
                }
            }
    }
    //create the new Tween and add it to the list
    var tween = new _Tween2.default(this.target, startProps, properties, startFrame, duration, ease);
    this.push(tween);
    //update starting values for the next tween - if tweened values included 'p', then Tween
    //parsed that to add additional data that is required
    Object.assign(this._currentProps, tween.endProps);
};

/**
 * Add a single keyframe that doesn't tween.
 * @method PIXI.animate.Timeline#addKeyframe
 * @param {Object} properties The properties to set.
 * @param {int} startFrame The starting frame index.
 */
p.addKeyframe = function (properties, startFrame) {
    this.extendLastFrame(startFrame - 1);
    var startProps = Object.assign({}, this._currentProps, properties);
    //create the new Tween and add it to the list
    var tween = new _Tween2.default(this.target, startProps, null, startFrame, 0);
    this.push(tween);
    Object.assign(this._currentProps, tween.endProps);
};

/**
 * Extend the last frame of the tween.
 * @method PIXI.animate.Timeline#extendLastFrame
 * @param {int} endFrame The ending frame index.
 */
p.extendLastFrame = function (endFrame) {
    if (this.length) {
        var prevTween = this[this.length - 1];
        if (prevTween.endFrame < endFrame) {
            if (prevTween.isTweenlessFrame) {
                prevTween.endFrame = endFrame;
            } else {
                this.addKeyframe(this._currentProps, prevTween.endFrame + 1, endFrame - prevTween.endFrame + 1);
            }
        }
    }
};

/**
 * Get the value for a property
 * @method PIXI.animate.Timeline#getPropFromShorthand
 * @param {string} prop
 */
p.getPropFromShorthand = function (prop) {
    var target = this.target;
    switch (prop) {
        case 'x':
            return target.position.x;
        case 'y':
            return target.position.y;
        case 'sx':
            return target.scale.x;
        case 'sy':
            return target.scale.y;
        case 'kx':
            return target.skew.x;
        case 'ky':
            return target.skew.y;
        case 'r':
            return target.rotation;
        case 'a':
            return target.alpha;
        case 'v':
            return target.visible;
        case 'm':
            return target.mask;
        // case 't':
        //   return target.tint;
        //not sure if we'll actually handle graphics this way?
        //g: return null;
    }
    return null;
};

// Assign to namespace
exports.default = Timeline;

},{"./Tween":8}],8:[function(require,module,exports){
"use strict";

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Provide timeline playback of movieclip
 * @memberof PIXI.animate
 * @class Tween
 * @constructor
 * @param {PIXI.animate.MovieClip} target The target to play
 * @param {Object} startProps The starting properties
 * @param {Object} endProps The ending properties
 * @param {int} duration Number oframes to tween
 * @param {Function} [ease] Ease function to use
 */

var Tween = function () {
    function Tween(target, startProps, endProps, startFrame, duration, ease) {
        _classCallCheck(this, Tween);

        /**
         * target display object
         * @name PIXI.animate.Tween#target
         * @type {Object}
         */
        this.target = target;

        /**
         * properties at the start of the tween
         * @type {Object}
         * @name PIXI.animate.Tween#startProps
         */
        this.startProps = startProps;

        /**
         * properties at the end of the tween, as well as any properties that are set
         * instead of tweened
         * @type {Object}
         * @name PIXI.animate.Tween#endProps
         */
        this.endProps = {};

        /**
         * duration of tween in frames. For a keyframe with no tweening, the duration will be 0.
         * @type {int}
         * @name PIXI.animate.Tween#duration
         */
        this.duration = duration;

        /**
         * The frame that the tween starts on
         * @type {int}
         * @name PIXI.animate.Tween#startFrame
         */
        this.startFrame = startFrame;

        /**
         * the frame that the tween ends on
         * @type {int}
         * @name PIXI.animate.Tween#endFrame
         */
        this.endFrame = startFrame + duration;

        /**
         * easing function to use, if any
         * @type {Function}
         * @name PIXI.animate.Tween#ease
         */
        this.ease = ease;

        /**
         * If we don't tween.
         * @type {Boolean}
         * @name PIXI.animate.Tween#isTweenlessFrame
         */
        this.isTweenlessFrame = !endProps;

        var prop = void 0;
        if (endProps) {
            //make a copy to safely include any unchanged values from the start of the tween
            for (prop in endProps) {
                this.endProps[prop] = endProps[prop];
            }
        }

        //copy in any starting properties don't change
        for (prop in startProps) {
            if (!this.endProps.hasOwnProperty(prop)) {
                this.endProps[prop] = startProps[prop];
            }
        }
    }

    /**
     * Set the current frame.
     * @method PIXI.animate.Tween#setPosition
     * @param {int} currentFrame
     */


    Tween.prototype.setPosition = function setPosition(currentFrame) {
        //if this is a single frame with no tweening, or at the end of the tween, then
        //just speed up the process by setting values
        if (currentFrame >= this.endFrame) {
            this.setToEnd();
            return;
        }

        if (this.isTweenlessFrame) {
            this.setToEnd();
            return;
        }

        var time = (currentFrame - this.startFrame) / this.duration;
        if (this.ease) {
            time = this.ease(time);
        }
        var target = this.target;
        var startProps = this.startProps;
        var endProps = this.endProps;
        for (var _prop in endProps) {
            var lerp = props[_prop];
            if (lerp) {
                setPropFromShorthand(target, _prop, lerp(startProps[_prop], endProps[_prop], time));
            } else {
                setPropFromShorthand(target, _prop, startProps[_prop]);
            }
        }
    };

    /**
     * Set to the end position
     * @method PIXI.animate.Tween#setToEnd
     */


    Tween.prototype.setToEnd = function setToEnd() {
        var endProps = this.endProps;
        var target = this.target;
        for (var _prop2 in endProps) {
            setPropFromShorthand(target, _prop2, endProps[_prop2]);
        }
    };

    return Tween;
}();

//standard tweening


function lerpValue(start, end, t) {
    return start + (end - start) * t;
}

var props = {
    //position
    x: lerpValue,
    y: lerpValue,
    //scale
    sx: lerpValue,
    sy: lerpValue,
    //skew
    kx: lerpValue,
    ky: lerpValue,
    //rotation
    r: lerpRotation,
    //alpha
    a: lerpValue,
    //tinting
    // t: lerpColor,
    t: null,
    //values to be set
    v: null, //visible
    c: null, //colorTransform
    m: null, //mask
    g: null //not sure if we'll actually handle graphics this way?
};

//split r, g, b into separate values for tweening
/*function lerpColor(start, end, t)
{
    //split start color into components
    let sR = start >> 16 & 0xFF;
    let sG = start >> 8 & 0xFF;
    let sB = start & 0xFF;
    //split end color into components
    let eR = end >> 16 & 0xFF;
    let eG = end >> 8 & 0xFF;
    let eB = end & 0xFF;
    //lerp red
    let r = sR + (eR - sR) * percent;
    //clamp red to valid values
    if (r < 0)
        r = 0;
    else if (r > 255)
        r = 255;
    //lerp green
    let g = sG + (eG - sG) * percent;
    //clamp green to valid values
    if (g < 0)
        g = 0;
    else if (g > 255)
        g = 255;
    //lerp blue
    let b = sB + (eB - sB) * percent;
    //clamp blue to valid values
    if (b < 0)
        b = 0;
    else if (b > 255)
        b = 255;

    let combined = (r << 16) | (g << 8) | b;
    return combined;
}*/

var PI = Math.PI;
var TWO_PI = PI * 2;

//handle 355 -> 5 degrees only going through a 10 degree change instead of
//the long way around
//Math from http://stackoverflow.com/a/2708740
function lerpRotation(start, end, t) {
    var difference = Math.abs(end - start);
    if (difference > PI) {
        // We need to add on to one of the values.
        if (end > start) {
            // We'll add it on to start...
            start += TWO_PI;
        } else {
            // Add it on to end.
            end += PI + TWO_PI;
        }
    }

    // Interpolate it.
    var value = start + (end - start) * t;

    // wrap to 0-2PI
    /*if (value >= 0 && value <= TWO_PI)
        return value;
    return value % TWO_PI;*/

    //just return, as it's faster
    return value;
}

function setPropFromShorthand(target, prop, value) {
    switch (prop) {
        case "x":
            target.transform.position.x = value;
            break;
        case "y":
            target.transform.position.y = value;
            break;
        case "sx":
            target.transform.scale.x = value;
            break;
        case "sy":
            target.transform.scale.y = value;
            break;
        case "kx":
            target.transform.skew.x = value;
            break;
        case "ky":
            target.transform.skew.y = value;
            break;
        case "r":
            target.transform.rotation = value;
            break;
        case "a":
            target.alpha = value;
            break;
        case "t":
            target.i(value); // i = setTint
            break;
        case "c":
            target.c.apply(target, value); // c = setColorTransform
            break;
        case "v":
            target.visible = value;
            break;
        case "m":
            target.ma(value); // ma = setMask
            break;
    }
}

// Assign to namespace
exports.default = Tween;

},{}],9:[function(require,module,exports){
'use strict';

exports.__esModule = true;
exports.VERSION = exports.Tween = exports.Timeline = exports.SymbolLoader = exports.ShapesCache = exports.Scene = exports.MovieClip = exports.utils = exports.sound = exports.load = exports.AnimatorTimeline = exports.Animator = undefined;

var _load = require('./load');

var _load2 = _interopRequireDefault(_load);

var _sound = require('./sound');

var _sound2 = _interopRequireDefault(_sound);

var _utils = require('./utils');

var _utils2 = _interopRequireDefault(_utils);

var _MovieClip = require('./MovieClip');

var _MovieClip2 = _interopRequireDefault(_MovieClip);

var _Scene = require('./Scene');

var _Scene2 = _interopRequireDefault(_Scene);

var _ShapesCache = require('./ShapesCache');

var _ShapesCache2 = _interopRequireDefault(_ShapesCache);

var _SymbolLoader = require('./SymbolLoader');

var _SymbolLoader2 = _interopRequireDefault(_SymbolLoader);

var _Timeline = require('./Timeline');

var _Timeline2 = _interopRequireDefault(_Timeline);

var _Tween = require('./Tween');

var _Tween2 = _interopRequireDefault(_Tween);

var _Animator = require('./Animator');

var _Animator2 = _interopRequireDefault(_Animator);

var _AnimatorTimeline = require('./AnimatorTimeline');

var _AnimatorTimeline2 = _interopRequireDefault(_AnimatorTimeline);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var VERSION = '1.3.3';

/**
 * @namespace PIXI.animate
 */
exports.Animator = _Animator2.default;
exports.AnimatorTimeline = _AnimatorTimeline2.default;
exports.load = _load2.default;
exports.sound = _sound2.default;
exports.utils = _utils2.default;
exports.MovieClip = _MovieClip2.default;
exports.Scene = _Scene2.default;
exports.ShapesCache = _ShapesCache2.default;
exports.SymbolLoader = _SymbolLoader2.default;
exports.Timeline = _Timeline2.default;
exports.Tween = _Tween2.default;
exports.VERSION = VERSION;

},{"./Animator":1,"./AnimatorTimeline":2,"./MovieClip":3,"./Scene":4,"./ShapesCache":5,"./SymbolLoader":6,"./Timeline":7,"./Tween":8,"./load":10,"./sound":11,"./utils":12}],10:[function(require,module,exports){
"use strict";

exports.__esModule = true;
/**
 * Load the stage class and preload any assets
 * @method PIXI.animate.load
 * @param {Object} options Options for loading.
 * @param {Function} options.stage Reference to the stage class
 * @param {Object} [options.stage.assets] Assets used to preload
 * @param {PIXI.Container} options.parent The Container to auto-add the stage to.
 * @param {String} [options.basePath] Base root directory
 * @return {PIXI.loaders.Loader} instance of PIXI resource loader
 */
/**
 * Load the stage class and preload any assets
 * ```
 * let renderer = new PIXI.autoDetectRenderer(1280, 720);
 * let stage = new PIXI.Container();
 * PIXI.animate.load(lib.MyStage, function(instance){
 *     stage.addChild(instance);
 * });
 * function update() {
 *      renderer.render(stage);
 *      update();
 * }
 * update();
 * ```
 * @method PIXI.animate.load
 * @param {Function} StageRef Reference to the stage class.
 * @param {Object} [StageRef.assets] Assets used to preload.
 * @param {Function} complete The callback function when complete.
 * @return {PIXI.loaders.Loader} instance of PIXI resource loader
 */
/**
 * Load the stage class and preload any assets
 * ```
 * let renderer = new PIXI.autoDetectRenderer(1280, 720);
 * let stage = new PIXI.Container();
 * PIXI.animate.load(lib.MyStage, stage);
 * function update() {
 *      renderer.render(stage);
 *      update();
 * }
 * update();
 * ```
 * @method PIXI.animate.load
 * @param {Function} StageRef Reference to the stage class.
 * @param {Object} [StageRef.assets] Assets used to preload.
 * @param {PIXI.Container} parent The Container to auto-add the stage to.
 * @param {String} [basePath] Base root directory
 * @return {PIXI.loaders.Loader} instance of PIXI resource loader
 */
/**
 * Load the stage class and preload any assets
 * ```
 * let basePath = "file:/path/to/assets";
 * let renderer = new PIXI.autoDetectRenderer(1280, 720);
 * 
 * let extensions = PIXI.compressedTextures.detectExtensions(renderer);
 * let loader = new PIXI.loaders.Loader();
 * // this is an example of setting up a pre loader plugin to handle compressed textures in this case
 * loader.pre(PIXI.compressedTextures.extensionChooser(extensions));
 * 
 * // specify metadata this way if you want to provide a default loading strategy for all assets listed in the PIXI animation
 * let metadata = { default: { metadata: { imageMetadata: { choice: [".crn"] } } } };
 * // specify metadata this way if you want to provide a specific loading strategy for a certain asset listed inside the PIXI animation library
 * let metadata = { MyStage_atlas_1: { metadata: { imageMetadata: { choice: [".crn"] } } } };
 * 
 * let stage = new PIXI.Container();
 * PIXI.animate.load(lib.MyStage, stage, ()=>{}, basePath, loader, metadata);
 * function update() {
 *      renderer.render(stage);
 *      update();
 * }
 * update();
 * ```
 * @method PIXI.animate.load
 * @param {Function} StageRef Reference to the stage class.
 * @param {Object} [StageRef.assets] Assets used to preload.
 * @param {PIXI.Container} parent The Container to auto-add the stage to.
 * @param {Function} [complete] The callback function when complete.
 * @param {String} [basePath] Base root directory
 * @param {PIXI.loaders.Loader} [loader] A Pixi loader object
 * @param {Object} [metadata] A metadata object for the asset being loaded
 * @return {PIXI.loaders.Loader} instance of PIXI resource loader
 */

var load = function load(options, parent, complete, basePath, loader, metadata) {

    // Support arguments (ref, complete, basePath)
    if (typeof parent === "function") {
        basePath = complete;
        complete = parent;
        parent = null;
    } else {
        if (typeof complete === "string") {
            basePath = complete;
            complete = null;
        }
    }

    if (typeof options === "function") {
        options = {
            stage: options,
            parent: parent,
            basePath: basePath || "",
            complete: complete
        };
    }

    options = Object.assign({
        stage: null,
        parent: null,
        basePath: '',
        complete: null
    }, options || {});

    loader = loader || new PIXI.loaders.Loader();

    function done() {
        var instance = new options.stage();
        if (options.parent) {
            options.parent.addChild(instance);
        }
        if (options.complete) {
            options.complete(instance, loader);
        }
    }

    // Check for assets to preload
    var assets = options.stage.assets || {};
    if (assets && Object.keys(assets).length) {
        // assetBaseDir can accept either with trailing slash or not
        var _basePath = options.basePath;
        if (_basePath) {
            _basePath += "/";
        }
        for (var id in assets) {
            var data = null;
            if (metadata) {
                // if the metadata was supplied for this particular asset, use these options
                if (metadata[id]) {
                    data = metadata[id];
                }
                // if the metadata supplied a default option
                else if (metadata.default) {
                        data = metadata.default;
                    }
            }
            loader.add(id, _basePath + assets[id], data);
        }
        loader.once('complete', done).load();
    } else {
        // tiny case where there's only text and no shapes/animations
        done();
    }

    return loader;
};

exports.default = load;

},{}],11:[function(require,module,exports){
"use strict";

exports.__esModule = true;
/**
 * @description Event emitter for all sound events. This emits a single
 * `play` event which contains the alias, loop and MovieClip which is playing
 * the sound.
 * @name PIXI.animate.sound
 * @type {EventEmitter}
 * @example
 * 
 * PIXI.animate.sound.on('play', (alias, loop, context) => {
 *    // custom handle sounds being played
 *    // where 'alias' is the ID in stage assets
 * });
 */
exports.default = new PIXI.utils.EventEmitter();

},{}],12:[function(require,module,exports){
'use strict';

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// If the movieclip plugin is installed
var _prepare = null;

/**
 * @namespace PIXI.animate.utils
 * @description For keyframe conversions
 */

var AnimateUtils = function () {
    function AnimateUtils() {
        _classCallCheck(this, AnimateUtils);
    }

    /**
     * Convert the Hexidecimal string (e.g., "#fff") to uint
     * @static
     * @method PIXI.animate.utils.hexToUint
     */
    AnimateUtils.hexToUint = function hexToUint(hex) {
        // Remove the hash
        hex = hex.substr(1);

        // Convert shortcolors fc9 to ffcc99
        if (hex.length === 3) {
            hex = hex.replace(/([a-f0-9])/g, '$1$1');
        }
        return parseInt(hex, 16);
    };

    /** 
     * Fill frames with booleans of true (showing) and false (hidden).
     * @static
     * @method PIXI.animate.utils.fillFrames
     * @param {Array<Boolean>} timeline
     * @param {int} startFrame The start frame when the timeline shows up
     * @param {int} duration The length of showing
     */


    AnimateUtils.fillFrames = function fillFrames(timeline, startFrame, duration) {
        //ensure that the timeline is long enough
        var oldLength = timeline.length;
        if (oldLength < startFrame + duration) {
            timeline.length = startFrame + duration;
            //fill any gaps with false to denote that the child should be removed for a bit
            if (oldLength < startFrame) {
                //if the browser has implemented the ES6 fill() function, use that
                if (timeline.fill) {
                    timeline.fill(false, oldLength, startFrame);
                } else {
                    //if we can't use fill, then do a for loop to fill it
                    for (var i = oldLength; i < startFrame; ++i) {
                        timeline[i] = false;
                    }
                }
            }
        }
        //if the browser has implemented the ES6 fill() function, use that
        if (timeline.fill) {
            timeline.fill(true, startFrame, startFrame + duration);
        } else {
            var length = timeline.length;
            //if we can't use fill, then do a for loop to fill it
            for (var _i = startFrame; _i < length; ++_i) {
                timeline[_i] = true;
            }
        }
    };

    /**
     * Convert serialized array into keyframes
     * `"0x100y100 1x150"` to: `{ "0": {"x":100, "y": 100}, "1": {"x": 150} }`
     * @static
     * @method PIXI.animate.utils.deserializeKeyframes
     * @param {String} keyframes
     * @param {Object} Resulting keyframes
     */


    AnimateUtils.deserializeKeyframes = function deserializeKeyframes(keyframes) {
        var result = {};
        var i = 0;
        var keysMap = {
            X: 'x', // x position
            Y: 'y', // y position
            A: 'sx', // scale x
            B: 'sy', // scale y
            C: 'kx', // skew x
            D: 'ky', // skew y
            R: 'r', // rotation
            L: 'a', // alpha
            T: 't', // tint
            F: 'c', // colorTransform
            V: 'v' // visibility
        };
        var c = void 0,
            buffer = '',
            isFrameStarted = false,
            prop = void 0,
            frame = {};

        while (i <= keyframes.length) {
            c = keyframes[i];
            if (keysMap[c]) {
                if (!isFrameStarted) {
                    isFrameStarted = true;
                    result[buffer] = frame;
                }
                if (prop) {
                    frame[prop] = this.parseValue(prop, buffer);
                }
                prop = keysMap[c];
                buffer = '';
                i++;
            }
            // Start a new prop
            else if (!c || c === ' ') {
                    i++;
                    frame[prop] = this.parseValue(prop, buffer);
                    buffer = '';
                    prop = null;
                    frame = {};
                    isFrameStarted = false;
                } else {
                    buffer += c;
                    i++;
                }
        }
        return result;
    };

    /**
     * Convert serialized shapes into draw commands for PIXI.Graphics.
     * @static
     * @method PIXI.animate.utils.deserializeShapes
     * @param {String} str
     * @param {Array} Resulting shapes map
     */


    AnimateUtils.deserializeShapes = function deserializeShapes(str) {
        var result = [];
        // each shape is a new line
        var shapes = str.split("\n");
        var isCommand = /^[a-z]{1,2}$/;
        for (var i = 0; i < shapes.length; i++) {
            var shape = shapes[i].split(' '); // arguments are space separated
            for (var j = 0; j < shape.length; j++) {
                // Convert all numbers to floats, ignore colors
                var arg = shape[j];
                if (arg[0] !== '#' && !isCommand.test(arg)) {
                    shape[j] = parseFloat(arg);
                }
            }
            result.push(shape);
        }
        return result;
    };

    /** 
     * Parse the value of the compressed keyframe.
     * @method PIXI.animate.utils.parseValue
     * @static
     * @private
     * @param {String} prop The property key
     * @param {String} buffer The contents
     * @return {*} The parsed value
     */


    AnimateUtils.parseValue = function parseValue(prop, buffer) {
        switch (prop) {
            // Color transforms are parsed as an array
            case 'c':
                {
                    buffer = buffer.split(',');
                    buffer.forEach(function (val, i, buffer) {
                        buffer[i] = parseFloat(val);
                    });
                    return buffer;
                }
            // Tint value should not be converted
            // can be color uint or string
            case 't':
                {
                    return buffer;
                }
            // The visiblity parse as boolean
            case 'v':
                {
                    return !!parseInt(buffer);
                }
            // Everything else parse a floats
            default:
                {
                    return parseFloat(buffer);
                }
        }
    };

    /** 
     * Upload all the textures and graphics to the GPU. 
     * @method PIXI.animate.utils.upload
     * @static
     * @param {PIXI.WebGLRenderer} renderer Render to upload to
     * @param {PIXI.DisplayObject} clip MovieClip to upload
     * @param {function} done When complete
     */


    AnimateUtils.upload = function upload(renderer, displayObject, done) {
        if (!_prepare) {
            _prepare = renderer.plugins.prepare;
            _prepare.register(this.addMovieClips);
        }
        _prepare.upload(displayObject, done);
    };

    /**
     * Add movie clips to the upload prepare.
     * @method PIXI.animate.utils.addMovieClips
     * @static
     * @private
     * @param {*} item To add to the queue 
     */


    AnimateUtils.addMovieClips = function addMovieClips(item) {
        if (item instanceof PIXI.animate.MovieClip) {
            item._timedChildTimelines.forEach(function (timeline) {
                var index = item.children.indexOf(timeline.target);
                if (index === -1) {
                    _prepare.add(timeline.target);
                }
            });
            return true;
        }
        return false;
    };

    return AnimateUtils;
}();

exports.default = AnimateUtils;

},{}],13:[function(require,module,exports){
"use strict";

/**
 * Mixins for the PIXI.Container class.
 * @class Container
 * @memberof PIXI
 */
var p = PIXI.Container.prototype;

/**
 * Shortcut for `addChild`.
 * @method PIXI.Container#ac
 * @param {*} [child*] N-number of children
 * @return {PIXI.DisplayObject} Instance of first child added
 */
p.ac = p.addChild;

/**
 * Extend a container
 * @method PIXI.Container.extend
 * @static
 * @param {PIXI.Container} child The child function
 * @return {PIXI.Container} THe child
 */
/**
 * Extend a container (shortcut for `extend`)
 * @method PIXI.Container.e
 * @static
 * @param {PIXI.Container} child The child function
 * @return {PIXI.Container} THe child
 */
PIXI.Container.extend = PIXI.Container.e = function (child) {
  child.prototype = Object.create(p);
  child.prototype.__parent = p;
  child.prototype.constructor = child;
  return child;
};

},{}],14:[function(require,module,exports){
"use strict";

var _utils = require("../animate/utils");

var _utils2 = _interopRequireDefault(_utils);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Mixins for the PIXI.DisplayObject class.
 * @memberof PIXI
 * @class DisplayObject
 */
var p = PIXI.DisplayObject.prototype;

// Color Matrix filter
var ColorMatrixFilter = void 0;
if (PIXI.filters) {
  ColorMatrixFilter = PIXI.filters.ColorMatrixFilter;
}

/**
 * Function to see if this is renderable or not. Useful for setting masks.
 * @method PIXI.DisplayObject#setRenderable
 * @param  {Boolean} [renderable=false] Make renderable
 * @return {PIXI.DisplayObject}
 */
/**
 * Shortcut to `setRenderable`.
 * @method PIXI.DisplayObject#re
 * @param  {Boolean} [renderable=false] Make renderable
 * @return {PIXI.DisplayObject}
 */
p.setRenderable = p.re = function (renderable) {
  this.renderable = !!renderable;
  return this;
};

/**
 * Shortcut for `setTransform`.
 * @method PIXI.DisplayObject#tr
 * @param {Number} x The X position
 * @param {Number} y The Y position
 * @param {Number} scaleX The X Scale value
 * @param {Number} scaleY The Y Scale value
 * @param {Number} skewX The X skew value
 * @param {Number} skewY The Y skew value
 * @param {Number} pivotX The X pivot value
 * @param {Number} pivotY The Y pivot value
 * @return {PIXI.DisplayObject} Instance for chaining
 */
p.t = p.setTransform;

/**
 * Setter for mask to be able to chain.
 * @method PIXI.DisplayObject#setMask
 * @param {PIXI.Graphics} mask The mask shape to use
 * @return {PIXI.DisplayObject} Instance for chaining
 */
/**
 * Shortcut for `setMask`.
 * @method PIXI.DisplayObject#ma
 * @param {PIXI.Sprite|PIXI.Graphics} mask The mask shape to use
 * @return {PIXI.DisplayObject} Instance for chaining
 */
p.setMask = p.ma = function (mask) {
  // According to PIXI, only Graphics and Sprites can 
  // be used as mask, let's ignore everything else, like other
  // movieclips and displayobjects/containers
  if (mask) {
    if (!(mask instanceof PIXI.Graphics) && !(mask instanceof PIXI.Sprite)) {
      if (typeof console !== "undefined" && console.warn) {
        console.warn("Warning: Masks can only be PIXI.Graphics or PIXI.Sprite objects.");
      }
      return this;
    }
  }
  this.mask = mask;
  return this;
};

/**
 * Setter for the alpha
 * @method PIXI.DisplayObject#setAlpha
 * @param {Number} alpha The alpha amount to use, from 0 to 1
 * @return {PIXI.DisplayObject} Instance for chaining
 */
/**
 * Shortcut for `setAlpha`.
 * @method PIXI.DisplayObject#a
 * @param {Number} alpha The alpha amount to use, from 0 to 1
 * @return {PIXI.DisplayObject} Instance for chaining
 */
p.setAlpha = p.a = function (alpha) {
  this.alpha = alpha;
  return this;
};

/**
 * Set the tint values by color.
 * @method PIXI.DisplayObject#setTint
 * @param {int} tint The color value to tint
 * @return {PIXI.DisplayObject} Object for chaining
 */
/**
 * Shortcut to `setTint`.
 * @method PIXI.DisplayObject#tn
 * @param {Number|String} tint The red percentage value
 * @return {PIXI.DisplayObject} Object for chaining
 */
p.setTint = p.i = function (tint) {
  if (typeof tint === "string") {
    tint = _utils2.default.hexToUint(tint);
  }
  // this.tint = tint
  // return this;
  // TODO: Replace with DisplayObject.tint setter
  // once the functionality is added to Pixi.js, for
  // now we'll use the slower ColorMatrixFilter to handle
  // the color transformation
  var r = tint >> 16 & 0xFF;
  var g = tint >> 8 & 0xFF;
  var b = tint & 0xFF;
  return this.c(r / 255, 0, g / 255, 0, b / 255, 0);
};

/**
 * Set additive and multiply color, tinting
 * @method PIXI.DisplayObject#setColorTransform
 * @param {Number} r The multiply red value
 * @param {Number} rA The additive red value
 * @param {Number} g The multiply green value
 * @param {Number} gA The additive green value
 * @param {Number} b The multiply blue value
 * @param {Number} bA The additive blue value
 * @return {PIXI.DisplayObject} Object for chaining
 */
/**
 * Shortcut to `setColor`.
 * @method PIXI.DisplayObject#c
 * @param {Number} r The multiply red value
 * @param {Number} rA The additive red value
 * @param {Number} g The multiply green value
 * @param {Number} gA The additive green value
 * @param {Number} b The multiply blue value
 * @param {Number} bA The additive blue value
 * @return {PIXI.DisplayObject} Object for chaining
 */
p.setColorTransform = p.c = function (r, rA, g, gA, b, bA) {
  var filter = this.colorTransformFilter;
  filter.matrix[0] = r;
  filter.matrix[4] = rA;
  filter.matrix[6] = g;
  filter.matrix[9] = gA;
  filter.matrix[12] = b;
  filter.matrix[14] = bA;
  this.filters = [filter];
  return this;
};

/**
 * The current default color transforming filters
 * @name {PIXI.filters.ColorMatrixFilter} PIXI.DisplayObject#colorTransformFilter
 */
if (!p.hasOwnProperty('colorTransformFilter')) {
  Object.defineProperty(p, 'colorTransformFilter', {
    set: function set(filter) {
      this._colorTransformFilter = filter;
    },
    get: function get() {
      return this._colorTransformFilter || new ColorMatrixFilter();
    }
  });
}

/**
 * Extend a container
 * @method PIXI.DisplayObject.extend
 * @static
 * @param {PIXI.DisplayObject} child The child function
 * @return {PIXI.DisplayObject} THe child
 */
/**
 * Extend a container (shortcut for `extend`)
 * @method PIXI.DisplayObject.e
 * @static
 * @param {PIXI.DisplayObject} child The child function
 * @return {PIXI.DisplayObject} THe child
 */
PIXI.DisplayObject.extend = PIXI.DisplayObject.e = function (child) {
  child.prototype = Object.create(p);
  child.prototype.__parent = p;
  child.prototype.constructor = child;
  return child;
};

},{"../animate/utils":12}],15:[function(require,module,exports){
"use strict";

/**
 * Mixins for the PIXI.Graphics class.
 * @memberof PIXI
 * @class Graphics
 */
var p = PIXI.Graphics.prototype;

/**
 * Shortcut for `drawCommands`.
 * @method PIXI.Graphics#d
 * @param  {Array} commands The commands and parameters to draw
 * @return {PIXI.Graphics}
 */
/**
 * Execute a series of commands, this is the name of the short function
 * followed by the parameters, e.g., `["f", "#ff0000", "r", 0, 0, 100, 200]`
 * @method PIXI.Graphics#drawCommands
 * @param  {Array} commands The commands and parameters to draw
 * @return {PIXI.Graphics}
 */
p.drawCommands = p.d = function (commands) {
  var currentCommand,
      params = [],
      i = 0;

  while (i <= commands.length) {
    var item = commands[i++];
    if (item === undefined || this[item]) {
      if (currentCommand) {
        this[currentCommand].apply(this, params);
        params.length = 0;
      }
      currentCommand = item;
    } else {
      params.push(item);
    }
  }
  return this;
};

/**
 * Closes the current path, effectively drawing a line from the current drawing point to the first drawing point specified
 * since the fill or stroke was last set.
 * @method PIXI.Graphics#c
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.c = p.closePath;

/**
 * Alias for `addHole`
 * @method PIXI.Graphics#h
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.h = p.addHole;

/**
 * Shortcut to `moveTo`.
 * @method PIXI.Graphics#m
 * @param {Number} x The x coordinate the drawing point should move to.
 * @param {Number} y The y coordinate the drawing point should move to.
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls).
 **/
p.m = p.moveTo;

/**
 * Shortcut to `lineTo`.
 * @method PIXI.Graphics#l
 * @param {Number} x The x coordinate the drawing point should draw to.
 * @param {Number} y The y coordinate the drawing point should draw to.
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.l = p.lineTo;

/**
 * Draws a quadratic curve from the current drawing point to (x, y) using the control point (cpx, cpy). For detailed
 * information, read the <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-context-2d-quadraticcurveto">
 * whatwg spec</a>. A tiny API method "qt" also exists.
 * @method PIXI.Graphics#q
 * @param {Number} cpx
 * @param {Number} cpy
 * @param {Number} x
 * @param {Number} y
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.q = p.quadraticCurveTo;

/**
 * Shortcut to `bezierCurveTo`.
 * @method PIXI.Graphics#b
 * @param {Number} cp1x
 * @param {Number} cp1y
 * @param {Number} cp2x
 * @param {Number} cp2y
 * @param {Number} x
 * @param {Number} y
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.b = p.bezierCurveTo;

/**
 * Shortcut to `beginFill`.
 * @method PIXI.Graphics#f
 * @param {Uint} color The hex color value (e.g. 0xFFFFFF)
 * null will result in no fill.
 * @param {Number} [alpha=1] The alpha value of fill
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.f = p.beginFill;

/**
 * Shortcut to `lineStyle`.
 * @method PIXI.Graphics#s
 * @param {String} color A CSS compatible color value (ex. "#FF0000", "red", or "rgba(255,0,0,0.5)"). Setting to
 * null will result in no stroke.
 * @param {Number} [thickness=1] The thickness of the stroke
 * @param {Number} [alpha=1] The alpha value from 0 (invisibile) to 1 (visible)
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.s = p.lineStyle;

/**
 * Shortcut to `drawRect`.
 * @method PIXI.Graphics#dr
 * @param {Number} x
 * @param {Number} y
 * @param {Number} w Width of the rectangle
 * @param {Number} h Height of the rectangle
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
/**
 * Shortcut to `drawRect`.
 * @method PIXI.Graphics#r
 * @param {Number} x
 * @param {Number} y
 * @param {Number} w Width of the rectangle
 * @param {Number} h Height of the rectangle
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.dr = p.drawRect;

/**
 * Shortcut to `drawRoundedRect`.
 * @method PIXI.Graphics#rr
 * @param {Number} x
 * @param {Number} y
 * @param {Number} w Width of the rectangle
 * @param {Number} h Height of the rectangle
 * @param {Number} radius The corner radius
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.rr = p.drawRoundedRect;

/**
 * Shortcut to `drawRoundedRect`.
 * @method PIXI.Graphics#rc
 * @param {Number} x
 * @param {Number} y
 * @param {Number} w Width of the rectangle
 * @param {Number} h Height of the rectangle
 * @param {Number} radiusTL The top left corner radius
 * @param {Number} radiusTR The top right corner radius
 * @param {Number} radiusBR The bottom right corner radius
 * @param {Number} radiusBL The bottom left corner radius
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.rc = p.drawRoundedRect;

/**
 * Shortcut to `drawCircle`.
 * @method PIXI.Graphics#dc
 * @param {Number} x x coordinate center point of circle.
 * @param {Number} y y coordinate center point of circle.
 * @param {Number} radius Radius of circle.
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.dc = p.drawCircle;

/**
 * Shortcut to `arc`.
 * @method PIXI.Graphics#ac
 * @param {Number} x
 * @param {Number} y
 * @param {Number} radius
 * @param {Number} startAngle Measured in radians.
 * @param {Number} endAngle Measured in radians.
 * @param {Boolean} anticlockwise
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.ar = p.arc;

/**
 * Shortcut to `arcTo`.
 * @method PIXI.Graphics#at
 * @param {Number} x1
 * @param {Number} y1
 * @param {Number} x2
 * @param {Number} y2
 * @param {Number} radius
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.at = p.arcTo;

/**
 * Shortcut to `drawEllipse`.
 * @method  PIXI.Graphics#de
 * @param  {Number} x      [description]
 * @param  {Number} y      [description]
 * @param  {Number} width  [description]
 * @param  {Number} height [description]
 */
p.de = p.drawEllipse;

/**
 * Placeholder method for a linear fill. Pixi does not support linear fills,
 * so we just pick the first color in colorArray
 * @method PIXI.Graphics#lf
 * @param {Array} colorArray An array of CSS compatible color values @see `f`
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.lf = function (colorArray) {
  console.warn("Linear gradient fills are not supported");
  return this.f(colorArray[0]);
};

/**
 * Placeholder method for a radial fill. Pixi does not support radial fills,
 * so we just pick the first color in colorArray
 * @method PIXI.Graphics#rf
 * @param {Array} colorArray An array of CSS compatible color values @see `f`
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.rf = function (colorArray) {
  console.warn("Radial gradient fills are not supported");
  return this.f(colorArray[0]);
};

/**
 * Placeholder method for a `beginBitmapFill`. Pixi does not support bitmap fills.
 * @method PIXI.Graphics#bf
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.bf = function () {
  console.warn("Bitmap fills are not supported");
  return this.f(0x0);
};

/**
 * Placeholder method for a `setStrokeDash`. Pixi does not support dashed strokes.
 * @method PIXI.Graphics#sd
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.sd = function () {
  console.warn("Dashed strokes are not supported");
  return this;
};

/**
 * Placeholder method for a `beginBitmapStroke`. Pixi does not support bitmap strokes.
 * @method PIXI.Graphics#bs
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.bs = function () {
  console.warn("Bitmap strokes are not supported");
  return this;
};

/**
 * Placeholder method for a `beginLinearGradientStroke`. Pixi does not support gradient strokes.
 * @method PIXI.Graphics#ls
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.ls = function () {
  console.warn("Linear gradient strokes are not supported");
  return this;
};

/**
 * Placeholder method for a `beginRadialGradientStroke`. Pixi does not support gradient strokes.
 * @method PIXI.Graphics#rs
 * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
 **/
p.rs = function () {
  console.warn("Radial gradient strokes are not supported");
  return this;
};

},{}],16:[function(require,module,exports){
"use strict";

/**
 * Mixins for the PIXI.Sprite class.
 * @memberof PIXI
 * @class Sprite
 */
var p = PIXI.Sprite.prototype;

/**
 * Extend a container
 * @method PIXI.Sprite.extend
 * @static
 * @param {PIXI.Sprite} child The child function
 * @return {PIXI.Sprite} THe child
 */
/**
 * Extend a container (shortcut for `extend`)
 * @method PIXI.Sprite.e
 * @static
 * @param {PIXI.Sprite} child The child function
 * @return {PIXI.Sprite} THe child
 */
PIXI.Sprite.extend = PIXI.Sprite.e = function (child) {
  child.prototype = Object.create(p);
  child.prototype.__parent = p;
  child.prototype.constructor = child;
  return child;
};

},{}],17:[function(require,module,exports){
"use strict";

/**
 * Mixins for the PIXI.Text class.
 * @memberof PIXI
 * @class Text
 */
var p = PIXI.Text.prototype;

// Possible align values
var ALIGN_VALUES = ["center", "right"];

/**
 * Setter for the alignment, also sets the anchor point
 * to make sure the positioning is correct.
 * @method PIXI.Text#setAlign
 * @param {String} align Either, center, right, left
 * @return {PIXI.Text} For chaining
 */
/**
 * Shortcut for `setAlign`.
 * @method PIXI.Text#g
 * @param {String|int} align Either, center (0), right (1), left (-1)
 * @return {PIXI.Text} For chaining
 */
p.setAlign = p.g = function (align) {
    if (typeof align == "string") {
        align = ALIGN_VALUES.indexOf(align);
    }
    this.style.align = ALIGN_VALUES[align] || "left";
    this.anchor.x = (align + 1) / 2;
    return this;
};

// Map of short names to long names
var STYLE_PROPS = {
    o: 'font', // TODO: deprecate in Pixi v4
    z: 'fontSize',
    f: 'fontFamily',
    y: 'fontStyle',
    g: 'fontWeight',
    i: 'fill',
    a: 'align',
    s: 'stroke',
    t: 'strokeThickness',
    w: 'wordWrap',
    d: 'wordWrapWidth',
    l: 'lineHeight',
    h: 'dropShadow',
    c: 'dropShadowColor',
    n: 'dropShadowAngle',
    b: 'dropShadowBlur',
    p: 'padding',
    x: 'textBaseline',
    j: 'lineJoin',
    m: 'miterLimit',
    e: 'letterSpacing'
};

/**
 * Set the style, a chainable version of style setter
 * @method PIXI.Text#setStyle
 * @param {Object} style
 * @return {PIXI.Text} instance of text field
 */
/**
 * Shortcut for `setStyle`.
 * @method PIXI.Text#ss
 * @param {Object} style
 * @return {PIXI.Text} instance of text field
 */
p.setStyle = p.ss = function (style) {
    // Replace short STYLE_PROPS with long names
    for (var k in STYLE_PROPS) {
        if (style[k] !== undefined) {
            style[STYLE_PROPS[k]] = style[k];
            delete style[k];
        }
    }
    this.style = style;
    return this;
};

/**
 * Initial setting of the drop shadow.
 * @method PIXI.Text#setShadow
 * @param {String} [color="#000000"] The color to set
 * @param {Number} [angle=Math.PI/4] The angle of offset, in radians
 * @param {Number} [distance=5] The offset distance
 * @return {PIXI.Text} For chaining
 */
/**
 * Shortcut for `setShadow`.
 * @method PIXI.Text#sh
 * @param {String} [color="#000000"] The color to set
 * @param {Number} [angle=Math.PI/4] The angle of offset, in radians
 * @param {Number} [distance=5] The offset distance
 * @return {PIXI.Text} For chaining
 */
p.setShadow = p.sh = function (color, angle, distance) {
    var style = this.style;
    style.dropShadow = true;

    // Convert color to hex string
    if (color !== undefined) {
        color = "#" + color.toString(16);
    }
    style.dropShadowColor = isUndefinedOr(color, style.dropShadowColor);
    style.dropShadowAngle = isUndefinedOr(angle, style.dropShadowAngle);
    style.dropShadowDistance = isUndefinedOr(distance, style.dropShadowDistance);
    return this;
};

/**
 * Check if a value is undefined, fallback to default value
 * @method isUndefinedOr
 * @private
 * @param {*} value The value to check
 * @param {*} defaultValue The default value if value is undefined
 * @return {*} The either the value or the default value
 */
var isUndefinedOr = function isUndefinedOr(value, defaultValue) {
    return value === undefined ? defaultValue : value;
};

},{}],18:[function(require,module,exports){
'use strict';

exports.__esModule = true;

var _Container = require('./Container');

var _Container2 = _interopRequireDefault(_Container);

var _DisplayObject = require('./DisplayObject');

var _DisplayObject2 = _interopRequireDefault(_DisplayObject);

var _Sprite = require('./Sprite');

var _Sprite2 = _interopRequireDefault(_Sprite);

var _Graphics = require('./Graphics');

var _Graphics2 = _interopRequireDefault(_Graphics);

var _Text = require('./Text');

var _Text2 = _interopRequireDefault(_Text);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @namespace PIXI
 */
exports.default = {
    Container: _Container2.default,
    DisplayObject: _DisplayObject2.default,
    Sprite: _Sprite2.default,
    Graphics: _Graphics2.default,
    Text: _Text2.default
};

},{"./Container":13,"./DisplayObject":14,"./Graphics":15,"./Sprite":16,"./Text":17}],19:[function(require,module,exports){
'use strict';

// If we're in the browser make sure PIXI is available
if (typeof PIXI === 'undefined') {
    throw "Requires PIXI";
}

if (!PIXI.animate) {
    // Include the PIXI mixins
    require('./mixins');

    // Add to the PIXI global object
    Object.defineProperty(PIXI, 'animate', {
        enumerable: true,
        get: function get() {
            return require('./animate');
        }
    });
}

// Export for Node-compatible environments like Electron
if (typeof module !== 'undefined' && module.exports) {
    module.exports = PIXI.animate;
}

},{"./animate":9,"./mixins":18}]},{},[19])(19)
});


//# sourceMappingURL=pixi-animate.js.map