text: if (!window.egret) {
      var egret_strings = {
          4001: "Abstract class can not be instantiated!",
          4002: "Unnamed data!",
          4003: "Nonsupport version!"
      };
  
      var Event = function(type, bubbles, cancelable, data) {
          this.type = type;
          this.bubbles = bubbles || false;
          this.cancelable = cancelable || false;
          this.data = data;
      };
  
      var EventDispatcher = function(target) {
          this._listenerDict = {};
      };
  
      EventDispatcher.prototype = {
          constructor: EventDispatcher,
          addEventListener: function(type, listener, thisObject, useCapture, priority, dispatchOnce) {
              if (!this._listenerDict[type]) {
                  this._listenerDict[type] = [];
              }
              this._listenerDict[type].push({
                  listener: listener,
                  thisObject: thisObject,
                  useCapture: useCapture,
                  priority: priority,
                  once: dispatchOnce
              });
          },
          once: function(type, listener, thisObject, useCapture, priority) {
              this.addEventListener(type, listener, thisObject, useCapture, priority, true);
          },
          removeEventListener: function(type, listener, thisObject, useCapture) {
              if (!type) {
                  this._listenerDict = {};
              } else if (!listener) {
                  if (this._listenerDict[type]) {
                      this._listenerDict[type].length = 0;
                  }
              } else {
                  var listeners = this._listenerDict[type];
                  var index = listeners.indexOf(listener);
                  if (index > -1) {
                      listeners.splice(index, 1);
                  }
              }
          },
          hasEventListener: function(type) {
              return this._listenerDict[type];
          },
          dispatchEvent: function(event) {
              if (event && event.type && this._listenerDict[event.type]) {
                  var listeners = this._listenerDict[event.type];
                  var copyListeners = listeners.slice();
                  for (var i = 0; i < copyListeners.length; i++) {
                      var listenerObj = copyListeners[i];
                      if (listenerObj.dispatchOnce) {
                          var index = listeners.indexOf(listenerObj);
                          if (index > -1) {
                              listeners.splice(index, 1);
                          }
                      }
                      if (listenerObj.listener) {
                          listenerObj.listener.call(listenerObj.thisObject || this, event);
                      }
                  }
              }
          },
          willTrigger: function(type) {
              return this.hasEventListener(type);
          }
      };
  
      window.egret = {
          getString: function(code) {
              return egret_strings[code] || 'no string code';
          },
          Event: Event,
          EventDispatcher: EventDispatcher,
          registerClass: function(classDefinition, className, interfaceNames) {
              var prototype = classDefinition.prototype;
              prototype.__class__ = className;
              var types = [className];
              if (interfaceNames) {
                  types = types.concat(interfaceNames);
              }
              var superTypes = prototype.__types__;
              if (prototype.__types__) {
                  var length = superTypes.length;
                  for (var i = 0; i < length; i++) {
                      var name = superTypes[i];
                      if (types.indexOf(name) == -1) {
                          types.push(name);
                      }
                  }
              }
              prototype.__types__ = types;
          }
      };
  }
  
  window.__extends = window.__extends || function __extends(d, b, mixin) {
      for (var p in b)
          if (b.hasOwnProperty(p))
              d[p] = b[p];
  
      function __() {
          this.constructor = d;
      }
      __.prototype = b.prototype;
      d.prototype = new __();
  
      if(mixin){
          for(var key in mixin){
              d.prototype[key] = mixin[key];
          }
      }
  };
  
  window.__define = window.__define || function(o, p, g, s) {
      Object.defineProperty(o, p, {
          configurable: true,
          enumerable: true,
          get: g,
          set: s
      });
  };
  var dragonBones;
  (function (dragonBones) {
      var DragonBones = (function () {
          function DragonBones() {
          }
          var d = __define,c=DragonBones,p=c.prototype;
          DragonBones.DATA_VERSION = "4.0";
          DragonBones.PARENT_COORDINATE_DATA_VERSION = "3.0";
          DragonBones.VERSION = "4.3.5";
          return DragonBones;
      })();
      dragonBones.DragonBones = DragonBones;
      egret.registerClass(DragonBones,'dragonBones.DragonBones');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Animation = (function () {
          function Animation(armature) {
              this._animationStateCount = 0;
              this._armature = armature;
              this._animationList = [];
              this._animationStateList = [];
              this._timeScale = 1;
              this._isPlaying = false;
              this.tweenEnabled = true;
          }
          var d = __define,c=Animation,p=c.prototype;
          p.dispose = function () {
              if (!this._armature) {
                  return;
              }
              this._resetAnimationStateList();
              this._animationList.length = 0;
              this._armature = null;
              this._animationDataList = null;
              this._animationList = null;
              this._animationStateList = null;
          };
          p._resetAnimationStateList = function () {
              var i = this._animationStateList.length;
              var animationState;
              while (i--) {
                  animationState = this._animationStateList[i];
                  animationState._resetTimelineStateList();
                  dragonBones.AnimationState._returnObject(animationState);
              }
              this._animationStateList.length = 0;
          };
          p.gotoAndPlay = function (animationName, fadeInTime, duration, playTimes, layer, group, fadeOutMode, pauseFadeOut, pauseFadeIn) {
              if (fadeInTime === void 0) { fadeInTime = -1; }
              if (duration === void 0) { duration = -1; }
              if (playTimes === void 0) { playTimes = NaN; }
              if (layer === void 0) { layer = 0; }
              if (group === void 0) { group = null; }
              if (fadeOutMode === void 0) { fadeOutMode = Animation.SAME_LAYER_AND_GROUP; }
              if (pauseFadeOut === void 0) { pauseFadeOut = true; }
              if (pauseFadeIn === void 0) { pauseFadeIn = true; }
              if (!this._animationDataList) {
                  return null;
              }
              var i = this._animationDataList.length;
              var animationData;
              while (i--) {
                  if (this._animationDataList[i].name == animationName) {
                      animationData = this._animationDataList[i];
                      break;
                  }
              }
              if (!animationData) {
                  return null;
              }
              var needUpdate = this._isPlaying == false;
              this._isPlaying = true;
              this._isFading = true;
              fadeInTime = fadeInTime < 0 ? (animationData.fadeTime < 0 ? 0.3 : animationData.fadeTime) : fadeInTime;
              var durationScale;
              if (duration < 0) {
                  durationScale = animationData.scale < 0 ? 1 : animationData.scale;
              }
              else {
                  durationScale = duration * 1000 / animationData.duration;
              }
              playTimes = isNaN(playTimes) ? animationData.playTimes : playTimes;
              var animationState;
              switch (fadeOutMode) {
                  case Animation.NONE:
                      break;
                  case Animation.SAME_LAYER:
                      i = this._animationStateList.length;
                      while (i--) {
                          animationState = this._animationStateList[i];
                          if (animationState.layer == layer) {
                              animationState.fadeOut(fadeInTime, pauseFadeOut);
                          }
                      }
                      break;
                  case Animation.SAME_GROUP:
                      i = this._animationStateList.length;
                      while (i--) {
                          animationState = this._animationStateList[i];
                          if (animationState.group == group) {
                              animationState.fadeOut(fadeInTime, pauseFadeOut);
                          }
                      }
                      break;
                  case Animation.ALL:
                      i = this._animationStateList.length;
                      while (i--) {
                          animationState = this._animationStateList[i];
                          animationState.fadeOut(fadeInTime, pauseFadeOut);
                      }
                      break;
                  case Animation.SAME_LAYER_AND_GROUP:
                  default:
                      i = this._animationStateList.length;
                      while (i--) {
                          animationState = this._animationStateList[i];
                          if (animationState.layer == layer && animationState.group == group) {
                              animationState.fadeOut(fadeInTime, pauseFadeOut);
                          }
                      }
                      break;
              }
              this._lastAnimationState = dragonBones.AnimationState._borrowObject();
              this._lastAnimationState._layer = layer;
              this._lastAnimationState._group = group;
              this._lastAnimationState.autoTween = this.tweenEnabled;
              this._lastAnimationState._fadeIn(this._armature, animationData, fadeInTime, 1 / durationScale, playTimes, pauseFadeIn);
              this.addState(this._lastAnimationState);
              var slotList = this._armature.getSlots(false);
              i = slotList.length;
              while (i--) {
                  var slot = slotList[i];
                  if (slot.childArmature) {
                      slot.childArmature.animation.gotoAndPlay(animationName, fadeInTime);
                  }
              }
              if (needUpdate) {
                  this._armature.advanceTime(0);
              }
              return this._lastAnimationState;
          };
          p.gotoAndStop = function (animationName, time, normalizedTime, fadeInTime, duration, layer, group, fadeOutMode) {
              if (normalizedTime === void 0) { normalizedTime = -1; }
              if (fadeInTime === void 0) { fadeInTime = 0; }
              if (duration === void 0) { duration = -1; }
              if (layer === void 0) { layer = 0; }
              if (group === void 0) { group = null; }
              if (fadeOutMode === void 0) { fadeOutMode = Animation.ALL; }
              var animationState = this.getState(animationName, layer);
              if (!animationState) {
                  animationState = this.gotoAndPlay(animationName, fadeInTime, duration, NaN, layer, group, fadeOutMode);
              }
              if (normalizedTime >= 0) {
                  animationState.setCurrentTime(animationState.totalTime * normalizedTime);
              }
              else {
                  animationState.setCurrentTime(time);
              }
              animationState.stop();
              return animationState;
          };
          p.play = function () {
              if (!this._animationDataList || this._animationDataList.length == 0) {
                  return;
              }
              if (!this._lastAnimationState) {
                  this.gotoAndPlay(this._animationDataList[0].name);
              }
              else if (!this._isPlaying) {
                  this._isPlaying = true;
              }
              else {
                  this.gotoAndPlay(this._lastAnimationState.name);
              }
          };
          p.stop = function () {
              this._isPlaying = false;
          };
          p.getState = function (name, layer) {
              if (layer === void 0) { layer = 0; }
              var i = this._animationStateList.length;
              while (i--) {
                  var animationState = this._animationStateList[i];
                  if (animationState.name == name && animationState.layer == layer) {
                      return animationState;
                  }
              }
              return null;
          };
          p.hasAnimation = function (animationName) {
              var i = this._animationDataList.length;
              while (i--) {
                  if (this._animationDataList[i].name == animationName) {
                      return true;
                  }
              }
              return false;
          };
          p._advanceTime = function (passedTime) {
              if (!this._isPlaying) {
                  return;
              }
              var isFading = false;
              passedTime *= this._timeScale;
              var i = this._animationStateList.length;
              while (i--) {
                  var animationState = this._animationStateList[i];
                  if (animationState._advanceTime(passedTime)) {
                      this.removeState(animationState);
                  }
                  else if (animationState.fadeState != 1) {
                      isFading = true;
                  }
              }
              this._isFading = isFading;
          };
          p._updateAnimationStates = function () {
              var i = this._animationStateList.length;
              while (i--) {
                  this._animationStateList[i]._updateTimelineStates();
              }
          };
          p.addState = function (animationState) {
              if (this._animationStateList.indexOf(animationState) < 0) {
                  this._animationStateList.unshift(animationState);
                  this._animationStateCount = this._animationStateList.length;
              }
          };
          p.removeState = function (animationState) {
              var index = this._animationStateList.indexOf(animationState);
              if (index >= 0) {
                  this._animationStateList.splice(index, 1);
                  dragonBones.AnimationState._returnObject(animationState);
                  if (this._lastAnimationState == animationState) {
                      if (this._animationStateList.length > 0) {
                          this._lastAnimationState = this._animationStateList[0];
                      }
                      else {
                          this._lastAnimationState = null;
                      }
                  }
                  this._animationStateCount = this._animationStateList.length;
              }
          };
          d(p, "movementList"
              ,function () {
                  return this._animationList;
              }
          );
          d(p, "movementID"
              ,function () {
                  return this.lastAnimationName;
              }
          );
          d(p, "lastAnimationState"
              ,function () {
                  return this._lastAnimationState;
              }
          );
          d(p, "lastAnimationName"
              ,function () {
                  return this._lastAnimationState ? this._lastAnimationState.name : null;
              }
          );
          d(p, "animationList"
              ,function () {
                  return this._animationList;
              }
          );
          d(p, "isPlaying"
              ,function () {
                  return this._isPlaying && !this.isComplete;
              }
          );
          d(p, "isComplete"
              ,function () {
                  if (this._lastAnimationState) {
                      if (!this._lastAnimationState.isComplete) {
                          return false;
                      }
                      var i = this._animationStateList.length;
                      while (i--) {
                          if (!this._animationStateList[i].isComplete) {
                              return false;
                          }
                      }
                      return true;
                  }
                  return true;
              }
          );
          d(p, "timeScale"
              ,function () {
                  return this._timeScale;
              }
              ,function (value) {
                  if (isNaN(value) || value < 0) {
                      value = 1;
                  }
                  this._timeScale = value;
              }
          );
          d(p, "animationDataList"
              ,function () {
                  return this._animationDataList;
              }
              ,function (value) {
                  this._animationDataList = value;
                  this._animationList.length = 0;
                  for (var i = 0, len = this._animationDataList.length; i < len; i++) {
                      var animationData = this._animationDataList[i];
                      this._animationList[this._animationList.length] = animationData.name;
                  }
              }
          );
          Animation.NONE = "none";
          Animation.SAME_LAYER = "sameLayer";
          Animation.SAME_GROUP = "sameGroup";
          Animation.SAME_LAYER_AND_GROUP = "sameLayerAndGroup";
          Animation.ALL = "all";
          return Animation;
      })();
      dragonBones.Animation = Animation;
      egret.registerClass(Animation,'dragonBones.Animation');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var AnimationState = (function () {
          function AnimationState() {
              this._layer = 0;
              this._currentFrameIndex = 0;
              this._currentFramePosition = 0;
              this._currentFrameDuration = 0;
              this._currentPlayTimes = 0;
              this._totalTime = 0;
              this._currentTime = 0;
              this._lastTime = 0;
              this._fadeState = 0;
              this._playTimes = 0;
              this._timelineStateList = [];
              this._slotTimelineStateList = [];
              this._boneMasks = [];
          }
          var d = __define,c=AnimationState,p=c.prototype;
          AnimationState._borrowObject = function () {
              if (AnimationState._pool.length == 0) {
                  return new AnimationState();
              }
              return AnimationState._pool.pop();
          };
          AnimationState._returnObject = function (animationState) {
              animationState.clear();
              if (AnimationState._pool.indexOf(animationState) < 0) {
                  AnimationState._pool[AnimationState._pool.length] = animationState;
              }
          };
          AnimationState._clear = function () {
              var i = AnimationState._pool.length;
              while (i--) {
                  AnimationState._pool[i].clear();
              }
              AnimationState._pool.length = 0;
              dragonBones.TimelineState._clear();
          };
          p.clear = function () {
              this._resetTimelineStateList();
              this._boneMasks.length = 0;
              this._armature = null;
              this._clip = null;
          };
          p._resetTimelineStateList = function () {
              var i = this._timelineStateList.length;
              while (i--) {
                  dragonBones.TimelineState._returnObject(this._timelineStateList[i]);
              }
              this._timelineStateList.length = 0;
              i = this._slotTimelineStateList.length;
              while (i--) {
                  dragonBones.SlotTimelineState._returnObject(this._slotTimelineStateList[i]);
              }
              this._slotTimelineStateList.length = 0;
          };
          p.containsBoneMask = function (boneName) {
              return this._boneMasks.length == 0 || this._boneMasks.indexOf(boneName) >= 0;
          };
          p.addBoneMask = function (boneName, ifInvolveChildBones) {
              if (ifInvolveChildBones === void 0) { ifInvolveChildBones = true; }
              this.addBoneToBoneMask(boneName);
              if (ifInvolveChildBones) {
                  var currentBone = this._armature.getBone(boneName);
                  if (currentBone) {
                      var boneList = this._armature.getBones(false);
                      var i = boneList.length;
                      while (i--) {
                          var tempBone = boneList[i];
                          if (currentBone.contains(tempBone)) {
                              this.addBoneToBoneMask(tempBone.name);
                          }
                      }
                  }
              }
              this._updateTimelineStates();
              return this;
          };
          p.removeBoneMask = function (boneName, ifInvolveChildBones) {
              if (ifInvolveChildBones === void 0) { ifInvolveChildBones = true; }
              this.removeBoneFromBoneMask(boneName);
              if (ifInvolveChildBones) {
                  var currentBone = this._armature.getBone(boneName);
                  if (currentBone) {
                      var boneList = this._armature.getBones(false);
                      var i = boneList.length;
                      while (i--) {
                          var tempBone = boneList[i];
                          if (currentBone.contains(tempBone)) {
                              this.removeBoneFromBoneMask(tempBone.name);
                          }
                      }
                  }
              }
              this._updateTimelineStates();
              return this;
          };
          p.removeAllMixingTransform = function () {
              this._boneMasks.length = 0;
              this._updateTimelineStates();
              return this;
          };
          p.addBoneToBoneMask = function (boneName) {
              if (this._clip.getTimeline(boneName) && this._boneMasks.indexOf(boneName) < 0) {
                  this._boneMasks.push(boneName);
              }
          };
          p.removeBoneFromBoneMask = function (boneName) {
              var index = this._boneMasks.indexOf(boneName);
              if (index >= 0) {
                  this._boneMasks.splice(index, 1);
              }
          };
          p._updateTimelineStates = function () {
              var timelineState;
              var slotTimelineState;
              var i = this._timelineStateList.length;
              var len;
              while (i--) {
                  timelineState = this._timelineStateList[i];
                  if (!this._armature.getBone(timelineState.name)) {
                      this.removeTimelineState(timelineState);
                  }
              }
              i = this._slotTimelineStateList.length;
              while (i--) {
                  slotTimelineState = this._slotTimelineStateList[i];
                  if (!this._armature.getSlot(slotTimelineState.name)) {
                      this.removeSlotTimelineState(slotTimelineState);
                  }
              }
              if (this._boneMasks.length > 0) {
                  i = this._timelineStateList.length;
                  while (i--) {
                      timelineState = this._timelineStateList[i];
                      if (this._boneMasks.indexOf(timelineState.name) < 0) {
                          this.removeTimelineState(timelineState);
                      }
                  }
                  for (i = 0, len = this._boneMasks.length; i < len; i++) {
                      var timelineName = this._boneMasks[i];
                      this.addTimelineState(timelineName);
                  }
              }
              else {
                  for (i = 0, len = this._clip.timelineList.length; i < len; i++) {
                      var timeline = this._clip.timelineList[i];
                      this.addTimelineState(timeline.name);
                  }
              }
              for (i = 0, len = this._clip.slotTimelineList.length; i < len; i++) {
                  var slotTimeline = this._clip.slotTimelineList[i];
                  this.addSlotTimelineState(slotTimeline.name);
              }
          };
          p.addTimelineState = function (timelineName) {
              var bone = this._armature.getBone(timelineName);
              if (bone) {
                  for (var i = 0, len = this._timelineStateList.length; i < len; i++) {
                      var eachState = this._timelineStateList[i];
                      if (eachState.name == timelineName) {
                          return;
                      }
                  }
                  var timelineState = dragonBones.TimelineState._borrowObject();
                  timelineState._fadeIn(bone, this, this._clip.getTimeline(timelineName));
                  this._timelineStateList.push(timelineState);
              }
          };
          p.removeTimelineState = function (timelineState) {
              var index = this._timelineStateList.indexOf(timelineState);
              this._timelineStateList.splice(index, 1);
              dragonBones.TimelineState._returnObject(timelineState);
          };
          p.addSlotTimelineState = function (timelineName) {
              var slot = this._armature.getSlot(timelineName);
              if (slot) {
                  for (var i = 0, len = this._slotTimelineStateList.length; i < len; i++) {
                      var eachState = this._slotTimelineStateList[i];
                      if (eachState.name == timelineName) {
                          return;
                      }
                  }
                  var timelineState = dragonBones.SlotTimelineState._borrowObject();
                  timelineState._fadeIn(slot, this, this._clip.getSlotTimeline(timelineName));
                  this._slotTimelineStateList.push(timelineState);
              }
          };
          p.removeSlotTimelineState = function (timelineState) {
              var index = this._slotTimelineStateList.indexOf(timelineState);
              this._slotTimelineStateList.splice(index, 1);
              dragonBones.SlotTimelineState._returnObject(timelineState);
          };
          p.play = function () {
              this._isPlaying = true;
              return this;
          };
          p.stop = function () {
              this._isPlaying = false;
              return this;
          };
          p._fadeIn = function (armature, clip, fadeTotalTime, timeScale, playTimes, pausePlayhead) {
              this._armature = armature;
              this._clip = clip;
              this._pausePlayheadInFade = pausePlayhead;
              this._name = this._clip.name;
              this._totalTime = this._clip.duration;
              this.autoTween = this._clip.autoTween;
              this.setTimeScale(timeScale);
              this.setPlayTimes(playTimes);
              this._isComplete = false;
              this._currentFrameIndex = -1;
              this._currentPlayTimes = -1;
              if (Math.round(this._totalTime * this._clip.frameRate * 0.001) < 2 || timeScale == Infinity) {
                  this._currentTime = this._totalTime;
              }
              else {
                  this._currentTime = -1;
              }
              this._time = 0;
              this._boneMasks.length = 0;
              this._isFadeOut = false;
              this._fadeWeight = 0;
              this._fadeTotalWeight = 1;
              this._fadeState = -1;
              this._fadeCurrentTime = 0;
              this._fadeBeginTime = this._fadeCurrentTime;
              this._fadeTotalTime = fadeTotalTime * this._timeScale;
              this._isPlaying = true;
              this.displayControl = true;
              this.lastFrameAutoTween = true;
              this.additiveBlending = false;
              this.weight = 1;
              this.fadeOutTime = fadeTotalTime;
              this._updateTimelineStates();
              return this;
          };
          p.fadeOut = function (fadeTotalTime, pausePlayhead) {
              if (!this._armature) {
                  return null;
              }
              if (isNaN(fadeTotalTime) || fadeTotalTime < 0) {
                  fadeTotalTime = 0;
              }
              this._pausePlayheadInFade = pausePlayhead;
              if (this._isFadeOut) {
                  if (fadeTotalTime > this._fadeTotalTime / this._timeScale - (this._fadeCurrentTime - this._fadeBeginTime)) {
                      return this;
                  }
              }
              else {
                  for (var i = 0, len = this._timelineStateList.length; i < len; i++) {
                      var timelineState = this._timelineStateList[i];
                      timelineState._fadeOut();
                  }
              }
              this._isFadeOut = true;
              this._fadeTotalWeight = this._fadeWeight;
              this._fadeState = -1;
              this._fadeBeginTime = this._fadeCurrentTime;
              this._fadeTotalTime = this._fadeTotalWeight >= 0 ? fadeTotalTime * this._timeScale : 0;
              this.displayControl = false;
              return this;
          };
          p._advanceTime = function (passedTime) {
              passedTime *= this._timeScale;
              this.advanceFadeTime(passedTime);
              if (this._fadeWeight) {
                  this.advanceTimelinesTime(passedTime);
              }
              return this._isFadeOut && this._fadeState == 1;
          };
          p.advanceFadeTime = function (passedTime) {
              var fadeStartFlg = false;
              var fadeCompleteFlg = false;
              if (this._fadeBeginTime >= 0) {
                  var fadeState = this._fadeState;
                  this._fadeCurrentTime += passedTime < 0 ? -passedTime : passedTime;
                  if (this._fadeCurrentTime >= this._fadeBeginTime + this._fadeTotalTime) {
                      if (this._fadeWeight == 1 ||
                          this._fadeWeight == 0) {
                          fadeState = 1;
                          if (this._pausePlayheadInFade) {
                              this._pausePlayheadInFade = false;
                              this._currentTime = -1;
                          }
                      }
                      this._fadeWeight = this._isFadeOut ? 0 : 1;
                  }
                  else if (this._fadeCurrentTime >= this._fadeBeginTime) {
                      fadeState = 0;
                      this._fadeWeight = (this._fadeCurrentTime - this._fadeBeginTime) / this._fadeTotalTime * this._fadeTotalWeight;
                      if (this._isFadeOut) {
                          this._fadeWeight = this._fadeTotalWeight - this._fadeWeight;
                      }
                  }
                  else {
                      fadeState = -1;
                      this._fadeWeight = this._isFadeOut ? 1 : 0;
                  }
                  if (this._fadeState != fadeState) {
                      if (this._fadeState == -1) {
                          fadeStartFlg = true;
                      }
                      if (fadeState == 1) {
                          fadeCompleteFlg = true;
                      }
                      this._fadeState = fadeState;
                  }
              }
              var event;
              if (fadeStartFlg) {
                  if (this._isFadeOut) {
                      if (this._armature.hasEventListener(dragonBones.AnimationEvent.FADE_OUT)) {
                          event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.FADE_OUT);
                          event.animationState = this;
                          this._armature._eventList.push(event);
                      }
                  }
                  else {
                      this.hideBones();
                      if (this._armature.hasEventListener(dragonBones.AnimationEvent.FADE_IN)) {
                          event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.FADE_IN);
                          event.animationState = this;
                          this._armature._eventList.push(event);
                      }
                  }
              }
              if (fadeCompleteFlg) {
                  if (this._isFadeOut) {
                      if (this._armature.hasEventListener(dragonBones.AnimationEvent.FADE_OUT_COMPLETE)) {
                          event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.FADE_OUT_COMPLETE);
                          event.animationState = this;
                          this._armature._eventList.push(event);
                      }
                  }
                  else {
                      if (this._armature.hasEventListener(dragonBones.AnimationEvent.FADE_IN_COMPLETE)) {
                          event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.FADE_IN_COMPLETE);
                          event.animationState = this;
                          this._armature._eventList.push(event);
                      }
                  }
              }
          };
          p.advanceTimelinesTime = function (passedTime) {
              if (this._isPlaying && !this._pausePlayheadInFade) {
                  this._time += passedTime;
              }
              var startFlg = false;
              var completeFlg = false;
              var loopCompleteFlg = false;
              var isThisComplete = false;
              var currentPlayTimes = 0;
              var currentTime = this._time * 1000;
              if (this._playTimes == 0) {
                  isThisComplete = false;
                  currentPlayTimes = Math.ceil(Math.abs(currentTime) / this._totalTime) || 1;
                  if (currentTime >= 0) {
                      currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  }
                  else {
                      currentTime -= Math.ceil(currentTime / this._totalTime) * this._totalTime;
                  }
                  if (currentTime < 0) {
                      currentTime += this._totalTime;
                  }
              }
              else {
                  var totalTimes = this._playTimes * this._totalTime;
                  if (currentTime >= totalTimes) {
                      currentTime = totalTimes;
                      isThisComplete = true;
                  }
                  else if (currentTime <= -totalTimes) {
                      currentTime = -totalTimes;
                      isThisComplete = true;
                  }
                  else {
                      isThisComplete = false;
                  }
                  if (currentTime < 0) {
                      currentTime += totalTimes;
                  }
                  currentPlayTimes = Math.ceil(currentTime / this._totalTime) || 1;
                  if (currentTime >= 0) {
                      currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  }
                  else {
                      currentTime -= Math.ceil(currentTime / this._totalTime) * this._totalTime;
                  }
                  if (isThisComplete) {
                      currentTime = this._totalTime;
                  }
              }
              this._isComplete = isThisComplete;
              var progress = this._time * 1000 / this._totalTime;
              var i = 0;
              var len = 0;
              for (i = 0, len = this._timelineStateList.length; i < len; i++) {
                  var timeline = this._timelineStateList[i];
                  timeline._update(progress);
                  this._isComplete = timeline._isComplete && this._isComplete;
              }
              for (i = 0, len = this._slotTimelineStateList.length; i < len; i++) {
                  var slotTimeline = this._slotTimelineStateList[i];
                  slotTimeline._update(progress);
                  this._isComplete = timeline._isComplete && this._isComplete;
              }
              if (this._currentTime != currentTime) {
                  if (this._currentPlayTimes != currentPlayTimes) {
                      if (this._currentPlayTimes > 0 && currentPlayTimes > 1) {
                          loopCompleteFlg = true;
                      }
                      this._currentPlayTimes = currentPlayTimes;
                  }
                  if (this._currentTime < 0) {
                      startFlg = true;
                  }
                  if (this._isComplete) {
                      completeFlg = true;
                  }
                  this._lastTime = this._currentTime;
                  this._currentTime = currentTime;
                  this.updateMainTimeline(isThisComplete);
              }
              var event;
              if (startFlg) {
                  if (this._armature.hasEventListener(dragonBones.AnimationEvent.START)) {
                      event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.START);
                      event.animationState = this;
                      this._armature._eventList.push(event);
                  }
              }
              if (completeFlg) {
                  if (this._armature.hasEventListener(dragonBones.AnimationEvent.COMPLETE)) {
                      event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.COMPLETE);
                      event.animationState = this;
                      this._armature._eventList.push(event);
                  }
                  if (this.autoFadeOut) {
                      this.fadeOut(this.fadeOutTime, true);
                  }
              }
              else if (loopCompleteFlg) {
                  if (this._armature.hasEventListener(dragonBones.AnimationEvent.LOOP_COMPLETE)) {
                      event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.LOOP_COMPLETE);
                      event.animationState = this;
                      this._armature._eventList.push(event);
                  }
              }
          };
          p.updateMainTimeline = function (isThisComplete) {
              var frameList = this._clip.frameList;
              if (frameList.length > 0) {
                  var prevFrame;
                  var currentFrame;
                  for (var i = 0, l = this._clip.frameList.length; i < l; ++i) {
                      if (this._currentFrameIndex < 0) {
                          this._currentFrameIndex = 0;
                      }
                      else if (this._currentTime < this._currentFramePosition || this._currentTime >= this._currentFramePosition + this._currentFrameDuration || this._currentTime < this._lastTime) {
                          this._currentFrameIndex++;
                          this._lastTime = this._currentTime;
                          if (this._currentFrameIndex >= frameList.length) {
                              if (isThisComplete) {
                                  this._currentFrameIndex--;
                                  break;
                              }
                              else {
                                  this._currentFrameIndex = 0;
                              }
                          }
                      }
                      else {
                          break;
                      }
                      currentFrame = frameList[this._currentFrameIndex];
                      if (prevFrame) {
                          this._armature._arriveAtFrame(prevFrame, null, this, true);
                      }
                      this._currentFrameDuration = currentFrame.duration;
                      this._currentFramePosition = currentFrame.position;
                      prevFrame = currentFrame;
                  }
                  if (currentFrame) {
                      this._armature._arriveAtFrame(currentFrame, null, this, false);
                  }
              }
          };
          p.hideBones = function () {
              for (var i = 0, len = this._clip.hideTimelineNameMap.length; i < len; i++) {
                  var timelineName = this._clip.hideTimelineNameMap[i];
                  var bone = this._armature.getBone(timelineName);
                  if (bone) {
                      bone._hideSlots();
                  }
              }
              var slotTimelineName;
              for (i = 0, len = this._clip.hideSlotTimelineNameMap.length; i < len; i++) {
                  slotTimelineName = this._clip.hideSlotTimelineNameMap[i];
                  var slot = this._armature.getSlot(slotTimelineName);
                  if (slot) {
                      slot._resetToOrigin();
                  }
              }
          };
          p.setAdditiveBlending = function (value) {
              this.additiveBlending = value;
              return this;
          };
          p.setAutoFadeOut = function (value, fadeOutTime) {
              if (fadeOutTime === void 0) { fadeOutTime = -1; }
              this.autoFadeOut = value;
              if (fadeOutTime >= 0) {
                  this.fadeOutTime = fadeOutTime * this._timeScale;
              }
              return this;
          };
          p.setWeight = function (value) {
              if (isNaN(value) || value < 0) {
                  value = 1;
              }
              this.weight = value;
              return this;
          };
          p.setFrameTween = function (autoTween, lastFrameAutoTween) {
              this.autoTween = autoTween;
              this.lastFrameAutoTween = lastFrameAutoTween;
              return this;
          };
          p.setCurrentTime = function (value) {
              if (value < 0 || isNaN(value)) {
                  value = 0;
              }
              this._time = value;
              this._currentTime = this._time * 1000;
              return this;
          };
          p.setTimeScale = function (value) {
              if (isNaN(value) || value == Infinity) {
                  value = 1;
              }
              this._timeScale = value;
              return this;
          };
          p.setPlayTimes = function (value) {
              if (value === void 0) { value = 0; }
              if (Math.round(this._totalTime * 0.001 * this._clip.frameRate) < 2) {
                  this._playTimes = value < 0 ? -1 : 1;
              }
              else {
                  this._playTimes = value < 0 ? -value : value;
              }
              this.autoFadeOut = value < 0 ? true : false;
              return this;
          };
          d(p, "name"
              ,function () {
                  return this._name;
              }
          );
          d(p, "layer"
              ,function () {
                  return this._layer;
              }
          );
          d(p, "group"
              ,function () {
                  return this._group;
              }
          );
          d(p, "clip"
              ,function () {
                  return this._clip;
              }
          );
          d(p, "isComplete"
              ,function () {
                  return this._isComplete;
              }
          );
          d(p, "isPlaying"
              ,function () {
                  return (this._isPlaying && !this._isComplete);
              }
          );
          d(p, "currentPlayTimes"
              ,function () {
                  return this._currentPlayTimes < 0 ? 0 : this._currentPlayTimes;
              }
          );
          d(p, "totalTime"
              ,function () {
                  return this._totalTime * 0.001;
              }
          );
          d(p, "currentTime"
              ,function () {
                  return this._currentTime < 0 ? 0 : this._currentTime * 0.001;
              }
          );
          d(p, "fadeWeight"
              ,function () {
                  return this._fadeWeight;
              }
          );
          d(p, "fadeState"
              ,function () {
                  return this._fadeState;
              }
          );
          d(p, "fadeTotalTime"
              ,function () {
                  return this._fadeTotalTime;
              }
          );
          d(p, "timeScale"
              ,function () {
                  return this._timeScale;
              }
          );
          d(p, "playTimes"
              ,function () {
                  return this._playTimes;
              }
          );
          AnimationState._pool = [];
          return AnimationState;
      })();
      dragonBones.AnimationState = AnimationState;
      egret.registerClass(AnimationState,'dragonBones.AnimationState');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SlotTimelineState = (function () {
          function SlotTimelineState() {
              this._totalTime = 0;
              this._currentTime = 0;
              this._currentFrameIndex = 0;
              this._currentFramePosition = 0;
              this._currentFrameDuration = 0;
              this._updateMode = 0;
              this._durationColor = new dragonBones.ColorTransform();
          }
          var d = __define,c=SlotTimelineState,p=c.prototype;
          SlotTimelineState._borrowObject = function () {
              if (SlotTimelineState._pool.length == 0) {
                  return new SlotTimelineState();
              }
              return SlotTimelineState._pool.pop();
          };
          SlotTimelineState._returnObject = function (timeline) {
              if (SlotTimelineState._pool.indexOf(timeline) < 0) {
                  SlotTimelineState._pool[SlotTimelineState._pool.length] = timeline;
              }
              timeline.clear();
          };
          SlotTimelineState._clear = function () {
              var i = SlotTimelineState._pool.length;
              while (i--) {
                  SlotTimelineState._pool[i].clear();
              }
              SlotTimelineState._pool.length = 0;
          };
          p.clear = function () {
              if (this._slot) {
                  this._slot._removeState(this);
                  this._slot = null;
              }
              this._armature = null;
              this._animation = null;
              this._animationState = null;
              this._timelineData = null;
          };
          p._fadeIn = function (slot, animationState, timelineData) {
              this._slot = slot;
              this._armature = this._slot.armature;
              this._animation = this._armature.animation;
              this._animationState = animationState;
              this._timelineData = timelineData;
              this.name = timelineData.name;
              this._totalTime = this._timelineData.duration;
              this._rawAnimationScale = this._animationState.clip.scale;
              this._isComplete = false;
              this._blendEnabled = false;
              this._tweenColor = false;
              this._currentFrameIndex = -1;
              this._currentTime = -1;
              this._tweenEasing = NaN;
              this._weight = 1;
              switch (this._timelineData.frameList.length) {
                  case 0:
                      this._updateMode = 0;
                      break;
                  case 1:
                      this._updateMode = 1;
                      break;
                  default:
                      this._updateMode = -1;
                      break;
              }
              this._slot._addState(this);
          };
          p._fadeOut = function () {
          };
          p._update = function (progress) {
              if (this._updateMode == -1) {
                  this.updateMultipleFrame(progress);
              }
              else if (this._updateMode == 1) {
                  this._updateMode = 0;
                  this.updateSingleFrame();
              }
          };
          p.updateMultipleFrame = function (progress) {
              var currentPlayTimes = 0;
              progress /= this._timelineData.scale;
              progress += this._timelineData.offset;
              var currentTime = this._totalTime * progress;
              var playTimes = this._animationState.playTimes;
              if (playTimes == 0) {
                  this._isComplete = false;
                  currentPlayTimes = Math.ceil(Math.abs(currentTime) / this._totalTime) || 1;
                  if (currentTime >= 0) {
                      currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  }
                  else {
                      currentTime -= Math.ceil(currentTime / this._totalTime) * this._totalTime;
                  }
                  if (currentTime < 0) {
                      currentTime += this._totalTime;
                  }
              }
              else {
                  var totalTimes = playTimes * this._totalTime;
                  if (currentTime >= totalTimes) {
                      currentTime = totalTimes;
                      this._isComplete = true;
                  }
                  else if (currentTime <= -totalTimes) {
                      currentTime = -totalTimes;
                      this._isComplete = true;
                  }
                  else {
                      this._isComplete = false;
                  }
                  if (currentTime < 0) {
                      currentTime += totalTimes;
                  }
                  currentPlayTimes = Math.ceil(currentTime / this._totalTime) || 1;
                  if (this._isComplete) {
                      currentTime = this._totalTime;
                  }
                  else {
                      if (currentTime >= 0) {
                          currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                      }
                      else {
                          currentTime -= Math.ceil(currentTime / this._totalTime) * this._totalTime;
                      }
                  }
              }
              if (this._currentTime != currentTime) {
                  this._currentTime = currentTime;
                  var frameList = this._timelineData.frameList;
                  var prevFrame;
                  var currentFrame;
                  for (var i = 0, l = this._timelineData.frameList.length; i < l; ++i) {
                      if (this._currentFrameIndex < 0) {
                          this._currentFrameIndex = 0;
                      }
                      else if (this._currentTime < this._currentFramePosition || this._currentTime >= this._currentFramePosition + this._currentFrameDuration) {
                          this._currentFrameIndex++;
                          if (this._currentFrameIndex >= frameList.length) {
                              if (this._isComplete) {
                                  this._currentFrameIndex--;
                                  break;
                              }
                              else {
                                  this._currentFrameIndex = 0;
                              }
                          }
                      }
                      else {
                          break;
                      }
                      currentFrame = (frameList[this._currentFrameIndex]);
                      if (prevFrame) {
                          this._slot._arriveAtFrame(prevFrame, this, this._animationState, true);
                      }
                      this._currentFrameDuration = currentFrame.duration;
                      this._currentFramePosition = currentFrame.position;
                      prevFrame = currentFrame;
                  }
                  if (currentFrame) {
                      this._slot._arriveAtFrame(currentFrame, this, this._animationState, false);
                      this._blendEnabled = currentFrame.displayIndex >= 0;
                      if (this._blendEnabled) {
                          this.updateToNextFrame(currentPlayTimes);
                      }
                      else {
                          this._tweenEasing = NaN;
                          this._tweenColor = false;
                      }
                  }
                  if (this._blendEnabled) {
                      this.updateTween();
                  }
              }
          };
          p.updateToNextFrame = function (currentPlayTimes) {
              if (currentPlayTimes === void 0) { currentPlayTimes = 0; }
              var nextFrameIndex = this._currentFrameIndex + 1;
              if (nextFrameIndex >= this._timelineData.frameList.length) {
                  nextFrameIndex = 0;
              }
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              var nextFrame = (this._timelineData.frameList[nextFrameIndex]);
              var tweenEnabled = false;
              if (nextFrameIndex == 0 &&
                  (!this._animationState.lastFrameAutoTween ||
                      (this._animationState.playTimes &&
                          this._animationState.currentPlayTimes >= this._animationState.playTimes &&
                          ((this._currentFramePosition + this._currentFrameDuration) / this._totalTime + currentPlayTimes - this._timelineData.offset) * this._timelineData.scale > 0.999999))) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (currentFrame.displayIndex < 0 || nextFrame.displayIndex < 0) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (this._animationState.autoTween) {
                  this._tweenEasing = this._animationState.clip.tweenEasing;
                  if (isNaN(this._tweenEasing)) {
                      this._tweenEasing = currentFrame.tweenEasing;
                      this._tweenCurve = currentFrame.curve;
                      if (isNaN(this._tweenEasing) && this._tweenCurve == null) {
                          tweenEnabled = false;
                      }
                      else {
                          if (this._tweenEasing == 10) {
                              this._tweenEasing = 0;
                          }
                          tweenEnabled = true;
                      }
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              else {
                  this._tweenEasing = currentFrame.tweenEasing;
                  this._tweenCurve = currentFrame.curve;
                  if ((isNaN(this._tweenEasing) || this._tweenEasing == 10) && this._tweenCurve == null) {
                      this._tweenEasing = NaN;
                      tweenEnabled = false;
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              if (tweenEnabled) {
                  if (currentFrame.color && nextFrame.color) {
                      this._durationColor.alphaOffset = nextFrame.color.alphaOffset - currentFrame.color.alphaOffset;
                      this._durationColor.redOffset = nextFrame.color.redOffset - currentFrame.color.redOffset;
                      this._durationColor.greenOffset = nextFrame.color.greenOffset - currentFrame.color.greenOffset;
                      this._durationColor.blueOffset = nextFrame.color.blueOffset - currentFrame.color.blueOffset;
                      this._durationColor.alphaMultiplier = nextFrame.color.alphaMultiplier - currentFrame.color.alphaMultiplier;
                      this._durationColor.redMultiplier = nextFrame.color.redMultiplier - currentFrame.color.redMultiplier;
                      this._durationColor.greenMultiplier = nextFrame.color.greenMultiplier - currentFrame.color.greenMultiplier;
                      this._durationColor.blueMultiplier = nextFrame.color.blueMultiplier - currentFrame.color.blueMultiplier;
                      if (this._durationColor.alphaOffset ||
                          this._durationColor.redOffset ||
                          this._durationColor.greenOffset ||
                          this._durationColor.blueOffset ||
                          this._durationColor.alphaMultiplier ||
                          this._durationColor.redMultiplier ||
                          this._durationColor.greenMultiplier ||
                          this._durationColor.blueMultiplier) {
                          this._tweenColor = true;
                      }
                      else {
                          this._tweenColor = false;
                      }
                  }
                  else if (currentFrame.color) {
                      this._tweenColor = true;
                      this._durationColor.alphaOffset = -currentFrame.color.alphaOffset;
                      this._durationColor.redOffset = -currentFrame.color.redOffset;
                      this._durationColor.greenOffset = -currentFrame.color.greenOffset;
                      this._durationColor.blueOffset = -currentFrame.color.blueOffset;
                      this._durationColor.alphaMultiplier = 1 - currentFrame.color.alphaMultiplier;
                      this._durationColor.redMultiplier = 1 - currentFrame.color.redMultiplier;
                      this._durationColor.greenMultiplier = 1 - currentFrame.color.greenMultiplier;
                      this._durationColor.blueMultiplier = 1 - currentFrame.color.blueMultiplier;
                  }
                  else if (nextFrame.color) {
                      this._tweenColor = true;
                      this._durationColor.alphaOffset = nextFrame.color.alphaOffset;
                      this._durationColor.redOffset = nextFrame.color.redOffset;
                      this._durationColor.greenOffset = nextFrame.color.greenOffset;
                      this._durationColor.blueOffset = nextFrame.color.blueOffset;
                      this._durationColor.alphaMultiplier = nextFrame.color.alphaMultiplier - 1;
                      this._durationColor.redMultiplier = nextFrame.color.redMultiplier - 1;
                      this._durationColor.greenMultiplier = nextFrame.color.greenMultiplier - 1;
                      this._durationColor.blueMultiplier = nextFrame.color.blueMultiplier - 1;
                  }
                  else {
                      this._tweenColor = false;
                  }
              }
              else {
                  this._tweenColor = false;
              }
              if (!this._tweenColor && this._animationState.displayControl) {
                  if (currentFrame.color) {
                      this._slot._updateDisplayColor(currentFrame.color.alphaOffset, currentFrame.color.redOffset, currentFrame.color.greenOffset, currentFrame.color.blueOffset, currentFrame.color.alphaMultiplier, currentFrame.color.redMultiplier, currentFrame.color.greenMultiplier, currentFrame.color.blueMultiplier, true);
                  }
                  else if (this._slot._isColorChanged) {
                      this._slot._updateDisplayColor(0, 0, 0, 0, 1, 1, 1, 1, false);
                  }
              }
          };
          p.updateTween = function () {
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              if (this._tweenColor && this._animationState.displayControl) {
                  var progress = (this._currentTime - this._currentFramePosition) / this._currentFrameDuration;
                  if (this._tweenCurve != null) {
                      progress = this._tweenCurve.getValueByProgress(progress);
                  }
                  else if (this._tweenEasing) {
                      progress = dragonBones.MathUtil.getEaseValue(progress, this._tweenEasing);
                  }
                  if (currentFrame.color) {
                      this._slot._updateDisplayColor(currentFrame.color.alphaOffset + this._durationColor.alphaOffset * progress, currentFrame.color.redOffset + this._durationColor.redOffset * progress, currentFrame.color.greenOffset + this._durationColor.greenOffset * progress, currentFrame.color.blueOffset + this._durationColor.blueOffset * progress, currentFrame.color.alphaMultiplier + this._durationColor.alphaMultiplier * progress, currentFrame.color.redMultiplier + this._durationColor.redMultiplier * progress, currentFrame.color.greenMultiplier + this._durationColor.greenMultiplier * progress, currentFrame.color.blueMultiplier + this._durationColor.blueMultiplier * progress, true);
                  }
                  else {
                      this._slot._updateDisplayColor(this._durationColor.alphaOffset * progress, this._durationColor.redOffset * progress, this._durationColor.greenOffset * progress, this._durationColor.blueOffset * progress, 1 + this._durationColor.alphaMultiplier * progress, 1 + this._durationColor.redMultiplier * progress, 1 + this._durationColor.greenMultiplier * progress, 1 + this._durationColor.blueMultiplier * progress, true);
                  }
              }
          };
          p.updateSingleFrame = function () {
              var currentFrame = (this._timelineData.frameList[0]);
              this._slot._arriveAtFrame(currentFrame, this, this._animationState, false);
              this._isComplete = true;
              this._tweenEasing = NaN;
              this._tweenColor = false;
              this._blendEnabled = currentFrame.displayIndex >= 0;
              if (this._blendEnabled) {
                  if (this._animationState.displayControl) {
                      if (currentFrame.color) {
                          this._slot._updateDisplayColor(currentFrame.color.alphaOffset, currentFrame.color.redOffset, currentFrame.color.greenOffset, currentFrame.color.blueOffset, currentFrame.color.alphaMultiplier, currentFrame.color.redMultiplier, currentFrame.color.greenMultiplier, currentFrame.color.blueMultiplier, true);
                      }
                      else if (this._slot._isColorChanged) {
                          this._slot._updateDisplayColor(0, 0, 0, 0, 1, 1, 1, 1, false);
                      }
                  }
              }
          };
          SlotTimelineState.HALF_PI = Math.PI * 0.5;
          SlotTimelineState.DOUBLE_PI = Math.PI * 2;
          SlotTimelineState._pool = [];
          return SlotTimelineState;
      })();
      dragonBones.SlotTimelineState = SlotTimelineState;
      egret.registerClass(SlotTimelineState,'dragonBones.SlotTimelineState');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var TimelineState = (function () {
          function TimelineState() {
              this._totalTime = 0;
              this._currentTime = 0;
              this._lastTime = 0;
              this._currentFrameIndex = 0;
              this._currentFramePosition = 0;
              this._currentFrameDuration = 0;
              this._updateMode = 0;
              this._transform = new dragonBones.DBTransform();
              this._pivot = new dragonBones.Point();
              this._durationTransform = new dragonBones.DBTransform();
              this._durationPivot = new dragonBones.Point();
              this._durationColor = new dragonBones.ColorTransform();
          }
          var d = __define,c=TimelineState,p=c.prototype;
          TimelineState._borrowObject = function () {
              if (TimelineState._pool.length == 0) {
                  return new TimelineState();
              }
              return TimelineState._pool.pop();
          };
          TimelineState._returnObject = function (timeline) {
              if (TimelineState._pool.indexOf(timeline) < 0) {
                  TimelineState._pool[TimelineState._pool.length] = timeline;
              }
              timeline.clear();
          };
          TimelineState._clear = function () {
              var i = TimelineState._pool.length;
              while (i--) {
                  TimelineState._pool[i].clear();
              }
              TimelineState._pool.length = 0;
          };
          p.clear = function () {
              if (this._bone) {
                  this._bone._removeState(this);
                  this._bone = null;
              }
              this._armature = null;
              this._animation = null;
              this._animationState = null;
              this._timelineData = null;
              this._originTransform = null;
              this._originPivot = null;
          };
          p._fadeIn = function (bone, animationState, timelineData) {
              this._bone = bone;
              this._armature = this._bone.armature;
              this._animation = this._armature.animation;
              this._animationState = animationState;
              this._timelineData = timelineData;
              this._originTransform = this._timelineData.originTransform;
              this._originPivot = this._timelineData.originPivot;
              this.name = timelineData.name;
              this._totalTime = this._timelineData.duration;
              this._rawAnimationScale = this._animationState.clip.scale;
              this._isComplete = false;
              this._tweenTransform = false;
              this._tweenScale = false;
              this._currentFrameIndex = -1;
              this._currentTime = -1;
              this._tweenEasing = NaN;
              this._weight = 1;
              this._transform.x = 0;
              this._transform.y = 0;
              this._transform.scaleX = 1;
              this._transform.scaleY = 1;
              this._transform.skewX = 0;
              this._transform.skewY = 0;
              this._pivot.x = 0;
              this._pivot.y = 0;
              this._durationTransform.x = 0;
              this._durationTransform.y = 0;
              this._durationTransform.scaleX = 1;
              this._durationTransform.scaleY = 1;
              this._durationTransform.skewX = 0;
              this._durationTransform.skewY = 0;
              this._durationPivot.x = 0;
              this._durationPivot.y = 0;
              switch (this._timelineData.frameList.length) {
                  case 0:
                      this._updateMode = 0;
                      break;
                  case 1:
                      this._updateMode = 1;
                      break;
                  default:
                      this._updateMode = -1;
                      break;
              }
              this._bone._addState(this);
          };
          p._fadeOut = function () {
              this._transform.skewX = dragonBones.TransformUtil.formatRadian(this._transform.skewX);
              this._transform.skewY = dragonBones.TransformUtil.formatRadian(this._transform.skewY);
          };
          p._update = function (progress) {
              if (this._updateMode == -1) {
                  this.updateMultipleFrame(progress);
              }
              else if (this._updateMode == 1) {
                  this._updateMode = 0;
                  this.updateSingleFrame();
              }
          };
          p.updateMultipleFrame = function (progress) {
              var currentPlayTimes = 0;
              progress /= this._timelineData.scale;
              progress += this._timelineData.offset;
              var currentTime = this._totalTime * progress;
              var playTimes = this._animationState.playTimes;
              if (playTimes == 0) {
                  this._isComplete = false;
                  currentPlayTimes = Math.ceil(Math.abs(currentTime) / this._totalTime) || 1;
                  if (currentTime >= 0) {
                      currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  }
                  else {
                      currentTime -= Math.ceil(currentTime / this._totalTime) * this._totalTime;
                  }
                  if (currentTime < 0) {
                      currentTime += this._totalTime;
                  }
              }
              else {
                  var totalTimes = playTimes * this._totalTime;
                  if (currentTime >= totalTimes) {
                      currentTime = totalTimes;
                      this._isComplete = true;
                  }
                  else if (currentTime <= -totalTimes) {
                      currentTime = -totalTimes;
                      this._isComplete = true;
                  }
                  else {
                      this._isComplete = false;
                  }
                  if (currentTime < 0) {
                      currentTime += totalTimes;
                  }
                  currentPlayTimes = Math.ceil(currentTime / this._totalTime) || 1;
                  if (this._isComplete) {
                      currentTime = this._totalTime;
                  }
                  else {
                      if (currentTime >= 0) {
                          currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                      }
                      else {
                          currentTime -= Math.ceil(currentTime / this._totalTime) * this._totalTime;
                      }
                  }
              }
              if (this._currentTime != currentTime) {
                  this._lastTime = this._currentTime;
                  this._currentTime = currentTime;
                  var frameList = this._timelineData.frameList;
                  var prevFrame;
                  var currentFrame;
                  for (var i = 0, l = this._timelineData.frameList.length; i < l; ++i) {
                      if (this._currentFrameIndex < 0) {
                          this._currentFrameIndex = 0;
                      }
                      else if (this._currentTime < this._currentFramePosition || this._currentTime >= this._currentFramePosition + this._currentFrameDuration || this._currentTime < this._lastTime) {
                          this._currentFrameIndex++;
                          this._lastTime = this._currentTime;
                          if (this._currentFrameIndex >= frameList.length) {
                              if (this._isComplete) {
                                  this._currentFrameIndex--;
                                  break;
                              }
                              else {
                                  this._currentFrameIndex = 0;
                              }
                          }
                      }
                      else {
                          break;
                      }
                      currentFrame = (frameList[this._currentFrameIndex]);
                      if (prevFrame) {
                          this._bone._arriveAtFrame(prevFrame, this, this._animationState, true);
                      }
                      this._currentFrameDuration = currentFrame.duration;
                      this._currentFramePosition = currentFrame.position;
                      prevFrame = currentFrame;
                  }
                  if (currentFrame) {
                      this._bone._arriveAtFrame(currentFrame, this, this._animationState, false);
                      this.updateToNextFrame(currentPlayTimes);
                  }
                  this.updateTween();
              }
          };
          p.updateToNextFrame = function (currentPlayTimes) {
              if (currentPlayTimes === void 0) { currentPlayTimes = 0; }
              var nextFrameIndex = this._currentFrameIndex + 1;
              if (nextFrameIndex >= this._timelineData.frameList.length) {
                  nextFrameIndex = 0;
              }
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              var nextFrame = (this._timelineData.frameList[nextFrameIndex]);
              var tweenEnabled = false;
              if (nextFrameIndex == 0 &&
                  (!this._animationState.lastFrameAutoTween ||
                      (this._animationState.playTimes &&
                          this._animationState.currentPlayTimes >= this._animationState.playTimes &&
                          ((this._currentFramePosition + this._currentFrameDuration) / this._totalTime + currentPlayTimes - this._timelineData.offset) * this._timelineData.scale > 0.999999))) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (currentFrame.displayIndex < 0 || nextFrame.displayIndex < 0) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (this._animationState.autoTween) {
                  this._tweenEasing = this._animationState.clip.tweenEasing;
                  if (isNaN(this._tweenEasing)) {
                      this._tweenEasing = currentFrame.tweenEasing;
                      this._tweenCurve = currentFrame.curve;
                      if (isNaN(this._tweenEasing) && this._tweenCurve == null) {
                          tweenEnabled = false;
                      }
                      else {
                          if (this._tweenEasing == 10) {
                              this._tweenEasing = 0;
                          }
                          tweenEnabled = true;
                      }
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              else {
                  this._tweenEasing = currentFrame.tweenEasing;
                  this._tweenCurve = currentFrame.curve;
                  if ((isNaN(this._tweenEasing) || this._tweenEasing == 10) && this._tweenCurve == null) {
                      this._tweenEasing = NaN;
                      tweenEnabled = false;
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              if (tweenEnabled) {
                  this._durationTransform.x = nextFrame.transform.x - currentFrame.transform.x;
                  this._durationTransform.y = nextFrame.transform.y - currentFrame.transform.y;
                  this._durationTransform.skewX = nextFrame.transform.skewX - currentFrame.transform.skewX;
                  this._durationTransform.skewY = nextFrame.transform.skewY - currentFrame.transform.skewY;
                  this._durationTransform.scaleX = nextFrame.transform.scaleX - currentFrame.transform.scaleX + nextFrame.scaleOffset.x;
                  this._durationTransform.scaleY = nextFrame.transform.scaleY - currentFrame.transform.scaleY + nextFrame.scaleOffset.y;
                  this._durationTransform.normalizeRotation();
                  if (nextFrameIndex == 0) {
                      this._durationTransform.skewX = dragonBones.TransformUtil.formatRadian(this._durationTransform.skewX);
                      this._durationTransform.skewY = dragonBones.TransformUtil.formatRadian(this._durationTransform.skewY);
                  }
                  this._durationPivot.x = nextFrame.pivot.x - currentFrame.pivot.x;
                  this._durationPivot.y = nextFrame.pivot.y - currentFrame.pivot.y;
                  if (this._durationTransform.x ||
                      this._durationTransform.y ||
                      this._durationTransform.skewX ||
                      this._durationTransform.skewY ||
                      this._durationTransform.scaleX ||
                      this._durationTransform.scaleY ||
                      this._durationPivot.x ||
                      this._durationPivot.y) {
                      this._tweenTransform = true;
                      this._tweenScale = currentFrame.tweenScale;
                  }
                  else {
                      this._tweenTransform = false;
                      this._tweenScale = false;
                  }
              }
              else {
                  this._tweenTransform = false;
                  this._tweenScale = false;
              }
              if (!this._tweenTransform) {
                  if (this._animationState.additiveBlending) {
                      this._transform.x = currentFrame.transform.x;
                      this._transform.y = currentFrame.transform.y;
                      this._transform.skewX = currentFrame.transform.skewX;
                      this._transform.skewY = currentFrame.transform.skewY;
                      this._transform.scaleX = currentFrame.transform.scaleX;
                      this._transform.scaleY = currentFrame.transform.scaleY;
                      this._pivot.x = currentFrame.pivot.x;
                      this._pivot.y = currentFrame.pivot.y;
                  }
                  else {
                      this._transform.x = this._originTransform.x + currentFrame.transform.x;
                      this._transform.y = this._originTransform.y + currentFrame.transform.y;
                      this._transform.skewX = this._originTransform.skewX + currentFrame.transform.skewX;
                      this._transform.skewY = this._originTransform.skewY + currentFrame.transform.skewY;
                      this._transform.scaleX = this._originTransform.scaleX * currentFrame.transform.scaleX;
                      this._transform.scaleY = this._originTransform.scaleY * currentFrame.transform.scaleY;
                      this._pivot.x = this._originPivot.x + currentFrame.pivot.x;
                      this._pivot.y = this._originPivot.y + currentFrame.pivot.y;
                  }
                  this._bone.invalidUpdate();
              }
              else if (!this._tweenScale) {
                  if (this._animationState.additiveBlending) {
                      this._transform.scaleX = currentFrame.transform.scaleX;
                      this._transform.scaleY = currentFrame.transform.scaleY;
                  }
                  else {
                      this._transform.scaleX = this._originTransform.scaleX * currentFrame.transform.scaleX;
                      this._transform.scaleY = this._originTransform.scaleY * currentFrame.transform.scaleY;
                  }
              }
          };
          p.updateTween = function () {
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              if (this._tweenTransform) {
                  var progress = (this._currentTime - this._currentFramePosition) / this._currentFrameDuration;
                  if (this._tweenCurve != null) {
                      progress = this._tweenCurve.getValueByProgress(progress);
                  }
                  else if (this._tweenEasing) {
                      progress = dragonBones.MathUtil.getEaseValue(progress, this._tweenEasing);
                  }
                  var currentTransform = currentFrame.transform;
                  var currentPivot = currentFrame.pivot;
                  if (this._animationState.additiveBlending) {
                      this._transform.x = currentTransform.x + this._durationTransform.x * progress;
                      this._transform.y = currentTransform.y + this._durationTransform.y * progress;
                      this._transform.skewX = currentTransform.skewX + this._durationTransform.skewX * progress;
                      this._transform.skewY = currentTransform.skewY + this._durationTransform.skewY * progress;
                      if (this._tweenScale) {
                          this._transform.scaleX = currentTransform.scaleX + this._durationTransform.scaleX * progress;
                          this._transform.scaleY = currentTransform.scaleY + this._durationTransform.scaleY * progress;
                      }
                      this._pivot.x = currentPivot.x + this._durationPivot.x * progress;
                      this._pivot.y = currentPivot.y + this._durationPivot.y * progress;
                  }
                  else {
                      this._transform.x = this._originTransform.x + currentTransform.x + this._durationTransform.x * progress;
                      this._transform.y = this._originTransform.y + currentTransform.y + this._durationTransform.y * progress;
                      this._transform.skewX = this._originTransform.skewX + currentTransform.skewX + this._durationTransform.skewX * progress;
                      this._transform.skewY = this._originTransform.skewY + currentTransform.skewY + this._durationTransform.skewY * progress;
                      if (this._tweenScale) {
                          this._transform.scaleX = this._originTransform.scaleX * currentTransform.scaleX + this._durationTransform.scaleX * progress;
                          this._transform.scaleY = this._originTransform.scaleY * currentTransform.scaleY + this._durationTransform.scaleY * progress;
                      }
                      this._pivot.x = this._originPivot.x + currentPivot.x + this._durationPivot.x * progress;
                      this._pivot.y = this._originPivot.y + currentPivot.y + this._durationPivot.y * progress;
                  }
                  this._bone.invalidUpdate();
              }
          };
          p.updateSingleFrame = function () {
              var currentFrame = (this._timelineData.frameList[0]);
              this._bone._arriveAtFrame(currentFrame, this, this._animationState, false);
              this._isComplete = true;
              this._tweenEasing = NaN;
              this._tweenTransform = false;
              this._tweenScale = false;
              this._tweenColor = false;
              if (this._animationState.additiveBlending) {
                  this._transform.x = currentFrame.transform.x;
                  this._transform.y = currentFrame.transform.y;
                  this._transform.skewX = currentFrame.transform.skewX;
                  this._transform.skewY = currentFrame.transform.skewY;
                  this._transform.scaleX = currentFrame.transform.scaleX;
                  this._transform.scaleY = currentFrame.transform.scaleY;
                  this._pivot.x = currentFrame.pivot.x;
                  this._pivot.y = currentFrame.pivot.y;
              }
              else {
                  this._transform.x = this._originTransform.x + currentFrame.transform.x;
                  this._transform.y = this._originTransform.y + currentFrame.transform.y;
                  this._transform.skewX = this._originTransform.skewX + currentFrame.transform.skewX;
                  this._transform.skewY = this._originTransform.skewY + currentFrame.transform.skewY;
                  this._transform.scaleX = this._originTransform.scaleX * currentFrame.transform.scaleX;
                  this._transform.scaleY = this._originTransform.scaleY * currentFrame.transform.scaleY;
                  this._pivot.x = this._originPivot.x + currentFrame.pivot.x;
                  this._pivot.y = this._originPivot.y + currentFrame.pivot.y;
              }
              this._bone.invalidUpdate();
          };
          TimelineState.HALF_PI = Math.PI * 0.5;
          TimelineState.DOUBLE_PI = Math.PI * 2;
          TimelineState._pool = [];
          return TimelineState;
      })();
      dragonBones.TimelineState = TimelineState;
      egret.registerClass(TimelineState,'dragonBones.TimelineState');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var WorldClock = (function () {
          function WorldClock(time, timeScale) {
              if (time === void 0) { time = -1; }
              if (timeScale === void 0) { timeScale = 1; }
              this._time = time >= 0 ? time : new Date().getTime() * 0.001;
              this._timeScale = isNaN(timeScale) ? 1 : timeScale;
              this._animatableList = [];
          }
          var d = __define,c=WorldClock,p=c.prototype;
          d(p, "time"
              ,function () {
                  return this._time;
              }
          );
          d(p, "timeScale"
              ,function () {
                  return this._timeScale;
              }
              ,function (value) {
                  if (isNaN(value) || value < 0) {
                      value = 1;
                  }
                  this._timeScale = value;
              }
          );
          p.contains = function (animatable) {
              return this._animatableList.indexOf(animatable) >= 0;
          };
          p.add = function (animatable) {
              if (animatable && this._animatableList.indexOf(animatable) == -1) {
                  this._animatableList.push(animatable);
              }
          };
          p.remove = function (animatable) {
              var index = this._animatableList.indexOf(animatable);
              if (index >= 0) {
                  this._animatableList[index] = null;
              }
          };
          p.clear = function () {
              this._animatableList.length = 0;
          };
          p.advanceTime = function (passedTime) {
              if (passedTime === void 0) { passedTime = -1; }
              if (passedTime < 0) {
                  passedTime = new Date().getTime() * 0.001 - this._time;
              }
              passedTime *= this._timeScale;
              this._time += passedTime;
              var length = this._animatableList.length;
              if (length == 0) {
                  return;
              }
              var currentIndex = 0;
              for (var i = 0; i < length; i++) {
                  var animatable = this._animatableList[i];
                  if (animatable) {
                      if (currentIndex != i) {
                          this._animatableList[currentIndex] = animatable;
                          this._animatableList[i] = null;
                      }
                      animatable.advanceTime(passedTime);
                      currentIndex++;
                  }
              }
              if (currentIndex != i) {
                  length = this._animatableList.length;
                  while (i < length) {
                      this._animatableList[currentIndex++] = this._animatableList[i++];
                  }
                  this._animatableList.length = currentIndex;
              }
          };
          WorldClock.clock = new WorldClock();
          return WorldClock;
      })();
      dragonBones.WorldClock = WorldClock;
      egret.registerClass(WorldClock,'dragonBones.WorldClock',["dragonBones.IAnimatable"]);
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var EventDispatcher = (function (_super) {
          __extends(EventDispatcher, _super);
          function EventDispatcher(target) {
              if (target === void 0) { target = null; }
              _super.call(this, target);
          }
          var d = __define,c=EventDispatcher,p=c.prototype;
          return EventDispatcher;
      })(egret.EventDispatcher);
      dragonBones.EventDispatcher = EventDispatcher;
      egret.registerClass(EventDispatcher,'dragonBones.EventDispatcher');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SoundEventManager = (function (_super) {
          __extends(SoundEventManager, _super);
          function SoundEventManager() {
              _super.call(this);
              if (SoundEventManager._instance) {
                  throw new Error("Singleton already constructed!");
              }
          }
          var d = __define,c=SoundEventManager,p=c.prototype;
          SoundEventManager.getInstance = function () {
              if (!SoundEventManager._instance) {
                  SoundEventManager._instance = new SoundEventManager();
              }
              return SoundEventManager._instance;
          };
          return SoundEventManager;
      })(dragonBones.EventDispatcher);
      dragonBones.SoundEventManager = SoundEventManager;
      egret.registerClass(SoundEventManager,'dragonBones.SoundEventManager');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Armature = (function (_super) {
          __extends(Armature, _super);
          function Armature(display) {
              _super.call(this);
              this._display = display;
              this._animation = new dragonBones.Animation(this);
              this._slotsZOrderChanged = false;
              this._slotList = [];
              this._boneList = [];
              this._eventList = [];
              this._delayDispose = false;
              this._lockDispose = false;
              this._armatureData = null;
          }
          var d = __define,c=Armature,p=c.prototype;
          d(p, "armatureData"
              ,function () {
                  return this._armatureData;
              }
          );
          d(p, "display"
              ,function () {
                  return this._display;
              }
          );
          p.getDisplay = function () {
              return this._display;
          };
          d(p, "animation"
              ,function () {
                  return this._animation;
              }
          );
          p.dispose = function () {
              this._delayDispose = true;
              if (!this._animation || this._lockDispose) {
                  return;
              }
              this.userData = null;
              this._animation.dispose();
              var i = this._slotList.length;
              while (i--) {
                  this._slotList[i].dispose();
              }
              i = this._boneList.length;
              while (i--) {
                  this._boneList[i].dispose();
              }
              this._armatureData = null;
              this._animation = null;
              this._slotList = null;
              this._boneList = null;
              this._eventList = null;
          };
          p.invalidUpdate = function (boneName) {
              if (boneName === void 0) { boneName = null; }
              if (boneName) {
                  var bone = this.getBone(boneName);
                  if (bone) {
                      bone.invalidUpdate();
                  }
              }
              else {
                  var i = this._boneList.length;
                  while (i--) {
                      this._boneList[i].invalidUpdate();
                  }
              }
          };
          p.advanceTime = function (passedTime) {
              this._lockDispose = true;
              this._animation._advanceTime(passedTime);
              passedTime *= this._animation.timeScale;
              var isFading = this._animation._isFading;
              var i = this._boneList.length;
              while (i--) {
                  var bone = this._boneList[i];
                  bone._update(isFading);
              }
              i = this._slotList.length;
              while (i--) {
                  var slot = this._slotList[i];
                  slot._update();
                  if (slot._isShowDisplay) {
                      var childArmature = slot.childArmature;
                      if (childArmature) {
                          childArmature.advanceTime(passedTime);
                      }
                  }
              }
              if (this._slotsZOrderChanged) {
                  this.updateSlotsZOrder();
                  if (this.hasEventListener(dragonBones.ArmatureEvent.Z_ORDER_UPDATED)) {
                      this.dispatchEvent(new dragonBones.ArmatureEvent(dragonBones.ArmatureEvent.Z_ORDER_UPDATED));
                  }
              }
              if (this._eventList.length > 0) {
                  for (var i = 0, len = this._eventList.length; i < len; i++) {
                      var event = this._eventList[i];
                      this.dispatchEvent(event);
                  }
                  this._eventList.length = 0;
              }
              this._lockDispose = false;
              if (this._delayDispose) {
                  this.dispose();
              }
          };
          p.resetAnimation = function () {
              this.animation.stop();
              this.animation._resetAnimationStateList();
              for (var i = 0, len = this._boneList.length; i < len; i++) {
                  this._boneList[i]._removeAllStates();
              }
          };
          p.getSlots = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this._slotList.concat() : this._slotList;
          };
          p.getSlot = function (slotName) {
              var length = this._slotList.length;
              for (var i = 0; i < length; i++) {
                  var slot = this._slotList[i];
                  if (slot.name == slotName) {
                      return slot;
                  }
              }
              return null;
          };
          p.getSlotByDisplay = function (displayObj) {
              if (displayObj) {
                  var length = this._slotList.length;
                  for (var i = 0; i < length; i++) {
                      var slot = this._slotList[i];
                      if (slot.display == displayObj) {
                          return slot;
                      }
                  }
              }
              return null;
          };
          p.addSlot = function (slot, boneName) {
              var bone = this.getBone(boneName);
              if (bone) {
                  bone.addSlot(slot);
              }
              else {
                  throw new Error();
              }
          };
          p.removeSlot = function (slot) {
              if (!slot || slot.armature != this) {
                  throw new Error();
              }
              slot.parent.removeSlot(slot);
          };
          p.removeSlotByName = function (slotName) {
              var slot = this.getSlot(slotName);
              if (slot) {
                  this.removeSlot(slot);
              }
              return slot;
          };
          p.getBones = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this._boneList.concat() : this._boneList;
          };
          p.getBone = function (boneName) {
              var length = this._boneList.length;
              for (var i = 0; i < length; i++) {
                  var bone = this._boneList[i];
                  if (bone.name == boneName) {
                      return bone;
                  }
              }
              return null;
          };
          p.getBoneByDisplay = function (display) {
              var slot = this.getSlotByDisplay(display);
              return slot ? slot.parent : null;
          };
          p.addBone = function (bone, parentName, updateLater) {
              if (parentName === void 0) { parentName = null; }
              if (updateLater === void 0) { updateLater = false; }
              var parentBone;
              if (parentName) {
                  parentBone = this.getBone(parentName);
                  if (!parentBone) {
                      throw new Error();
                  }
              }
              if (parentBone) {
                  parentBone.addChildBone(bone, updateLater);
              }
              else {
                  if (bone.parent) {
                      bone.parent.removeChildBone(bone, updateLater);
                  }
                  bone._setArmature(this);
                  if (!updateLater) {
                      this._updateAnimationAfterBoneListChanged();
                  }
              }
          };
          p.removeBone = function (bone, updateLater) {
              if (updateLater === void 0) { updateLater = false; }
              if (!bone || bone.armature != this) {
                  throw new Error();
              }
              if (bone.parent) {
                  bone.parent.removeChildBone(bone, updateLater);
              }
              else {
                  bone._setArmature(null);
                  if (!updateLater) {
                      this._updateAnimationAfterBoneListChanged(false);
                  }
              }
          };
          p.removeBoneByName = function (boneName) {
              var bone = this.getBone(boneName);
              if (bone) {
                  this.removeBone(bone);
              }
              return bone;
          };
          p._addBoneToBoneList = function (bone) {
              if (this._boneList.indexOf(bone) < 0) {
                  this._boneList[this._boneList.length] = bone;
              }
          };
          p._removeBoneFromBoneList = function (bone) {
              var index = this._boneList.indexOf(bone);
              if (index >= 0) {
                  this._boneList.splice(index, 1);
              }
          };
          p._addSlotToSlotList = function (slot) {
              if (this._slotList.indexOf(slot) < 0) {
                  this._slotList[this._slotList.length] = slot;
              }
          };
          p._removeSlotFromSlotList = function (slot) {
              var index = this._slotList.indexOf(slot);
              if (index >= 0) {
                  this._slotList.splice(index, 1);
              }
          };
          p.updateSlotsZOrder = function () {
              this._slotList.sort(this.sortSlot);
              var i = this._slotList.length;
              while (i--) {
                  var slot = this._slotList[i];
                  if (slot._isShowDisplay) {
                      slot._addDisplayToContainer(this._display);
                  }
              }
              this._slotsZOrderChanged = false;
          };
          p._updateAnimationAfterBoneListChanged = function (ifNeedSortBoneList) {
              if (ifNeedSortBoneList === void 0) { ifNeedSortBoneList = true; }
              if (ifNeedSortBoneList) {
                  this.sortBoneList();
              }
              this._animation._updateAnimationStates();
          };
          p.sortBoneList = function () {
              var i = this._boneList.length;
              if (i == 0) {
                  return;
              }
              var helpArray = [];
              while (i--) {
                  var level = 0;
                  var bone = this._boneList[i];
                  var boneParent = bone;
                  while (boneParent) {
                      level++;
                      boneParent = boneParent.parent;
                  }
                  helpArray[i] = [level, bone];
              }
              helpArray.sort(dragonBones.ArmatureData.sortBoneDataHelpArrayDescending);
              i = helpArray.length;
              while (i--) {
                  this._boneList[i] = helpArray[i][1];
              }
              helpArray.length = 0;
          };
          p._arriveAtFrame = function (frame, timelineState, animationState, isCross) {
              if (frame.event && this.hasEventListener(dragonBones.FrameEvent.ANIMATION_FRAME_EVENT)) {
                  var frameEvent = new dragonBones.FrameEvent(dragonBones.FrameEvent.ANIMATION_FRAME_EVENT);
                  frameEvent.animationState = animationState;
                  frameEvent.frameLabel = frame.event;
                  this._eventList.push(frameEvent);
              }
              if (frame.sound && Armature._soundManager.hasEventListener(dragonBones.SoundEvent.SOUND)) {
                  var soundEvent = new dragonBones.SoundEvent(dragonBones.SoundEvent.SOUND);
                  soundEvent.armature = this;
                  soundEvent.animationState = animationState;
                  soundEvent.sound = frame.sound;
                  Armature._soundManager.dispatchEvent(soundEvent);
              }
              if (frame.action) {
                  if (animationState.displayControl) {
                      this.animation.gotoAndPlay(frame.action);
                  }
              }
          };
          p.sortSlot = function (slot1, slot2) {
              return slot1.zOrder < slot2.zOrder ? 1 : -1;
          };
          p.getAnimation = function () {
              return this._animation;
          };
          Armature._soundManager = dragonBones.SoundEventManager.getInstance();
          return Armature;
      })(dragonBones.EventDispatcher);
      dragonBones.Armature = Armature;
      egret.registerClass(Armature,'dragonBones.Armature',["dragonBones.IAnimatable"]);
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Matrix = (function () {
          function Matrix() {
              this.a = 1;
              this.b = 0;
              this.c = 0;
              this.d = 1;
              this.tx = 0;
              this.ty = 0;
          }
          var d = __define,c=Matrix,p=c.prototype;
          p.invert = function () {
              var a1 = this.a;
              var b1 = this.b;
              var c1 = this.c;
              var d1 = this.d;
              var tx1 = this.tx;
              var n = a1 * d1 - b1 * c1;
              this.a = d1 / n;
              this.b = -b1 / n;
              this.c = -c1 / n;
              this.d = a1 / n;
              this.tx = (c1 * this.ty - d1 * tx1) / n;
              this.ty = -(a1 * this.ty - b1 * tx1) / n;
          };
          p.concat = function (m) {
              var ma = m.a;
              var mb = m.b;
              var mc = m.c;
              var md = m.d;
              var tx1 = this.tx;
              var ty1 = this.ty;
              if (ma != 1 || mb != 0 || mc != 0 || md != 1) {
                  var a1 = this.a;
                  var b1 = this.b;
                  var c1 = this.c;
                  var d1 = this.d;
                  this.a = a1 * ma + b1 * mc;
                  this.b = a1 * mb + b1 * md;
                  this.c = c1 * ma + d1 * mc;
                  this.d = c1 * mb + d1 * md;
              }
              this.tx = tx1 * ma + ty1 * mc + m.tx;
              this.ty = tx1 * mb + ty1 * md + m.ty;
          };
          p.copyFrom = function (m) {
              this.tx = m.tx;
              this.ty = m.ty;
              this.a = m.a;
              this.b = m.b;
              this.c = m.c;
              this.d = m.d;
          };
          return Matrix;
      })();
      dragonBones.Matrix = Matrix;
      egret.registerClass(Matrix,'dragonBones.Matrix');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var DBTransform = (function () {
          function DBTransform() {
              this.x = 0;
              this.y = 0;
              this.skewX = 0;
              this.skewY = 0;
              this.scaleX = 1;
              this.scaleY = 1;
          }
          var d = __define,c=DBTransform,p=c.prototype;
          d(p, "rotation"
              ,function () {
                  return this.skewX;
              }
              ,function (value) {
                  this.skewX = this.skewY = value;
              }
          );
          p.copy = function (transform) {
              this.x = transform.x;
              this.y = transform.y;
              this.skewX = transform.skewX;
              this.skewY = transform.skewY;
              this.scaleX = transform.scaleX;
              this.scaleY = transform.scaleY;
          };
          p.add = function (transform) {
              this.x += transform.x;
              this.y += transform.y;
              this.skewX += transform.skewX;
              this.skewY += transform.skewY;
              this.scaleX *= transform.scaleX;
              this.scaleY *= transform.scaleY;
          };
          p.minus = function (transform) {
              this.x -= transform.x;
              this.y -= transform.y;
              this.skewX -= transform.skewX;
              this.skewY -= transform.skewY;
              this.scaleX /= transform.scaleX;
              this.scaleY /= transform.scaleY;
          };
          p.normalizeRotation = function () {
              this.skewX = dragonBones.TransformUtil.normalizeRotation(this.skewX);
              this.skewY = dragonBones.TransformUtil.normalizeRotation(this.skewY);
          };
          p.toString = function () {
              var string = "x:" + this.x + " y:" + this.y + " skewX:" + this.skewX + " skewY:" + this.skewY + " scaleX:" + this.scaleX + " scaleY:" + this.scaleY;
              return string;
          };
          return DBTransform;
      })();
      dragonBones.DBTransform = DBTransform;
      egret.registerClass(DBTransform,'dragonBones.DBTransform');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var DBObject = (function () {
          function DBObject() {
              this._globalTransformMatrix = new dragonBones.Matrix();
              this._global = new dragonBones.DBTransform();
              this._origin = new dragonBones.DBTransform();
              this._offset = new dragonBones.DBTransform();
              this._offset.scaleX = this._offset.scaleY = 1;
              this._visible = true;
              this._armature = null;
              this._parent = null;
              this.userData = null;
              this.inheritRotation = true;
              this.inheritScale = true;
              this.inheritTranslation = true;
          }
          var d = __define,c=DBObject,p=c.prototype;
          d(p, "global"
              ,function () {
                  return this._global;
              }
          );
          d(p, "origin"
              ,function () {
                  return this._origin;
              }
          );
          d(p, "offset"
              ,function () {
                  return this._offset;
              }
          );
          d(p, "armature"
              ,function () {
                  return this._armature;
              }
          );
          p._setArmature = function (value) {
              this._armature = value;
          };
          d(p, "parent"
              ,function () {
                  return this._parent;
              }
          );
          p._setParent = function (value) {
              this._parent = value;
          };
          p.dispose = function () {
              this.userData = null;
              this._globalTransformMatrix = null;
              this._global = null;
              this._origin = null;
              this._offset = null;
              this._armature = null;
              this._parent = null;
          };
          p._calculateRelativeParentTransform = function () {
          };
          p._calculateParentTransform = function () {
              if (this.parent && (this.inheritTranslation || this.inheritRotation || this.inheritScale)) {
                  var parentGlobalTransform = this._parent._globalTransformForChild;
                  var parentGlobalTransformMatrix = this._parent._globalTransformMatrixForChild;
                  if (!this.inheritTranslation || !this.inheritRotation || !this.inheritScale) {
                      parentGlobalTransform = DBObject._tempParentGlobalTransform;
                      parentGlobalTransform.copy(this._parent._globalTransformForChild);
                      if (!this.inheritTranslation) {
                          parentGlobalTransform.x = 0;
                          parentGlobalTransform.y = 0;
                      }
                      if (!this.inheritScale) {
                          parentGlobalTransform.scaleX = 1;
                          parentGlobalTransform.scaleY = 1;
                      }
                      if (!this.inheritRotation) {
                          parentGlobalTransform.skewX = 0;
                          parentGlobalTransform.skewY = 0;
                      }
                      parentGlobalTransformMatrix = DBObject._tempParentGlobalTransformMatrix;
                      dragonBones.TransformUtil.transformToMatrix(parentGlobalTransform, parentGlobalTransformMatrix, true);
                  }
                  return { parentGlobalTransform: parentGlobalTransform, parentGlobalTransformMatrix: parentGlobalTransformMatrix };
              }
              return null;
          };
          p._updateGlobal = function () {
              this._calculateRelativeParentTransform();
              var output = this._calculateParentTransform();
              if (output != null) {
                  var parentMatrix = output.parentGlobalTransformMatrix;
                  var parentGlobalTransform = output.parentGlobalTransform;
                  var x = this._global.x;
                  var y = this._global.y;
                  this._global.x = parentMatrix.a * x + parentMatrix.c * y + parentMatrix.tx;
                  this._global.y = parentMatrix.d * y + parentMatrix.b * x + parentMatrix.ty;
                  if (this.inheritRotation) {
                      this._global.skewX += parentGlobalTransform.skewX;
                      this._global.skewY += parentGlobalTransform.skewY;
                  }
                  if (this.inheritScale) {
                      this._global.scaleX *= parentGlobalTransform.scaleX;
                      this._global.scaleY *= parentGlobalTransform.scaleY;
                  }
              }
              dragonBones.TransformUtil.transformToMatrix(this._global, this._globalTransformMatrix, true);
              return output;
          };
          DBObject._tempParentGlobalTransformMatrix = new dragonBones.Matrix();
          DBObject._tempParentGlobalTransform = new dragonBones.DBTransform();
          return DBObject;
      })();
      dragonBones.DBObject = DBObject;
      egret.registerClass(DBObject,'dragonBones.DBObject');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Bone = (function (_super) {
          __extends(Bone, _super);
          function Bone() {
              _super.call(this);
              this.applyOffsetTranslationToChild = true;
              this.applyOffsetRotationToChild = true;
              this.applyOffsetScaleToChild = false;
              this._needUpdate = 0;
              this._tween = new dragonBones.DBTransform();
              this._tweenPivot = new dragonBones.Point();
              this._tween.scaleX = this._tween.scaleY = 1;
              this._boneList = [];
              this._slotList = [];
              this._timelineStateList = [];
              this._needUpdate = 2;
              this._isColorChanged = false;
          }
          var d = __define,c=Bone,p=c.prototype;
          Bone.initWithBoneData = function (boneData) {
              var outputBone = new Bone();
              outputBone.name = boneData.name;
              outputBone.inheritRotation = boneData.inheritRotation;
              outputBone.inheritScale = boneData.inheritScale;
              outputBone.origin.copy(boneData.transform);
              return outputBone;
          };
          p.dispose = function () {
              if (!this._boneList) {
                  return;
              }
              _super.prototype.dispose.call(this);
              var i = this._boneList.length;
              while (i--) {
                  this._boneList[i].dispose();
              }
              i = this._slotList.length;
              while (i--) {
                  this._slotList[i].dispose();
              }
              this._tween = null;
              this._tweenPivot = null;
              this._boneList = null;
              this._slotList = null;
              this._timelineStateList = null;
          };
          p.contains = function (child) {
              if (!child) {
                  throw new Error();
              }
              if (child == this) {
                  return false;
              }
              var ancestor = child;
              while (!(ancestor == this || ancestor == null)) {
                  ancestor = ancestor.parent;
              }
              return ancestor == this;
          };
          p.addChildBone = function (childBone, updateLater) {
              if (updateLater === void 0) { updateLater = false; }
              if (!childBone) {
                  throw new Error();
              }
              if (childBone == this || childBone.contains(this)) {
                  throw new Error();
              }
              if (childBone.parent == this) {
                  return;
              }
              if (childBone.parent) {
                  childBone.parent.removeChildBone(childBone, updateLater);
              }
              this._boneList[this._boneList.length] = childBone;
              childBone._setParent(this);
              childBone._setArmature(this._armature);
              if (this._armature && !updateLater) {
                  this._armature._updateAnimationAfterBoneListChanged();
              }
          };
          p.removeChildBone = function (childBone, updateLater) {
              if (updateLater === void 0) { updateLater = false; }
              if (!childBone) {
                  throw new Error();
              }
              var index = this._boneList.indexOf(childBone);
              if (index < 0) {
                  throw new Error();
              }
              this._boneList.splice(index, 1);
              childBone._setParent(null);
              childBone._setArmature(null);
              if (this._armature && !updateLater) {
                  this._armature._updateAnimationAfterBoneListChanged(false);
              }
          };
          p.addSlot = function (childSlot) {
              if (!childSlot) {
                  throw new Error();
              }
              if (childSlot.parent) {
                  childSlot.parent.removeSlot(childSlot);
              }
              this._slotList[this._slotList.length] = childSlot;
              childSlot._setParent(this);
              childSlot.setArmature(this._armature);
          };
          p.removeSlot = function (childSlot) {
              if (!childSlot) {
                  throw new Error();
              }
              var index = this._slotList.indexOf(childSlot);
              if (index < 0) {
                  throw new Error();
              }
              this._slotList.splice(index, 1);
              childSlot._setParent(null);
              childSlot.setArmature(null);
          };
          p._setArmature = function (value) {
              if (this._armature == value) {
                  return;
              }
              if (this._armature) {
                  this._armature._removeBoneFromBoneList(this);
                  this._armature._updateAnimationAfterBoneListChanged(false);
              }
              this._armature = value;
              if (this._armature) {
                  this._armature._addBoneToBoneList(this);
              }
              var i = this._boneList.length;
              while (i--) {
                  this._boneList[i]._setArmature(this._armature);
              }
              i = this._slotList.length;
              while (i--) {
                  this._slotList[i].setArmature(this._armature);
              }
          };
          p.getBones = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this._boneList.concat() : this._boneList;
          };
          p.getSlots = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this._slotList.concat() : this._slotList;
          };
          p.invalidUpdate = function () {
              this._needUpdate = 2;
          };
          p._calculateRelativeParentTransform = function () {
              this._global.scaleX = this._origin.scaleX * this._tween.scaleX * this._offset.scaleX;
              this._global.scaleY = this._origin.scaleY * this._tween.scaleY * this._offset.scaleY;
              this._global.skewX = this._origin.skewX + this._tween.skewX + this._offset.skewX;
              this._global.skewY = this._origin.skewY + this._tween.skewY + this._offset.skewY;
              this._global.x = this._origin.x + this._tween.x + this._offset.x;
              this._global.y = this._origin.y + this._tween.y + this._offset.y;
          };
          p._update = function (needUpdate) {
              if (needUpdate === void 0) { needUpdate = false; }
              this._needUpdate--;
              if (needUpdate || this._needUpdate > 0 || (this._parent && this._parent._needUpdate > 0)) {
                  this._needUpdate = 1;
              }
              else {
                  return;
              }
              this.blendingTimeline();
              var result = this._updateGlobal();
              var parentGlobalTransform = result ? result.parentGlobalTransform : null;
              var parentGlobalTransformMatrix = result ? result.parentGlobalTransformMatrix : null;
              var ifExistOffsetTranslation = this._offset.x != 0 || this._offset.y != 0;
              var ifExistOffsetScale = this._offset.scaleX != 0 || this._offset.scaleY != 0;
              var ifExistOffsetRotation = this._offset.skewX != 0 || this._offset.skewY != 0;
              if ((!ifExistOffsetTranslation || this.applyOffsetTranslationToChild) &&
                  (!ifExistOffsetScale || this.applyOffsetScaleToChild) &&
                  (!ifExistOffsetRotation || this.applyOffsetRotationToChild)) {
                  this._globalTransformForChild = this._global;
                  this._globalTransformMatrixForChild = this._globalTransformMatrix;
              }
              else {
                  if (!this._tempGlobalTransformForChild) {
                      this._tempGlobalTransformForChild = new dragonBones.DBTransform();
                  }
                  this._globalTransformForChild = this._tempGlobalTransformForChild;
                  if (!this._tempGlobalTransformMatrixForChild) {
                      this._tempGlobalTransformMatrixForChild = new dragonBones.Matrix();
                  }
                  this._globalTransformMatrixForChild = this._tempGlobalTransformMatrixForChild;
                  this._globalTransformForChild.x = this._origin.x + this._tween.x;
                  this._globalTransformForChild.y = this._origin.y + this._tween.y;
                  this._globalTransformForChild.scaleX = this._origin.scaleX * this._tween.scaleX;
                  this._globalTransformForChild.scaleY = this._origin.scaleY * this._tween.scaleY;
                  this._globalTransformForChild.skewX = this._origin.skewX + this._tween.skewX;
                  this._globalTransformForChild.skewY = this._origin.skewY + this._tween.skewY;
                  if (this.applyOffsetTranslationToChild) {
                      this._globalTransformForChild.x += this._offset.x;
                      this._globalTransformForChild.y += this._offset.y;
                  }
                  if (this.applyOffsetScaleToChild) {
                      this._globalTransformForChild.scaleX *= this._offset.scaleX;
                      this._globalTransformForChild.scaleY *= this._offset.scaleY;
                  }
                  if (this.applyOffsetRotationToChild) {
                      this._globalTransformForChild.skewX += this._offset.skewX;
                      this._globalTransformForChild.skewY += this._offset.skewY;
                  }
                  dragonBones.TransformUtil.transformToMatrix(this._globalTransformForChild, this._globalTransformMatrixForChild, true);
                  if (parentGlobalTransformMatrix) {
                      this._globalTransformMatrixForChild.concat(parentGlobalTransformMatrix);
                      dragonBones.TransformUtil.matrixToTransform(this._globalTransformMatrixForChild, this._globalTransformForChild, this._globalTransformForChild.scaleX * parentGlobalTransform.scaleX >= 0, this._globalTransformForChild.scaleY * parentGlobalTransform.scaleY >= 0);
                  }
              }
          };
          p._updateColor = function (aOffset, rOffset, gOffset, bOffset, aMultiplier, rMultiplier, gMultiplier, bMultiplier, colorChanged) {
              var length = this._slotList.length;
              for (var i = 0; i < length; i++) {
                  var childSlot = this._slotList[i];
                  childSlot._updateDisplayColor(aOffset, rOffset, gOffset, bOffset, aMultiplier, rMultiplier, gMultiplier, bMultiplier);
              }
              this._isColorChanged = colorChanged;
          };
          p._hideSlots = function () {
              var length = this._slotList.length;
              for (var i = 0; i < length; i++) {
                  var childSlot = this._slotList[i];
                  childSlot._changeDisplay(-1);
              }
          };
          p._arriveAtFrame = function (frame, timelineState, animationState, isCross) {
              var displayControl = animationState.displayControl &&
                  (!this.displayController || this.displayController == animationState.name) &&
                  animationState.containsBoneMask(this.name);
              if (displayControl) {
                  var tansformFrame = frame;
                  var displayIndex = tansformFrame.displayIndex;
                  var childSlot;
                  if (frame.event && this._armature.hasEventListener(dragonBones.FrameEvent.BONE_FRAME_EVENT)) {
                      var frameEvent = new dragonBones.FrameEvent(dragonBones.FrameEvent.BONE_FRAME_EVENT);
                      frameEvent.bone = this;
                      frameEvent.animationState = animationState;
                      frameEvent.frameLabel = frame.event;
                      this._armature._eventList.push(frameEvent);
                  }
                  if (frame.sound && Bone._soundManager.hasEventListener(dragonBones.SoundEvent.SOUND)) {
                      var soundEvent = new dragonBones.SoundEvent(dragonBones.SoundEvent.SOUND);
                      soundEvent.armature = this._armature;
                      soundEvent.animationState = animationState;
                      soundEvent.sound = frame.sound;
                      Bone._soundManager.dispatchEvent(soundEvent);
                  }
                  if (frame.action) {
                      var length1 = this._slotList.length;
                      for (var i1 = 0; i1 < length1; i1++) {
                          childSlot = this._slotList[i1];
                          var childArmature = childSlot.childArmature;
                          if (childArmature) {
                              childArmature.animation.gotoAndPlay(frame.action);
                          }
                      }
                  }
              }
          };
          p._addState = function (timelineState) {
              if (this._timelineStateList.indexOf(timelineState) < 0) {
                  this._timelineStateList.push(timelineState);
                  this._timelineStateList.sort(this.sortState);
              }
          };
          p._removeState = function (timelineState) {
              var index = this._timelineStateList.indexOf(timelineState);
              if (index >= 0) {
                  this._timelineStateList.splice(index, 1);
              }
          };
          p._removeAllStates = function () {
              this._timelineStateList.length = 0;
          };
          p.blendingTimeline = function () {
              var timelineState;
              var transform;
              var pivot;
              var weight;
              var i = this._timelineStateList.length;
              if (i == 1) {
                  timelineState = this._timelineStateList[0];
                  weight = timelineState._animationState.weight * timelineState._animationState.fadeWeight;
                  timelineState._weight = weight;
                  transform = timelineState._transform;
                  pivot = timelineState._pivot;
                  this._tween.x = transform.x * weight;
                  this._tween.y = transform.y * weight;
                  this._tween.skewX = transform.skewX * weight;
                  this._tween.skewY = transform.skewY * weight;
                  this._tween.scaleX = 1 + (transform.scaleX - 1) * weight;
                  this._tween.scaleY = 1 + (transform.scaleY - 1) * weight;
                  this._tweenPivot.x = pivot.x * weight;
                  this._tweenPivot.y = pivot.y * weight;
              }
              else if (i > 1) {
                  var x = 0;
                  var y = 0;
                  var skewX = 0;
                  var skewY = 0;
                  var scaleX = 1;
                  var scaleY = 1;
                  var pivotX = 0;
                  var pivotY = 0;
                  var weigthLeft = 1;
                  var layerTotalWeight = 0;
                  var prevLayer = this._timelineStateList[i - 1]._animationState.layer;
                  var currentLayer = 0;
                  while (i--) {
                      timelineState = this._timelineStateList[i];
                      currentLayer = timelineState._animationState.layer;
                      if (prevLayer != currentLayer) {
                          if (layerTotalWeight >= weigthLeft) {
                              timelineState._weight = 0;
                              break;
                          }
                          else {
                              weigthLeft -= layerTotalWeight;
                          }
                      }
                      prevLayer = currentLayer;
                      weight = timelineState._animationState.weight * timelineState._animationState.fadeWeight * weigthLeft;
                      timelineState._weight = weight;
                      if (weight) {
                          transform = timelineState._transform;
                          pivot = timelineState._pivot;
                          x += transform.x * weight;
                          y += transform.y * weight;
                          skewX += transform.skewX * weight;
                          skewY += transform.skewY * weight;
                          scaleX += (transform.scaleX - 1) * weight;
                          scaleY += (transform.scaleY - 1) * weight;
                          pivotX += pivot.x * weight;
                          pivotY += pivot.y * weight;
                          layerTotalWeight += weight;
                      }
                  }
                  this._tween.x = x;
                  this._tween.y = y;
                  this._tween.skewX = skewX;
                  this._tween.skewY = skewY;
                  this._tween.scaleX = scaleX;
                  this._tween.scaleY = scaleY;
                  this._tweenPivot.x = pivotX;
                  this._tweenPivot.y = pivotY;
              }
          };
          p.sortState = function (state1, state2) {
              return state1._animationState.layer < state2._animationState.layer ? -1 : 1;
          };
          d(p, "childArmature"
              ,function () {
                  if (this.slot) {
                      return this.slot.childArmature;
                  }
                  return null;
              }
          );
          d(p, "display"
              ,function () {
                  if (this.slot) {
                      return this.slot.display;
                  }
                  return null;
              }
              ,function (value) {
                  if (this.slot) {
                      this.slot.display = value;
                  }
              }
          );
          d(p, "node"
              ,function () {
                  return this._offset;
              }
          );
          d(p, "visible",undefined
              ,function (value) {
                  if (this._visible != value) {
                      this._visible = value;
                      var length = this._slotList.length;
                      for (var i = 0; i < length; i++) {
                          var childSlot = this._slotList[i];
                          childSlot._updateDisplayVisible(this._visible);
                      }
                  }
              }
          );
          d(p, "slot"
              ,function () {
                  return this._slotList.length > 0 ? this._slotList[0] : null;
              }
          );
          Bone._soundManager = dragonBones.SoundEventManager.getInstance();
          return Bone;
      })(dragonBones.DBObject);
      dragonBones.Bone = Bone;
      egret.registerClass(Bone,'dragonBones.Bone');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Slot = (function (_super) {
          __extends(Slot, _super);
          function Slot(self) {
              _super.call(this);
              this._currentDisplayIndex = 0;
              if (self != this) {
                  throw new Error(egret.getString(4001));
              }
              this._displayList = [];
              this._timelineStateList = [];
              this._currentDisplayIndex = -1;
              this._originZOrder = 0;
              this._tweenZOrder = 0;
              this._offsetZOrder = 0;
              this._isShowDisplay = false;
              this._colorTransform = new dragonBones.ColorTransform();
              this._displayDataList = null;
              this._currentDisplay = null;
              this.inheritRotation = true;
              this.inheritScale = true;
          }
          var d = __define,c=Slot,p=c.prototype;
          p.initWithSlotData = function (slotData) {
              this.name = slotData.name;
              this.blendMode = slotData.blendMode;
              this._originZOrder = slotData.zOrder;
              this._displayDataList = slotData.displayDataList;
              this._originDisplayIndex = slotData.displayIndex;
          };
          p.dispose = function () {
              if (!this._displayList) {
                  return;
              }
              _super.prototype.dispose.call(this);
              this._displayList.length = 0;
              this._displayDataList = null;
              this._displayList = null;
              this._currentDisplay = null;
          };
          p.sortState = function (state1, state2) {
              return state1._animationState.layer < state2._animationState.layer ? -1 : 1;
          };
          p._addState = function (timelineState) {
              if (this._timelineStateList.indexOf(timelineState) < 0) {
                  this._timelineStateList.push(timelineState);
                  this._timelineStateList.sort(this.sortState);
              }
          };
          p._removeState = function (timelineState) {
              var index = this._timelineStateList.indexOf(timelineState);
              if (index >= 0) {
                  this._timelineStateList.splice(index, 1);
              }
          };
          p.setArmature = function (value) {
              if (this._armature == value) {
                  return;
              }
              if (this._armature) {
                  this._armature._removeSlotFromSlotList(this);
              }
              this._armature = value;
              if (this._armature) {
                  this._armature._addSlotToSlotList(this);
                  this._armature._slotsZOrderChanged = true;
                  this._addDisplayToContainer(this._armature.display);
              }
              else {
                  this._removeDisplayFromContainer();
              }
          };
          p._update = function () {
              if (this._parent._needUpdate <= 0 && !this._needUpdate) {
                  return;
              }
              this._updateGlobal();
              this._updateTransform();
              this._needUpdate = false;
          };
          p._calculateRelativeParentTransform = function () {
              this._global.scaleX = this._origin.scaleX * this._offset.scaleX;
              this._global.scaleY = this._origin.scaleY * this._offset.scaleY;
              this._global.skewX = this._origin.skewX + this._offset.skewX;
              this._global.skewY = this._origin.skewY + this._offset.skewY;
              this._global.x = this._origin.x + this._offset.x + this._parent._tweenPivot.x;
              this._global.y = this._origin.y + this._offset.y + this._parent._tweenPivot.y;
          };
          p.updateChildArmatureAnimation = function () {
              if (this.childArmature) {
                  if (this._isShowDisplay) {
                      if (this._armature &&
                          this._armature.animation.lastAnimationState &&
                          this.childArmature.animation.hasAnimation(this._armature.animation.lastAnimationState.name)) {
                          this.childArmature.animation.gotoAndPlay(this._armature.animation.lastAnimationState.name);
                      }
                      else {
                          this.childArmature.animation.play();
                      }
                  }
                  else {
                      this.childArmature.animation.stop();
                      this.childArmature.animation._lastAnimationState = null;
                  }
              }
          };
          p._changeDisplay = function (displayIndex) {
              if (displayIndex === void 0) { displayIndex = 0; }
              if (displayIndex < 0) {
                  if (this._isShowDisplay) {
                      this._isShowDisplay = false;
                      this._removeDisplayFromContainer();
                      this.updateChildArmatureAnimation();
                  }
              }
              else if (this._displayList.length > 0) {
                  var length = this._displayList.length;
                  if (displayIndex >= length) {
                      displayIndex = length - 1;
                  }
                  if (this._currentDisplayIndex != displayIndex) {
                      this._isShowDisplay = true;
                      this._currentDisplayIndex = displayIndex;
                      this._updateSlotDisplay();
                      this.updateChildArmatureAnimation();
                      if (this._displayDataList &&
                          this._displayDataList.length > 0 &&
                          this._currentDisplayIndex < this._displayDataList.length) {
                          this._origin.copy(this._displayDataList[this._currentDisplayIndex].transform);
                      }
                      this._needUpdate = true;
                  }
                  else if (!this._isShowDisplay) {
                      this._isShowDisplay = true;
                      if (this._armature) {
                          this._armature._slotsZOrderChanged = true;
                          this._addDisplayToContainer(this._armature.display);
                      }
                      this.updateChildArmatureAnimation();
                  }
              }
          };
          p._updateSlotDisplay = function () {
              var currentDisplayIndex = -1;
              if (this._currentDisplay) {
                  currentDisplayIndex = this._getDisplayIndex();
                  this._removeDisplayFromContainer();
              }
              var displayObj = this._displayList[this._currentDisplayIndex];
              if (displayObj) {
                  if (displayObj instanceof dragonBones.Armature) {
                      this._currentDisplay = displayObj.display;
                  }
                  else {
                      this._currentDisplay = displayObj;
                  }
              }
              else {
                  this._currentDisplay = null;
              }
              this._updateDisplay(this._currentDisplay);
              if (this._currentDisplay) {
                  if (this._armature && this._isShowDisplay) {
                      if (currentDisplayIndex < 0) {
                          this._armature._slotsZOrderChanged = true;
                          this._addDisplayToContainer(this._armature.display);
                      }
                      else {
                          this._addDisplayToContainer(this._armature.display, currentDisplayIndex);
                      }
                  }
                  this._updateDisplayBlendMode(this._blendMode);
                  this._updateDisplayColor(this._colorTransform.alphaOffset, this._colorTransform.redOffset, this._colorTransform.greenOffset, this._colorTransform.blueOffset, this._colorTransform.alphaMultiplier, this._colorTransform.redMultiplier, this._colorTransform.greenMultiplier, this._colorTransform.blueMultiplier, true);
                  this._updateDisplayVisible(this._visible);
                  this._updateTransform();
              }
          };
          d(p, "visible",undefined
              ,function (value) {
                  if (this._visible != value) {
                      this._visible = value;
                      this._updateDisplayVisible(this._visible);
                  }
              }
          );
          d(p, "displayList"
              ,function () {
                  return this._displayList;
              }
              ,function (value) {
                  if (!value) {
                      throw new Error();
                  }
                  if (this._currentDisplayIndex < 0) {
                      this._currentDisplayIndex = 0;
                  }
                  var i = this._displayList.length = value.length;
                  while (i--) {
                      this._displayList[i] = value[i];
                  }
                  var displayIndexBackup = this._currentDisplayIndex;
                  this._currentDisplayIndex = -1;
                  this._changeDisplay(displayIndexBackup);
              }
          );
          d(p, "display"
              ,function () {
                  return this._currentDisplay;
              }
              ,function (value) {
                  if (this._currentDisplayIndex < 0) {
                      this._currentDisplayIndex = 0;
                  }
                  if (this._displayList[this._currentDisplayIndex] == value) {
                      return;
                  }
                  this._displayList[this._currentDisplayIndex] = value;
                  this._updateSlotDisplay();
                  this.updateChildArmatureAnimation();
                  this._updateTransform();
              }
          );
          p.getDisplay = function () {
              return this.display;
          };
          p.setDisplay = function (value) {
              this.display = value;
          };
          d(p, "childArmature"
              ,function () {
                  if (this._displayList[this._currentDisplayIndex] instanceof dragonBones.Armature) {
                      return (this._displayList[this._currentDisplayIndex]);
                  }
                  return null;
              }
              ,function (value) {
                  this.display = value;
              }
          );
          d(p, "zOrder"
              ,function () {
                  return this._originZOrder + this._tweenZOrder + this._offsetZOrder;
              }
              ,function (value) {
                  if (this.zOrder != value) {
                      this._offsetZOrder = value - this._originZOrder - this._tweenZOrder;
                      if (this._armature) {
                          this._armature._slotsZOrderChanged = true;
                      }
                  }
              }
          );
          d(p, "blendMode"
              ,function () {
                  return this._blendMode;
              }
              ,function (value) {
                  if (this._blendMode != value) {
                      this._blendMode = value;
                      this._updateDisplayBlendMode(this._blendMode);
                  }
              }
          );
          p._updateDisplay = function (value) {
              throw new Error("");
          };
          p._getDisplayIndex = function () {
              throw new Error(egret.getString(4001));
          };
          p._addDisplayToContainer = function (container, index) {
              if (index === void 0) { index = -1; }
              throw new Error(egret.getString(4001));
          };
          p._removeDisplayFromContainer = function () {
              throw new Error(egret.getString(4001));
          };
          p._updateTransform = function () {
              throw new Error(egret.getString(4001));
          };
          p._updateDisplayVisible = function (value) {
              throw new Error(egret.getString(4001));
          };
          p._updateDisplayColor = function (aOffset, rOffset, gOffset, bOffset, aMultiplier, rMultiplier, gMultiplier, bMultiplier, colorChanged) {
              if (colorChanged === void 0) { colorChanged = false; }
              this._colorTransform.alphaOffset = aOffset;
              this._colorTransform.redOffset = rOffset;
              this._colorTransform.greenOffset = gOffset;
              this._colorTransform.blueOffset = bOffset;
              this._colorTransform.alphaMultiplier = aMultiplier;
              this._colorTransform.redMultiplier = rMultiplier;
              this._colorTransform.greenMultiplier = gMultiplier;
              this._colorTransform.blueMultiplier = bMultiplier;
              this._isColorChanged = colorChanged;
          };
          p._updateDisplayBlendMode = function (value) {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._arriveAtFrame = function (frame, timelineState, animationState, isCross) {
              var displayControl = animationState.displayControl &&
                  animationState.containsBoneMask(this.parent.name);
              if (displayControl) {
                  var slotFrame = frame;
                  var displayIndex = slotFrame.displayIndex;
                  var childSlot;
                  this._changeDisplay(displayIndex);
                  this._updateDisplayVisible(slotFrame.visible);
                  if (displayIndex >= 0) {
                      if (!isNaN(slotFrame.zOrder) && slotFrame.zOrder != this._tweenZOrder) {
                          this._tweenZOrder = slotFrame.zOrder;
                          this._armature._slotsZOrderChanged = true;
                      }
                  }
                  if (frame.action) {
                      if (this.childArmature) {
                          this.childArmature.animation.gotoAndPlay(frame.action);
                      }
                  }
              }
          };
          p._updateGlobal = function () {
              this._calculateRelativeParentTransform();
              dragonBones.TransformUtil.transformToMatrix(this._global, this._globalTransformMatrix, true);
              var output = this._calculateParentTransform();
              if (output) {
                  this._globalTransformMatrix.concat(output.parentGlobalTransformMatrix);
                  dragonBones.TransformUtil.matrixToTransform(this._globalTransformMatrix, this._global, this._global.scaleX * output.parentGlobalTransform.scaleX >= 0, this._global.scaleY * output.parentGlobalTransform.scaleY >= 0);
              }
              return output;
          };
          p._resetToOrigin = function () {
              this._changeDisplay(this._originDisplayIndex);
              this._updateDisplayColor(0, 0, 0, 0, 1, 1, 1, 1, true);
          };
          return Slot;
      })(dragonBones.DBObject);
      dragonBones.Slot = Slot;
      egret.registerClass(Slot,'dragonBones.Slot');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var AnimationCache = (function () {
          function AnimationCache() {
              this.slotTimelineCacheList = [];
              this.slotTimelineCacheDic = {};
              this.frameNum = 0;
          }
          var d = __define,c=AnimationCache,p=c.prototype;
          AnimationCache.initWithAnimationData = function (animationData, armatureData) {
              var output = new AnimationCache();
              output.name = animationData.name;
              var boneTimelineList = animationData.timelineList;
              var boneName;
              var boneData;
              var slotData;
              var slotTimelineCache;
              var slotName;
              for (var i = 0, length = boneTimelineList.length; i < length; i++) {
                  boneName = boneTimelineList[i].name;
                  for (var j = 0, jlen = armatureData.slotDataList.length; j < jlen; j++) {
                      slotData = armatureData.slotDataList[j];
                      slotName = slotData.name;
                      if (slotData.parent == boneName) {
                          if (output.slotTimelineCacheDic[slotName] == null) {
                              slotTimelineCache = new dragonBones.SlotTimelineCache();
                              slotTimelineCache.name = slotName;
                              output.slotTimelineCacheList.push(slotTimelineCache);
                              output.slotTimelineCacheDic[slotName] = slotTimelineCache;
                          }
                      }
                  }
              }
              return output;
          };
          p.initSlotTimelineCacheDic = function (slotCacheGeneratorDic, slotFrameCacheDic) {
              var name;
              for (var k in this.slotTimelineCacheDic) {
                  var slotTimelineCache = this.slotTimelineCacheDic[k];
                  name = slotTimelineCache.name;
                  slotTimelineCache.cacheGenerator = slotCacheGeneratorDic[name];
                  slotTimelineCache.currentFrameCache = slotFrameCacheDic[name];
              }
          };
          p.bindCacheUserSlotDic = function (slotDic) {
              for (var name in slotDic) {
                  (this.slotTimelineCacheDic[name]).bindCacheUser(slotDic[name]);
              }
          };
          p.addFrame = function () {
              this.frameNum++;
              var slotTimelineCache;
              for (var i = 0, length = this.slotTimelineCacheList.length; i < length; i++) {
                  slotTimelineCache = this.slotTimelineCacheList[i];
                  slotTimelineCache.addFrame();
              }
          };
          p.update = function (progress) {
              var frameIndex = Math.floor(progress * (this.frameNum - 1));
              var slotTimelineCache;
              for (var i = 0, length = this.slotTimelineCacheList.length; i < length; i++) {
                  slotTimelineCache = this.slotTimelineCacheList[i];
                  slotTimelineCache.update(frameIndex);
              }
          };
          return AnimationCache;
      })();
      dragonBones.AnimationCache = AnimationCache;
      egret.registerClass(AnimationCache,'dragonBones.AnimationCache');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var AnimationCacheManager = (function () {
          function AnimationCacheManager() {
              this.animationCacheDic = {};
              this.slotFrameCacheDic = {};
          }
          var d = __define,c=AnimationCacheManager,p=c.prototype;
          AnimationCacheManager.initWithArmatureData = function (armatureData, frameRate) {
              if (frameRate === void 0) { frameRate = 0; }
              var output = new AnimationCacheManager();
              output.armatureData = armatureData;
              if (frameRate <= 0) {
                  var animationData = armatureData.animationDataList[0];
                  if (animationData) {
                      output.frameRate = animationData.frameRate;
                  }
              }
              else {
                  output.frameRate = frameRate;
              }
              return output;
          };
          p.initAllAnimationCache = function () {
              var length = this.armatureData.animationDataList.length;
              for (var i = 0; i < length; i++) {
                  var animationData = this.armatureData.animationDataList[i];
                  this.animationCacheDic[animationData.name] = dragonBones.AnimationCache.initWithAnimationData(animationData, this.armatureData);
              }
          };
          p.initAnimationCache = function (animationName) {
              this.animationCacheDic[animationName] = dragonBones.AnimationCache.initWithAnimationData(this.armatureData.getAnimationData(animationName), this.armatureData);
          };
          p.bindCacheUserArmatures = function (armatures) {
              var length = armatures.length;
              for (var i = 0; i < length; i++) {
                  var armature = armatures[i];
                  this.bindCacheUserArmature(armature);
              }
          };
          p.bindCacheUserArmature = function (armature) {
              armature.animation.animationCacheManager = this;
              var cacheUser;
              for (var k in armature._slotDic) {
                  cacheUser = armature._slotDic[k];
                  cacheUser.frameCache = this.slotFrameCacheDic[cacheUser.name];
              }
          };
          p.setCacheGeneratorArmature = function (armature) {
              this.cacheGeneratorArmature = armature;
              var cacheUser;
              for (var slot in armature._slotDic) {
                  cacheUser = armature._slotDic[slot];
                  this.slotFrameCacheDic[cacheUser.name] = new dragonBones.SlotFrameCache();
              }
              for (var anim in this.animationCacheDic) {
                  var animationCache = this.animationCacheDic[anim];
                  animationCache.initSlotTimelineCacheDic(armature._slotDic, this.slotFrameCacheDic);
              }
          };
          p.generateAllAnimationCache = function (loop) {
              for (var anim in this.animationCacheDic) {
                  var animationCache = this.animationCacheDic[anim];
                  this.generateAnimationCache(animationCache.name, loop);
              }
          };
          p.generateAnimationCache = function (animationName, loop) {
              var temp = this.cacheGeneratorArmature.enableCache;
              this.cacheGeneratorArmature.enableCache = false;
              var animationCache = this.animationCacheDic[animationName];
              if (!animationCache) {
                  return;
              }
              var animationState = this.cacheGeneratorArmature.getAnimation().animationState;
              var passTime = 1 / this.frameRate;
              if (loop) {
                  this.cacheGeneratorArmature.getAnimation().gotoAndPlay(animationName, 0, -1, 0);
              }
              else {
                  this.cacheGeneratorArmature.getAnimation().gotoAndPlay(animationName, 0, -1, 1);
              }
              var tempEnableEventDispatch = this.cacheGeneratorArmature.enableEventDispatch;
              this.cacheGeneratorArmature.enableEventDispatch = false;
              var lastProgress;
              do {
                  lastProgress = animationState.progress;
                  this.cacheGeneratorArmature.advanceTime(passTime);
                  animationCache.addFrame();
              } while (animationState.progress >= lastProgress && animationState.progress < 1);
              this.cacheGeneratorArmature.enableEventDispatch = tempEnableEventDispatch;
              this.resetCacheGeneratorArmature();
              this.cacheGeneratorArmature.enableCache = temp;
          };
          p.resetCacheGeneratorArmature = function () {
              this.cacheGeneratorArmature.resetAnimation();
          };
          p.getAnimationCache = function (animationName) {
              return this.animationCacheDic[animationName];
          };
          return AnimationCacheManager;
      })();
      dragonBones.AnimationCacheManager = AnimationCacheManager;
      egret.registerClass(AnimationCacheManager,'dragonBones.AnimationCacheManager');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FrameCache = (function () {
          function FrameCache() {
              this.globalTransform = new dragonBones.DBTransform();
              this.globalTransformMatrix = new dragonBones.Matrix();
          }
          var d = __define,c=FrameCache,p=c.prototype;
          p.copy = function (frameCache) {
              this.globalTransform = frameCache.globalTransform;
              this.globalTransformMatrix = frameCache.globalTransformMatrix;
          };
          p.clear = function () {
              this.globalTransform = FrameCache.ORIGIN_TRAMSFORM;
              this.globalTransformMatrix = FrameCache.ORIGIN_MATRIX;
          };
          FrameCache.ORIGIN_TRAMSFORM = new dragonBones.DBTransform();
          FrameCache.ORIGIN_MATRIX = new dragonBones.Matrix();
          return FrameCache;
      })();
      dragonBones.FrameCache = FrameCache;
      egret.registerClass(FrameCache,'dragonBones.FrameCache');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SlotFrameCache = (function (_super) {
          __extends(SlotFrameCache, _super);
          function SlotFrameCache() {
              _super.call(this);
              this.displayIndex = -1;
          }
          var d = __define,c=SlotFrameCache,p=c.prototype;
          p.copy = function (frameCache) {
              _super.prototype.copy.call(this, frameCache);
              this.colorTransform = frameCache.colorTransform;
              this.displayIndex = frameCache.displayIndex;
          };
          p.clear = function () {
              _super.prototype.clear.call(this);
              this.colorTransform = null;
              this.displayIndex = -1;
          };
          return SlotFrameCache;
      })(dragonBones.FrameCache);
      dragonBones.SlotFrameCache = SlotFrameCache;
      egret.registerClass(SlotFrameCache,'dragonBones.SlotFrameCache');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var TimelineCache = (function () {
          function TimelineCache() {
              this.frameCacheList = new Array();
          }
          var d = __define,c=TimelineCache,p=c.prototype;
          p.addFrame = function () {
          };
          p.update = function (frameIndex) {
              if (frameIndex === void 0) { frameIndex = 0; }
              this.currentFrameCache.copy(this.frameCacheList[frameIndex]);
          };
          p.bindCacheUser = function (cacheUser) {
              cacheUser.frameCache = this.currentFrameCache;
          };
          return TimelineCache;
      })();
      dragonBones.TimelineCache = TimelineCache;
      egret.registerClass(TimelineCache,'dragonBones.TimelineCache');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SlotTimelineCache = (function (_super) {
          __extends(SlotTimelineCache, _super);
          function SlotTimelineCache() {
              _super.call(this);
          }
          var d = __define,c=SlotTimelineCache,p=c.prototype;
          p.addFrame = function () {
              var cache = new dragonBones.SlotFrameCache();
              cache.globalTransform.copy(this.cacheGenerator.global);
              cache.globalTransformMatrix.copyFrom(this.cacheGenerator.globalTransformMatrix);
              if (this.cacheGenerator.colorChanged) {
                  cache.colorTransform = dragonBones.ColorTransformUtil.cloneColor(this.cacheGenerator.colorTransform);
              }
              cache.displayIndex = this.cacheGenerator.displayIndex;
              this.frameCacheList.push(cache);
          };
          return SlotTimelineCache;
      })(dragonBones.TimelineCache);
      dragonBones.SlotTimelineCache = SlotTimelineCache;
      egret.registerClass(SlotTimelineCache,'dragonBones.SlotTimelineCache');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Event = (function (_super) {
          __extends(Event, _super);
          function Event(type, bubbles, cancelable) {
              if (bubbles === void 0) { bubbles = false; }
              if (cancelable === void 0) { cancelable = false; }
              _super.call(this, type, bubbles, cancelable);
          }
          var d = __define,c=Event,p=c.prototype;
          return Event;
      })(egret.Event);
      dragonBones.Event = Event;
      egret.registerClass(Event,'dragonBones.Event');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var AnimationEvent = (function (_super) {
          __extends(AnimationEvent, _super);
          function AnimationEvent(type, cancelable) {
              if (cancelable === void 0) { cancelable = false; }
              _super.call(this, type);
          }
          var d = __define,c=AnimationEvent,p=c.prototype;
          d(AnimationEvent, "MOVEMENT_CHANGE"
              ,function () {
                  return AnimationEvent.FADE_IN;
              }
          );
          d(p, "movementID"
              ,function () {
                  return this.animationName;
              }
          );
          d(p, "armature"
              ,function () {
                  return (this.target);
              }
          );
          d(p, "animationName"
              ,function () {
                  return this.animationState.name;
              }
          );
          AnimationEvent.FADE_IN = "fadeIn";
          AnimationEvent.FADE_OUT = "fadeOut";
          AnimationEvent.START = "start";
          AnimationEvent.COMPLETE = "complete";
          AnimationEvent.LOOP_COMPLETE = "loopComplete";
          AnimationEvent.FADE_IN_COMPLETE = "fadeInComplete";
          AnimationEvent.FADE_OUT_COMPLETE = "fadeOutComplete";
          return AnimationEvent;
      })(dragonBones.Event);
      dragonBones.AnimationEvent = AnimationEvent;
      egret.registerClass(AnimationEvent,'dragonBones.AnimationEvent');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var ArmatureEvent = (function (_super) {
          __extends(ArmatureEvent, _super);
          function ArmatureEvent(type) {
              _super.call(this, type);
          }
          var d = __define,c=ArmatureEvent,p=c.prototype;
          ArmatureEvent.Z_ORDER_UPDATED = "zOrderUpdated";
          return ArmatureEvent;
      })(dragonBones.Event);
      dragonBones.ArmatureEvent = ArmatureEvent;
      egret.registerClass(ArmatureEvent,'dragonBones.ArmatureEvent');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FrameEvent = (function (_super) {
          __extends(FrameEvent, _super);
          function FrameEvent(type, cancelable) {
              if (cancelable === void 0) { cancelable = false; }
              _super.call(this, type);
          }
          var d = __define,c=FrameEvent,p=c.prototype;
          d(FrameEvent, "MOVEMENT_FRAME_EVENT"
              ,function () {
                  return FrameEvent.ANIMATION_FRAME_EVENT;
              }
          );
          d(p, "armature"
              ,function () {
                  return (this.target);
              }
          );
          FrameEvent.ANIMATION_FRAME_EVENT = "animationFrameEvent";
          FrameEvent.BONE_FRAME_EVENT = "boneFrameEvent";
          return FrameEvent;
      })(dragonBones.Event);
      dragonBones.FrameEvent = FrameEvent;
      egret.registerClass(FrameEvent,'dragonBones.FrameEvent');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SoundEvent = (function (_super) {
          __extends(SoundEvent, _super);
          function SoundEvent(type, cancelable) {
              if (cancelable === void 0) { cancelable = false; }
              _super.call(this, type);
          }
          var d = __define,c=SoundEvent,p=c.prototype;
          SoundEvent.SOUND = "sound";
          return SoundEvent;
      })(dragonBones.Event);
      dragonBones.SoundEvent = SoundEvent;
      egret.registerClass(SoundEvent,'dragonBones.SoundEvent');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var BaseFactory = (function (_super) {
          __extends(BaseFactory, _super);
          function BaseFactory(self) {
              _super.call(this);
              this.dragonBonesDataDic = {};
              this.textureAtlasDic = {};
              if (self != this) {
                  throw new Error(egret.getString(4001));
              }
          }
          var d = __define,c=BaseFactory,p=c.prototype;
          p.dispose = function (disposeData) {
              if (disposeData === void 0) { disposeData = true; }
              if (disposeData) {
                  for (var skeletonName in this.dragonBonesDataDic) {
                      (this.dragonBonesDataDic[skeletonName]).dispose();
                      delete this.dragonBonesDataDic[skeletonName];
                  }
                  for (var textureAtlasName in this.textureAtlasDic) {
                      var textureAtlasArr = this.textureAtlasDic[textureAtlasName];
                      if (textureAtlasArr) {
                          for (var i = 0, len = textureAtlasArr.length; i < len; i++) {
                              textureAtlasArr[i].dispose();
                          }
                      }
                      delete this.textureAtlasDic[textureAtlasName];
                  }
              }
              this.dragonBonesDataDic = null;
              this.textureAtlasDic = null;
          };
          p.getDragonBonesData = function (name) {
              return this.dragonBonesDataDic[name];
          };
          p.getSkeletonData = function (name) {
              return this.getDragonBonesData(name);
          };
          p.addDragonBonesData = function (data, name) {
              if (name === void 0) { name = null; }
              if (!data) {
                  throw new Error();
              }
              name = name || data.name;
              if (!name) {
                  throw new Error(egret.getString(4002));
              }
              this.dragonBonesDataDic[name] = data;
          };
          p.addSkeletonData = function (data, name) {
              if (name === void 0) { name = null; }
              this.addDragonBonesData(data, name);
          };
          p.removeDragonBonesData = function (name) {
              delete this.dragonBonesDataDic[name];
          };
          p.removeSkeletonData = function (name) {
              delete this.dragonBonesDataDic[name];
          };
          p.getTextureAtlas = function (name) {
              return this.textureAtlasDic[name];
          };
          p.addTextureAtlas = function (textureAtlas, name) {
              if (name === void 0) { name = null; }
              if (!textureAtlas) {
                  throw new Error();
              }
              if (!name && textureAtlas.hasOwnProperty("name")) {
                  name = textureAtlas.name;
              }
              if (!name) {
                  throw new Error(egret.getString(4002));
              }
              var textureAtlasArr = this.textureAtlasDic[name];
              if (textureAtlasArr == null) {
                  textureAtlasArr = [];
                  this.textureAtlasDic[name] = textureAtlasArr;
              }
              if (textureAtlasArr.indexOf(textureAtlas) != -1) {
                  return;
              }
              textureAtlasArr.push(textureAtlas);
          };
          p.removeTextureAtlas = function (name) {
              delete this.textureAtlasDic[name];
          };
          p.getTextureDisplay = function (textureName, textureAtlasName, pivotX, pivotY) {
              if (textureAtlasName === void 0) { textureAtlasName = null; }
              if (pivotX === void 0) { pivotX = NaN; }
              if (pivotY === void 0) { pivotY = NaN; }
              var targetTextureAtlas;
              var textureAtlasArr;
              var i;
              var len;
              if (textureAtlasName) {
                  textureAtlasArr = this.textureAtlasDic[textureAtlasName];
                  if (textureAtlasArr) {
                      for (i = 0, len = textureAtlasArr.length; i < len; i++) {
                          targetTextureAtlas = textureAtlasArr[i];
                          if (targetTextureAtlas.getRegion(textureName)) {
                              break;
                          }
                          targetTextureAtlas = null;
                      }
                  }
              }
              else {
                  for (textureAtlasName in this.textureAtlasDic) {
                      textureAtlasArr = this.textureAtlasDic[textureAtlasName];
                      if (textureAtlasArr) {
                          for (i = 0, len = textureAtlasArr.length; i < len; i++) {
                              targetTextureAtlas = textureAtlasArr[i];
                              if (targetTextureAtlas.getRegion(textureName)) {
                                  break;
                              }
                              targetTextureAtlas = null;
                          }
                          if (targetTextureAtlas != null) {
                              break;
                          }
                      }
                  }
              }
              if (!targetTextureAtlas) {
                  return null;
              }
              if (isNaN(pivotX) || isNaN(pivotY)) {
                  var data = this.dragonBonesDataDic[textureAtlasName];
                  data = data ? data : this.findFirstDragonBonesData();
                  if (data) {
                      var displayData = data.getDisplayDataByName(textureName);
                      if (displayData) {
                          pivotX = displayData.pivot.x;
                          pivotY = displayData.pivot.y;
                      }
                  }
              }
              return this._generateDisplay(targetTextureAtlas, textureName, pivotX, pivotY);
          };
          p.buildArmature = function (armatureName, fromDragonBonesDataName, fromTextureAtlasName, skinName) {
              if (fromDragonBonesDataName === void 0) { fromDragonBonesDataName = null; }
              if (fromTextureAtlasName === void 0) { fromTextureAtlasName = null; }
              if (skinName === void 0) { skinName = null; }
              var buildArmatureDataPackage = {};
              this.fillBuildArmatureDataPackageArmatureInfo(armatureName, fromDragonBonesDataName, buildArmatureDataPackage);
              if (fromTextureAtlasName == null) {
                  fromTextureAtlasName = buildArmatureDataPackage.dragonBonesDataName;
              }
              var dragonBonesData = buildArmatureDataPackage.dragonBonesData;
              var armatureData = buildArmatureDataPackage.armatureData;
              if (!armatureData) {
                  return null;
              }
              return this.buildArmatureUsingArmatureDataFromTextureAtlas(dragonBonesData, armatureData, fromTextureAtlasName, skinName);
          };
          p.buildFastArmature = function (armatureName, fromDragonBonesDataName, fromTextureAtlasName, skinName) {
              if (fromDragonBonesDataName === void 0) { fromDragonBonesDataName = null; }
              if (fromTextureAtlasName === void 0) { fromTextureAtlasName = null; }
              if (skinName === void 0) { skinName = null; }
              var buildArmatureDataPackage = new BuildArmatureDataPackage();
              this.fillBuildArmatureDataPackageArmatureInfo(armatureName, fromDragonBonesDataName, buildArmatureDataPackage);
              if (fromTextureAtlasName == null) {
                  fromTextureAtlasName = buildArmatureDataPackage.dragonBonesDataName;
              }
              var dragonBonesData = buildArmatureDataPackage.dragonBonesData;
              var armatureData = buildArmatureDataPackage.armatureData;
              if (!armatureData) {
                  return null;
              }
              return this.buildFastArmatureUsingArmatureDataFromTextureAtlas(dragonBonesData, armatureData, fromTextureAtlasName, skinName);
          };
          p.buildArmatureUsingArmatureDataFromTextureAtlas = function (dragonBonesData, armatureData, textureAtlasName, skinName) {
              if (skinName === void 0) { skinName = null; }
              var outputArmature = this._generateArmature();
              outputArmature.name = armatureData.name;
              outputArmature.__dragonBonesData = dragonBonesData;
              outputArmature._armatureData = armatureData;
              outputArmature.animation.animationDataList = armatureData.animationDataList;
              this._buildBones(outputArmature);
              this._buildSlots(outputArmature, skinName, textureAtlasName);
              outputArmature.advanceTime(0);
              return outputArmature;
          };
          p.buildFastArmatureUsingArmatureDataFromTextureAtlas = function (dragonBonesData, armatureData, textureAtlasName, skinName) {
              if (skinName === void 0) { skinName = null; }
              var outputArmature = this._generateFastArmature();
              outputArmature.name = armatureData.name;
              outputArmature.__dragonBonesData = dragonBonesData;
              outputArmature._armatureData = armatureData;
              outputArmature.animation.animationDataList = armatureData.animationDataList;
              this._buildFastBones(outputArmature);
              this._buildFastSlots(outputArmature, skinName, textureAtlasName);
              outputArmature.advanceTime(0);
              return outputArmature;
          };
          p.copyAnimationsToArmature = function (toArmature, fromArmatreName, fromDragonBonesDataName, ifRemoveOriginalAnimationList) {
              if (fromDragonBonesDataName === void 0) { fromDragonBonesDataName = null; }
              if (ifRemoveOriginalAnimationList === void 0) { ifRemoveOriginalAnimationList = true; }
              var buildArmatureDataPackage = {};
              if (!this.fillBuildArmatureDataPackageArmatureInfo(fromArmatreName, fromDragonBonesDataName, buildArmatureDataPackage)) {
                  return false;
              }
              var fromArmatureData = buildArmatureDataPackage.armatureData;
              toArmature.animation.animationDataList = fromArmatureData.animationDataList;
              var fromSkinData = fromArmatureData.getSkinData("");
              var fromSlotData;
              var fromDisplayData;
              var toSlotList = toArmature.getSlots(false);
              var toSlot;
              var toSlotDisplayList;
              var toSlotDisplayListLength = 0;
              var toDisplayObject;
              var toChildArmature;
              var length1 = toSlotList.length;
              for (var i1 = 0; i1 < length1; i1++) {
                  toSlot = toSlotList[i1];
                  toSlotDisplayList = toSlot.displayList;
                  toSlotDisplayListLength = toSlotDisplayList.length;
                  for (var i = 0; i < toSlotDisplayListLength; i++) {
                      toDisplayObject = toSlotDisplayList[i];
                      if (toDisplayObject instanceof dragonBones.Armature) {
                          toChildArmature = toDisplayObject;
                          fromSlotData = fromSkinData.getSlotData(toSlot.name);
                          fromDisplayData = fromSlotData.displayDataList[i];
                          if (fromDisplayData.type == dragonBones.DisplayData.ARMATURE) {
                              this.copyAnimationsToArmature(toChildArmature, fromDisplayData.name, buildArmatureDataPackage.dragonBonesDataName, ifRemoveOriginalAnimationList);
                          }
                      }
                  }
              }
              return true;
          };
          p.fillBuildArmatureDataPackageArmatureInfo = function (armatureName, dragonBonesDataName, outputBuildArmatureDataPackage) {
              if (dragonBonesDataName) {
                  outputBuildArmatureDataPackage.dragonBonesDataName = dragonBonesDataName;
                  outputBuildArmatureDataPackage.dragonBonesData = this.dragonBonesDataDic[dragonBonesDataName];
                  outputBuildArmatureDataPackage.armatureData = outputBuildArmatureDataPackage.dragonBonesData.getArmatureDataByName(armatureName);
                  return true;
              }
              else {
                  for (dragonBonesDataName in this.dragonBonesDataDic) {
                      outputBuildArmatureDataPackage.dragonBonesData = this.dragonBonesDataDic[dragonBonesDataName];
                      outputBuildArmatureDataPackage.armatureData = outputBuildArmatureDataPackage.dragonBonesData.getArmatureDataByName(armatureName);
                      if (outputBuildArmatureDataPackage.armatureData) {
                          outputBuildArmatureDataPackage.dragonBonesDataName = dragonBonesDataName;
                          return true;
                      }
                  }
              }
              return false;
          };
          p.fillBuildArmatureDataPackageTextureInfo = function (fromTextureAtlasName, outputBuildArmatureDataPackage) {
              outputBuildArmatureDataPackage.textureAtlas = this.textureAtlasDic[fromTextureAtlasName ? fromTextureAtlasName : outputBuildArmatureDataPackage.dragonBonesDataName];
          };
          p.findFirstDragonBonesData = function () {
              for (var key in this.dragonBonesDataDic) {
                  var outputDragonBonesData = this.dragonBonesDataDic[key];
                  if (outputDragonBonesData) {
                      return outputDragonBonesData;
                  }
              }
              return null;
          };
          p.findFirstTextureAtlas = function () {
              for (var key in this.textureAtlasDic) {
                  var outputTextureAtlas = this.textureAtlasDic[key];
                  if (outputTextureAtlas) {
                      return outputTextureAtlas;
                  }
              }
              return null;
          };
          p._buildBones = function (armature) {
              var boneDataList = armature.armatureData.boneDataList;
              var boneData;
              var bone;
              var parent;
              for (var i = 0; i < boneDataList.length; i++) {
                  boneData = boneDataList[i];
                  bone = dragonBones.Bone.initWithBoneData(boneData);
                  parent = boneData.parent;
                  if (parent && armature.armatureData.getBoneData(parent) == null) {
                      parent = null;
                  }
                  armature.addBone(bone, parent, true);
              }
              armature._updateAnimationAfterBoneListChanged();
          };
          p._buildSlots = function (armature, skinName, textureAtlasName) {
              var skinData = armature.armatureData.getSkinData(skinName);
              if (!skinData) {
                  return;
              }
              armature.armatureData.setSkinData(skinName);
              var displayList = [];
              var slotDataList = armature.armatureData.slotDataList;
              var slotData;
              var slot;
              var bone;
              for (var i = 0; i < slotDataList.length; i++) {
                  slotData = slotDataList[i];
                  bone = armature.getBone(slotData.parent);
                  if (!bone) {
                      continue;
                  }
                  slot = this._generateSlot();
                  slot.initWithSlotData(slotData);
                  bone.addSlot(slot);
                  displayList.length = 0;
                  var l = slotData.displayDataList.length;
                  while (l--) {
                      var displayData = slotData.displayDataList[l];
                      switch (displayData.type) {
                          case dragonBones.DisplayData.ARMATURE:
                              var childArmature = this.buildArmatureUsingArmatureDataFromTextureAtlas(armature.__dragonBonesData, armature.__dragonBonesData.getArmatureDataByName(displayData.name), textureAtlasName, skinName);
                              displayList[l] = childArmature;
                              break;
                          case dragonBones.DisplayData.IMAGE:
                          default:
                              displayList[l] = this.getTextureDisplay(displayData.name, textureAtlasName, displayData.pivot.x, displayData.pivot.y);
                              break;
                      }
                  }
                  for (var j = 0, jLen = displayList.length; j < jLen; j++) {
                      var displayObject = displayList[j];
                      if (!displayObject) {
                          continue;
                      }
                      if (displayObject instanceof dragonBones.Armature) {
                          displayObject = displayObject.display;
                      }
                      if (displayObject.hasOwnProperty("name")) {
                          try {
                              displayObject["name"] = slot.name;
                          }
                          catch (err) {
                          }
                      }
                  }
                  slot.displayList = displayList;
                  slot._changeDisplay(slotData.displayIndex);
              }
          };
          p._buildFastBones = function (armature) {
              var boneDataList = armature.armatureData.boneDataList;
              var boneData;
              var bone;
              for (var i = 0; i < boneDataList.length; i++) {
                  boneData = boneDataList[i];
                  bone = dragonBones.FastBone.initWithBoneData(boneData);
                  armature.addBone(bone, boneData.parent);
              }
          };
          p._buildFastSlots = function (armature, skinName, textureAtlasName) {
              var skinData = armature.armatureData.getSkinData(skinName);
              if (!skinData) {
                  return;
              }
              armature.armatureData.setSkinData(skinName);
              var displayList = [];
              var slotDataList = armature.armatureData.slotDataList;
              var slotData;
              var slot;
              for (var i = 0; i < slotDataList.length; i++) {
                  displayList.length = 0;
                  slotData = slotDataList[i];
                  slot = this._generateFastSlot();
                  slot.initWithSlotData(slotData);
                  var l = slotData.displayDataList.length;
                  while (l--) {
                      var displayData = slotData.displayDataList[l];
                      switch (displayData.type) {
                          case dragonBones.DisplayData.ARMATURE:
                              var childArmature = this.buildFastArmatureUsingArmatureDataFromTextureAtlas(armature.__dragonBonesData, armature.__dragonBonesData.getArmatureDataByName(displayData.name), textureAtlasName, skinName);
                              displayList[l] = childArmature;
                              slot.hasChildArmature = true;
                              break;
                          case dragonBones.DisplayData.IMAGE:
                          default:
                              displayList[l] = this.getTextureDisplay(displayData.name, textureAtlasName, displayData.pivot.x, displayData.pivot.y);
                              break;
                      }
                  }
                  var length1 = displayList.length;
                  for (var i1 = 0; i1 < length1; i1++) {
                      var displayObject = displayList[i1];
                      if (!displayObject) {
                          continue;
                      }
                      if (displayObject instanceof dragonBones.FastArmature) {
                          displayObject = displayObject.display;
                      }
                      if (displayObject.hasOwnProperty("name")) {
                          try {
                              displayObject["name"] = slot.name;
                          }
                          catch (err) {
                          }
                      }
                  }
                  slot.initDisplayList(displayList.concat());
                  armature.addSlot(slot, slotData.parent);
                  slot._changeDisplayIndex(slotData.displayIndex);
              }
          };
          p._generateArmature = function () {
              return null;
          };
          p._generateSlot = function () {
              return null;
          };
          p._generateFastArmature = function () {
              return null;
          };
          p._generateFastSlot = function () {
              return null;
          };
          p._generateDisplay = function (textureAtlas, fullName, pivotX, pivotY) {
              return null;
          };
          BaseFactory._helpMatrix = new dragonBones.Matrix();
          return BaseFactory;
      })(dragonBones.EventDispatcher);
      dragonBones.BaseFactory = BaseFactory;
      egret.registerClass(BaseFactory,'dragonBones.BaseFactory');
      var BuildArmatureDataPackage = (function () {
          function BuildArmatureDataPackage() {
          }
          var d = __define,c=BuildArmatureDataPackage,p=c.prototype;
          return BuildArmatureDataPackage;
      })();
      dragonBones.BuildArmatureDataPackage = BuildArmatureDataPackage;
      egret.registerClass(BuildArmatureDataPackage,'dragonBones.BuildArmatureDataPackage');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastArmature = (function (_super) {
          __extends(FastArmature, _super);
          function FastArmature(display) {
              _super.call(this);
              this.isCacheManagerExclusive = false;
              this._enableEventDispatch = true;
              this.useCache = true;
              this._display = display;
              this._animation = new dragonBones.FastAnimation(this);
              this._slotsZOrderChanged = false;
              this._armatureData = null;
              this.boneList = [];
              this._boneDic = {};
              this.slotList = [];
              this._slotDic = {};
              this.slotHasChildArmatureList = [];
              this._eventList = [];
              this._delayDispose = false;
              this._lockDispose = false;
          }
          var d = __define,c=FastArmature,p=c.prototype;
          p.dispose = function () {
              this._delayDispose = true;
              if (!this._animation || this._lockDispose) {
                  return;
              }
              this.userData = null;
              this._animation.dispose();
              var i = this.slotList.length;
              while (i--) {
                  this.slotList[i].dispose();
              }
              i = this.boneList.length;
              while (i--) {
                  this.boneList[i].dispose();
              }
              this.slotList.length = 0;
              this.boneList.length = 0;
              this._armatureData = null;
              this._animation = null;
              this.slotList = null;
              this.boneList = null;
              this._eventList = null;
          };
          p.advanceTime = function (passedTime) {
              this._lockDispose = true;
              this._animation.advanceTime(passedTime);
              var bone;
              var slot;
              var i = 0;
              if (this._animation.animationState.isUseCache()) {
                  if (!this.useCache) {
                      this.useCache = true;
                  }
                  i = this.slotList.length;
                  while (i--) {
                      slot = this.slotList[i];
                      slot.updateByCache();
                  }
              }
              else {
                  if (this.useCache) {
                      this.useCache = false;
                      i = this.slotList.length;
                      while (i--) {
                          slot = this.slotList[i];
                          slot.switchTransformToBackup();
                      }
                  }
                  i = this.boneList.length;
                  while (i--) {
                      bone = this.boneList[i];
                      bone.update();
                  }
                  i = this.slotList.length;
                  while (i--) {
                      slot = this.slotList[i];
                      slot._update();
                  }
              }
              i = this.slotHasChildArmatureList.length;
              while (i--) {
                  slot = this.slotHasChildArmatureList[i];
                  var childArmature = slot.childArmature;
                  if (childArmature) {
                      childArmature.advanceTime(passedTime);
                  }
              }
              if (this._slotsZOrderChanged) {
                  this.updateSlotsZOrder();
              }
              while (this._eventList.length > 0) {
                  this.dispatchEvent(this._eventList.shift());
              }
              this._lockDispose = false;
              if (this._delayDispose) {
                  this.dispose();
              }
          };
          p.enableAnimationCache = function (frameRate, animationList, loop) {
              if (animationList === void 0) { animationList = null; }
              if (loop === void 0) { loop = true; }
              var animationCacheManager = dragonBones.AnimationCacheManager.initWithArmatureData(this.armatureData, frameRate);
              if (animationList) {
                  var length = animationList.length;
                  for (var i = 0; i < length; i++) {
                      var animationName = animationList[i];
                      animationCacheManager.initAnimationCache(animationName);
                  }
              }
              else {
                  animationCacheManager.initAllAnimationCache();
              }
              animationCacheManager.setCacheGeneratorArmature(this);
              animationCacheManager.generateAllAnimationCache(loop);
              animationCacheManager.bindCacheUserArmature(this);
              this.enableCache = true;
              return animationCacheManager;
          };
          p.getBone = function (boneName) {
              return this._boneDic[boneName];
          };
          p.getSlot = function (slotName) {
              return this._slotDic[slotName];
          };
          p.getBoneByDisplay = function (display) {
              var slot = this.getSlotByDisplay(display);
              return slot ? slot.parent : null;
          };
          p.getSlotByDisplay = function (displayObj) {
              if (displayObj) {
                  for (var i = 0, len = this.slotList.length; i < len; i++) {
                      if (this.slotList[i].display == displayObj) {
                          return this.slotList[i];
                      }
                  }
              }
              return null;
          };
          p.getSlots = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this.slotList.concat() : this.slotList;
          };
          p._updateBonesByCache = function () {
              var i = this.boneList.length;
              var bone;
              while (i--) {
                  bone = this.boneList[i];
                  bone.update();
              }
          };
          p.addBone = function (bone, parentName) {
              if (parentName === void 0) { parentName = null; }
              var parentBone;
              if (parentName) {
                  parentBone = this.getBone(parentName);
                  parentBone.boneList.push(bone);
              }
              bone.armature = this;
              bone.setParent(parentBone);
              this.boneList.unshift(bone);
              this._boneDic[bone.name] = bone;
          };
          p.addSlot = function (slot, parentBoneName) {
              var bone = this.getBone(parentBoneName);
              if (bone) {
                  slot.armature = this;
                  slot.setParent(bone);
                  bone.slotList.push(slot);
                  slot._addDisplayToContainer(this.display);
                  this.slotList.push(slot);
                  this._slotDic[slot.name] = slot;
                  if (slot.hasChildArmature) {
                      this.slotHasChildArmatureList.push(slot);
                  }
              }
              else {
                  throw new Error();
              }
          };
          p.updateSlotsZOrder = function () {
              this.slotList.sort(this.sortSlot);
              var i = this.slotList.length;
              while (i--) {
                  var slot = this.slotList[i];
                  if ((slot._frameCache && (slot._frameCache).displayIndex >= 0)
                      || (!slot._frameCache && slot.displayIndex >= 0)) {
                      slot._addDisplayToContainer(this._display);
                  }
              }
              this._slotsZOrderChanged = false;
          };
          p.sortBoneList = function () {
              var i = this.boneList.length;
              if (i == 0) {
                  return;
              }
              var helpArray = [];
              while (i--) {
                  var level = 0;
                  var bone = this.boneList[i];
                  var boneParent = bone;
                  while (boneParent) {
                      level++;
                      boneParent = boneParent.parent;
                  }
                  helpArray[i] = [level, bone];
              }
              helpArray.sort(dragonBones.ArmatureData.sortBoneDataHelpArrayDescending);
              i = helpArray.length;
              while (i--) {
                  this.boneList[i] = helpArray[i][1];
              }
              helpArray.length = 0;
          };
          p.arriveAtFrame = function (frame, animationState) {
              if (frame.event && this.hasEventListener(dragonBones.FrameEvent.ANIMATION_FRAME_EVENT)) {
                  var frameEvent = new dragonBones.FrameEvent(dragonBones.FrameEvent.ANIMATION_FRAME_EVENT);
                  frameEvent.animationState = animationState;
                  frameEvent.frameLabel = frame.event;
                  this._addEvent(frameEvent);
              }
              if (frame.action) {
                  this.animation.gotoAndPlay(frame.action);
              }
          };
          p.invalidUpdate = function (boneName) {
              if (boneName === void 0) { boneName = null; }
              if (boneName) {
                  var bone = this.getBone(boneName);
                  if (bone) {
                      bone.invalidUpdate();
                  }
              }
              else {
                  var i = this.boneList.length;
                  while (i--) {
                      this.boneList[i].invalidUpdate();
                  }
              }
          };
          p.resetAnimation = function () {
              this.animation.animationState._resetTimelineStateList();
              var length = this.boneList.length;
              for (var i = 0; i < length; i++) {
                  var boneItem = this.boneList[i];
                  boneItem._timelineState = null;
              }
              this.animation.stop();
          };
          p.sortSlot = function (slot1, slot2) {
              return slot1.zOrder < slot2.zOrder ? 1 : -1;
          };
          p.getAnimation = function () {
              return this._animation;
          };
          d(p, "armatureData"
              ,function () {
                  return this._armatureData;
              }
          );
          d(p, "animation"
              ,function () {
                  return this._animation;
              }
          );
          d(p, "display"
              ,function () {
                  return this._display;
              }
          );
          d(p, "enableCache"
              ,function () {
                  return this._enableCache;
              }
              ,function (value) {
                  this._enableCache = value;
              }
          );
          d(p, "enableEventDispatch"
              ,function () {
                  return this._enableEventDispatch;
              }
              ,function (value) {
                  this._enableEventDispatch = value;
              }
          );
          p._addEvent = function (event) {
              if (this._enableEventDispatch) {
                  this._eventList.push(event);
              }
          };
          return FastArmature;
      })(dragonBones.EventDispatcher);
      dragonBones.FastArmature = FastArmature;
      egret.registerClass(FastArmature,'dragonBones.FastArmature',["dragonBones.ICacheableArmature","dragonBones.IArmature","dragonBones.IAnimatable"]);
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastDBObject = (function () {
          function FastDBObject() {
              this._globalTransformMatrix = new dragonBones.Matrix();
              this._global = new dragonBones.DBTransform();
              this._origin = new dragonBones.DBTransform();
              this._visible = true;
              this.armature = null;
              this._parent = null;
              this.userData = null;
              this.inheritRotation = true;
              this.inheritScale = true;
              this.inheritTranslation = true;
          }
          var d = __define,c=FastDBObject,p=c.prototype;
          p.updateByCache = function () {
              this._global = this._frameCache.globalTransform;
              this._globalTransformMatrix = this._frameCache.globalTransformMatrix;
          };
          p.switchTransformToBackup = function () {
              if (!this._globalBackup) {
                  this._globalBackup = new dragonBones.DBTransform();
                  this._globalTransformMatrixBackup = new dragonBones.Matrix();
              }
              this._global = this._globalBackup;
              this._globalTransformMatrix = this._globalTransformMatrixBackup;
          };
          p.setParent = function (value) {
              this._parent = value;
          };
          p.dispose = function () {
              this.userData = null;
              this._globalTransformMatrix = null;
              this._global = null;
              this._origin = null;
              this.armature = null;
              this._parent = null;
          };
          p._calculateParentTransform = function () {
              if (this.parent && (this.inheritTranslation || this.inheritRotation || this.inheritScale)) {
                  var parentGlobalTransform = this._parent._global;
                  var parentGlobalTransformMatrix = this._parent._globalTransformMatrix;
                  if (!this.inheritTranslation && (parentGlobalTransform.x != 0 || parentGlobalTransform.y != 0) ||
                      !this.inheritRotation && (parentGlobalTransform.skewX != 0 || parentGlobalTransform.skewY != 0) ||
                      !this.inheritScale && (parentGlobalTransform.scaleX != 1 || parentGlobalTransform.scaleY != 1)) {
                      parentGlobalTransform = FastDBObject._tempParentGlobalTransform;
                      parentGlobalTransform.copy(this._parent._global);
                      if (!this.inheritTranslation) {
                          parentGlobalTransform.x = 0;
                          parentGlobalTransform.y = 0;
                      }
                      if (!this.inheritScale) {
                          parentGlobalTransform.scaleX = 1;
                          parentGlobalTransform.scaleY = 1;
                      }
                      if (!this.inheritRotation) {
                          parentGlobalTransform.skewX = 0;
                          parentGlobalTransform.skewY = 0;
                      }
                      parentGlobalTransformMatrix = dragonBones.DBObject._tempParentGlobalTransformMatrix;
                      dragonBones.TransformUtil.transformToMatrix(parentGlobalTransform, parentGlobalTransformMatrix);
                  }
                  FastDBObject.tempOutputObj.parentGlobalTransform = parentGlobalTransform;
                  FastDBObject.tempOutputObj.parentGlobalTransformMatrix = parentGlobalTransformMatrix;
                  return FastDBObject.tempOutputObj;
              }
              return null;
          };
          p._updateGlobal = function () {
              this._calculateRelativeParentTransform();
              var output = this._calculateParentTransform();
              if (output != null) {
                  var parentMatrix = output.parentGlobalTransformMatrix;
                  var parentGlobalTransform = output.parentGlobalTransform;
                  var x = this._global.x;
                  var y = this._global.y;
                  this._global.x = parentMatrix.a * x + parentMatrix.c * y + parentMatrix.tx;
                  this._global.y = parentMatrix.d * y + parentMatrix.b * x + parentMatrix.ty;
                  if (this.inheritRotation) {
                      this._global.skewX += parentGlobalTransform.skewX;
                      this._global.skewY += parentGlobalTransform.skewY;
                  }
                  if (this.inheritScale) {
                      this._global.scaleX *= parentGlobalTransform.scaleX;
                      this._global.scaleY *= parentGlobalTransform.scaleY;
                  }
              }
              dragonBones.TransformUtil.transformToMatrix(this._global, this._globalTransformMatrix, true);
              return output;
          };
          p._calculateRelativeParentTransform = function () {
          };
          d(p, "name"
              ,function () {
                  return this._name;
              }
              ,function (value) {
                  this._name = value;
              }
          );
          d(p, "global"
              ,function () {
                  return this._global;
              }
          );
          d(p, "globalTransformMatrix"
              ,function () {
                  return this._globalTransformMatrix;
              }
          );
          d(p, "origin"
              ,function () {
                  return this._origin;
              }
          );
          d(p, "parent"
              ,function () {
                  return this._parent;
              }
          );
          d(p, "visible"
              ,function () {
                  return this._visible;
              }
              ,function (value) {
                  this._visible = value;
              }
          );
          d(p, "frameCache",undefined
              ,function (cache) {
                  this._frameCache = cache;
              }
          );
          FastDBObject._tempParentGlobalTransform = new dragonBones.DBTransform();
          FastDBObject.tempOutputObj = {};
          return FastDBObject;
      })();
      dragonBones.FastDBObject = FastDBObject;
      egret.registerClass(FastDBObject,'dragonBones.FastDBObject');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastBone = (function (_super) {
          __extends(FastBone, _super);
          function FastBone() {
              _super.call(this);
              this.slotList = [];
              this.boneList = [];
              this._needUpdate = 0;
              this._needUpdate = 2;
              this._tweenPivot = new dragonBones.Point();
          }
          var d = __define,c=FastBone,p=c.prototype;
          FastBone.initWithBoneData = function (boneData) {
              var outputBone = new FastBone();
              outputBone.name = boneData.name;
              outputBone.inheritRotation = boneData.inheritRotation;
              outputBone.inheritScale = boneData.inheritScale;
              outputBone.origin.copy(boneData.transform);
              return outputBone;
          };
          p.getBones = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this.boneList.concat() : this.boneList;
          };
          p.getSlots = function (returnCopy) {
              if (returnCopy === void 0) { returnCopy = true; }
              return returnCopy ? this.slotList.concat() : this.slotList;
          };
          p.dispose = function () {
              _super.prototype.dispose.call(this);
              this._timelineState = null;
              this._tweenPivot = null;
          };
          p.invalidUpdate = function () {
              this._needUpdate = 2;
          };
          p._calculateRelativeParentTransform = function () {
              this._global.copy(this._origin);
              if (this._timelineState) {
                  this._global.add(this._timelineState._transform);
              }
          };
          p.updateByCache = function () {
              _super.prototype.updateByCache.call(this);
              this._global = this._frameCache.globalTransform;
              this._globalTransformMatrix = this._frameCache.globalTransformMatrix;
          };
          p.update = function (needUpdate) {
              if (needUpdate === void 0) { needUpdate = false; }
              this._needUpdate--;
              if (needUpdate || this._needUpdate > 0 || (this._parent && this._parent._needUpdate > 0)) {
                  this._needUpdate = 1;
              }
              else {
                  return;
              }
              this.blendingTimeline();
              this._updateGlobal();
          };
          p._hideSlots = function () {
              var length = this.slotList.length;
              for (var i = 0; i < length; i++) {
                  var childSlot = this.slotList[i];
                  childSlot.hideSlots();
              }
          };
          p.blendingTimeline = function () {
              if (this._timelineState) {
                  this._tweenPivot.x = this._timelineState._pivot.x;
                  this._tweenPivot.y = this._timelineState._pivot.y;
              }
          };
          p.arriveAtFrame = function (frame, animationState) {
              var childSlot;
              if (frame.event && this.armature.hasEventListener(dragonBones.FrameEvent.BONE_FRAME_EVENT)) {
                  var frameEvent = new dragonBones.FrameEvent(dragonBones.FrameEvent.BONE_FRAME_EVENT);
                  frameEvent.bone = this;
                  frameEvent.animationState = animationState;
                  frameEvent.frameLabel = frame.event;
                  this.armature._addEvent(frameEvent);
              }
          };
          d(p, "childArmature"
              ,function () {
                  var s = this.slot;
                  if (s) {
                      return s.childArmature;
                  }
                  return null;
              }
          );
          d(p, "display"
              ,function () {
                  var s = this.slot;
                  if (s) {
                      return s.display;
                  }
                  return null;
              }
              ,function (value) {
                  var s = this.slot;
                  if (s) {
                      s.display = value;
                  }
              }
          );
          d(p, "visible",undefined
              ,function (value) {
                  if (this._visible != value) {
                      this._visible = value;
                      for (var i = 0, len = this.armature.slotList.length; i < len; i++) {
                          if (this.armature.slotList[i].parent == this) {
                              this.armature.slotList[i]._updateDisplayVisible(this._visible);
                          }
                      }
                  }
              }
          );
          d(p, "slot"
              ,function () {
                  return this.slotList.length > 0 ? this.slotList[0] : null;
              }
          );
          return FastBone;
      })(dragonBones.FastDBObject);
      dragonBones.FastBone = FastBone;
      egret.registerClass(FastBone,'dragonBones.FastBone');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastSlot = (function (_super) {
          __extends(FastSlot, _super);
          function FastSlot(self) {
              _super.call(this);
              this._currentDisplayIndex = 0;
              if (self != this) {
                  throw new Error("Abstract class can not be instantiated!");
              }
              this.hasChildArmature = false;
              this._currentDisplayIndex = -1;
              this._originZOrder = 0;
              this._tweenZOrder = 0;
              this._offsetZOrder = 0;
              this._colorTransform = new dragonBones.ColorTransform();
              this._isColorChanged = false;
              this._displayDataList = null;
              this._currentDisplay = null;
              this.inheritRotation = true;
              this.inheritScale = true;
          }
          var d = __define,c=FastSlot,p=c.prototype;
          p.initWithSlotData = function (slotData) {
              this.name = slotData.name;
              this.blendMode = slotData.blendMode;
              this._originZOrder = slotData.zOrder;
              this._displayDataList = slotData.displayDataList;
              this._originDisplayIndex = slotData.displayIndex;
          };
          p.dispose = function () {
              if (!this._displayList) {
                  return;
              }
              _super.prototype.dispose.call(this);
              this._displayDataList = null;
              this._displayList = null;
              this._currentDisplay = null;
          };
          p.updateByCache = function () {
              _super.prototype.updateByCache.call(this);
              this._updateTransform();
              var cacheColor = (this._frameCache).colorTransform;
              var cacheColorChanged = cacheColor != null;
              if (this.colorChanged != cacheColorChanged ||
                  (this.colorChanged && cacheColorChanged && !dragonBones.ColorTransformUtil.isEqual(this._colorTransform, cacheColor))) {
                  cacheColor = cacheColor || dragonBones.ColorTransformUtil.originalColor;
                  this._updateDisplayColor(cacheColor.alphaOffset, cacheColor.redOffset, cacheColor.greenOffset, cacheColor.blueOffset, cacheColor.alphaMultiplier, cacheColor.redMultiplier, cacheColor.greenMultiplier, cacheColor.blueMultiplier, cacheColorChanged);
              }
              this._changeDisplayIndex((this._frameCache).displayIndex);
          };
          p._update = function () {
              if (this._parent._needUpdate <= 0) {
                  return;
              }
              this._updateGlobal();
              this._updateTransform();
          };
          p._calculateRelativeParentTransform = function () {
              this._global.copy(this._origin);
              this._global.x += this._parent._tweenPivot.x;
              this._global.y += this._parent._tweenPivot.y;
          };
          p.initDisplayList = function (newDisplayList) {
              this._displayList = newDisplayList;
          };
          p.clearCurrentDisplay = function () {
              if (this.hasChildArmature) {
                  var targetArmature = this.childArmature;
                  if (targetArmature) {
                      targetArmature.resetAnimation();
                  }
              }
              var slotIndex = this._getDisplayIndex();
              this._removeDisplayFromContainer();
              return slotIndex;
          };
          p._changeDisplayIndex = function (displayIndex) {
              if (displayIndex === void 0) { displayIndex = 0; }
              if (this._currentDisplayIndex == displayIndex) {
                  return;
              }
              var slotIndex = -1;
              if (this._currentDisplayIndex >= 0) {
                  slotIndex = this.clearCurrentDisplay();
              }
              this._currentDisplayIndex = displayIndex;
              if (this._currentDisplayIndex >= 0) {
                  this._origin.copy(this._displayDataList[this._currentDisplayIndex].transform);
                  this.initCurrentDisplay(slotIndex);
              }
          };
          p.changeSlotDisplay = function (value) {
              var slotIndex = this.clearCurrentDisplay();
              this._displayList[this._currentDisplayIndex] = value;
              this.initCurrentDisplay(slotIndex);
          };
          p.initCurrentDisplay = function (slotIndex) {
              if (slotIndex === void 0) { slotIndex = 0; }
              var display = this._displayList[this._currentDisplayIndex];
              if (display) {
                  if (display instanceof dragonBones.FastArmature) {
                      this._currentDisplay = display.display;
                  }
                  else {
                      this._currentDisplay = display;
                  }
              }
              else {
                  this._currentDisplay = null;
              }
              this._updateDisplay(this._currentDisplay);
              if (this._currentDisplay) {
                  if (slotIndex != -1) {
                      this._addDisplayToContainer(this.armature.display, slotIndex);
                  }
                  else {
                      this.armature._slotsZOrderChanged = true;
                      this._addDisplayToContainer(this.armature.display);
                  }
                  if (this._blendMode) {
                      this._updateDisplayBlendMode(this._blendMode);
                  }
                  if (this._isColorChanged) {
                      this._updateDisplayColor(this._colorTransform.alphaOffset, this._colorTransform.redOffset, this._colorTransform.greenOffset, this._colorTransform.blueOffset, this._colorTransform.alphaMultiplier, this._colorTransform.redMultiplier, this._colorTransform.greenMultiplier, this._colorTransform.blueMultiplier, true);
                  }
                  this._updateTransform();
                  if (display instanceof dragonBones.FastArmature) {
                      var targetArmature = (display);
                      if (this.armature &&
                          this.armature.animation.animationState &&
                          targetArmature.animation.hasAnimation(this.armature.animation.animationState.name)) {
                          targetArmature.animation.gotoAndPlay(this.armature.animation.animationState.name);
                      }
                      else {
                          targetArmature.animation.play();
                      }
                  }
              }
          };
          d(p, "visible",undefined
              ,function (value) {
                  if (this._visible != value) {
                      this._visible = value;
                      this._updateDisplayVisible(this._visible);
                  }
              }
          );
          d(p, "displayList"
              ,function () {
                  return this._displayList;
              }
              ,function (value) {
                  if (!value) {
                      throw new Error();
                  }
                  var newDisplay = value[this._currentDisplayIndex];
                  var displayChanged = this._currentDisplayIndex >= 0 && this._displayList[this._currentDisplayIndex] != newDisplay;
                  this._displayList = value;
                  if (displayChanged) {
                      this.changeSlotDisplay(newDisplay);
                  }
              }
          );
          d(p, "display"
              ,function () {
                  return this._currentDisplay;
              }
              ,function (value) {
                  if (this._currentDisplayIndex < 0) {
                      return;
                  }
                  if (this._displayList[this._currentDisplayIndex] == value) {
                      return;
                  }
                  this.changeSlotDisplay(value);
              }
          );
          d(p, "childArmature"
              ,function () {
                  return (this._displayList[this._currentDisplayIndex] instanceof dragonBones.Armature
                      || this._displayList[this._currentDisplayIndex] instanceof dragonBones.FastArmature) ? this._displayList[this._currentDisplayIndex] : null;
              }
              ,function (value) {
                  this.display = value;
              }
          );
          d(p, "zOrder"
              ,function () {
                  return this._originZOrder + this._tweenZOrder + this._offsetZOrder;
              }
              ,function (value) {
                  if (this.zOrder != value) {
                      this._offsetZOrder = value - this._originZOrder - this._tweenZOrder;
                      if (this.armature) {
                          this.armature._slotsZOrderChanged = true;
                      }
                  }
              }
          );
          d(p, "blendMode"
              ,function () {
                  return this._blendMode;
              }
              ,function (value) {
                  if (this._blendMode != value) {
                      this._blendMode = value;
                      this._updateDisplayBlendMode(this._blendMode);
                  }
              }
          );
          d(p, "colorTransform"
              ,function () {
                  return this._colorTransform;
              }
          );
          d(p, "displayIndex"
              ,function () {
                  return this._currentDisplayIndex;
              }
          );
          d(p, "colorChanged"
              ,function () {
                  return this._isColorChanged;
              }
          );
          p._updateDisplay = function (value) {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._getDisplayIndex = function () {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._addDisplayToContainer = function (container, index) {
              if (index === void 0) { index = -1; }
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._removeDisplayFromContainer = function () {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._updateTransform = function () {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._updateDisplayVisible = function (value) {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._updateDisplayColor = function (aOffset, rOffset, gOffset, bOffset, aMultiplier, rMultiplier, gMultiplier, bMultiplier, colorChanged) {
              if (colorChanged === void 0) { colorChanged = false; }
              this._colorTransform.alphaOffset = aOffset;
              this._colorTransform.redOffset = rOffset;
              this._colorTransform.greenOffset = gOffset;
              this._colorTransform.blueOffset = bOffset;
              this._colorTransform.alphaMultiplier = aMultiplier;
              this._colorTransform.redMultiplier = rMultiplier;
              this._colorTransform.greenMultiplier = gMultiplier;
              this._colorTransform.blueMultiplier = bMultiplier;
              this._isColorChanged = colorChanged;
          };
          p._updateDisplayBlendMode = function (value) {
              throw new Error("Abstract method needs to be implemented in subclass!");
          };
          p._arriveAtFrame = function (frame, animationState) {
              var slotFrame = frame;
              var displayIndex = slotFrame.displayIndex;
              this._changeDisplayIndex(displayIndex);
              this._updateDisplayVisible(slotFrame.visible);
              if (displayIndex >= 0) {
                  if (!isNaN(slotFrame.zOrder) && slotFrame.zOrder != this._tweenZOrder) {
                      this._tweenZOrder = slotFrame.zOrder;
                      this.armature._slotsZOrderChanged = true;
                  }
              }
              if (frame.action) {
                  var targetArmature = this.childArmature;
                  if (targetArmature) {
                      targetArmature.getAnimation().gotoAndPlay(frame.action);
                  }
              }
          };
          p.hideSlots = function () {
              this._changeDisplayIndex(-1);
              this._removeDisplayFromContainer();
              if (this._frameCache) {
                  this._frameCache.clear();
              }
          };
          p._updateGlobal = function () {
              this._calculateRelativeParentTransform();
              dragonBones.TransformUtil.transformToMatrix(this._global, this._globalTransformMatrix, true);
              var output = this._calculateParentTransform();
              if (output) {
                  this._globalTransformMatrix.concat(output.parentGlobalTransformMatrix);
                  dragonBones.TransformUtil.matrixToTransform(this._globalTransformMatrix, this._global, this._global.scaleX * output.parentGlobalTransform.scaleX >= 0, this._global.scaleY * output.parentGlobalTransform.scaleY >= 0);
              }
              return output;
          };
          p._resetToOrigin = function () {
              this._changeDisplayIndex(this._originDisplayIndex);
              this._updateDisplayColor(0, 0, 0, 0, 1, 1, 1, 1, true);
          };
          return FastSlot;
      })(dragonBones.FastDBObject);
      dragonBones.FastSlot = FastSlot;
      egret.registerClass(FastSlot,'dragonBones.FastSlot',["dragonBones.ISlotCacheGenerator","dragonBones.ICacheUser"]);
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Point = (function () {
          function Point(x, y) {
              if (x === void 0) { x = 0; }
              if (y === void 0) { y = 0; }
              this.x = x;
              this.y = y;
          }
          var d = __define,c=Point,p=c.prototype;
          p.toString = function () {
              return "[Point (x=" + this.x + " y=" + this.y + ")]";
          };
          return Point;
      })();
      dragonBones.Point = Point;
      egret.registerClass(Point,'dragonBones.Point');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Rectangle = (function () {
          function Rectangle(x, y, width, height) {
              if (x === void 0) { x = 0; }
              if (y === void 0) { y = 0; }
              if (width === void 0) { width = 0; }
              if (height === void 0) { height = 0; }
              this.x = x;
              this.y = y;
              this.width = width;
              this.height = height;
          }
          var d = __define,c=Rectangle,p=c.prototype;
          return Rectangle;
      })();
      dragonBones.Rectangle = Rectangle;
      egret.registerClass(Rectangle,'dragonBones.Rectangle');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Data3Parser = (function () {
          function Data3Parser() {
          }
          var d = __define,c=Data3Parser,p=c.prototype;
          Data3Parser.parseDragonBonesData = function (rawDataToParse) {
              if (!rawDataToParse) {
                  throw new Error();
              }
              var version = rawDataToParse[dragonBones.ConstValues.A_VERSION];
              version = version.toString();
              if (version.toString() != dragonBones.DragonBones.DATA_VERSION &&
                  version.toString() != dragonBones.DragonBones.PARENT_COORDINATE_DATA_VERSION &&
                  version.toString() != "2.3") {
                  throw new Error("Nonsupport version!");
              }
              var frameRate = Data3Parser.getNumber(rawDataToParse, dragonBones.ConstValues.A_FRAME_RATE, 0) || 0;
              var outputDragonBonesData = new dragonBones.DragonBonesData();
              outputDragonBonesData.name = rawDataToParse[dragonBones.ConstValues.A_NAME];
              outputDragonBonesData.isGlobal = rawDataToParse[dragonBones.ConstValues.A_IS_GLOBAL] == "0" ? false : true;
              Data3Parser.tempDragonBonesData = outputDragonBonesData;
              var armatureList = rawDataToParse[dragonBones.ConstValues.ARMATURE];
              for (var i = 0, len = armatureList.length; i < len; i++) {
                  var armatureObject = armatureList[i];
                  outputDragonBonesData.addArmatureData(Data3Parser.parseArmatureData(armatureObject, frameRate));
              }
              Data3Parser.tempDragonBonesData = null;
              return outputDragonBonesData;
          };
          Data3Parser.parseArmatureData = function (armatureDataToParse, frameRate) {
              var outputArmatureData = new dragonBones.ArmatureData();
              outputArmatureData.name = armatureDataToParse[dragonBones.ConstValues.A_NAME];
              var i;
              var len;
              var boneList = armatureDataToParse[dragonBones.ConstValues.BONE];
              for (i = 0, len = boneList.length; i < len; i++) {
                  var boneObject = boneList[i];
                  outputArmatureData.addBoneData(Data3Parser.parseBoneData(boneObject));
              }
              var skinList = armatureDataToParse[dragonBones.ConstValues.SKIN];
              for (i = 0, len = skinList.length; i < len; i++) {
                  var skinSlotList = skinList[i];
                  var skinSlotObject = skinSlotList[dragonBones.ConstValues.SLOT];
                  for (var j = 0, jLen = skinSlotObject.length; j < jLen; j++) {
                      var slotObject = skinSlotObject[j];
                      outputArmatureData.addSlotData(Data3Parser.parseSlotData(slotObject));
                  }
              }
              for (i = 0, len = skinList.length; i < len; i++) {
                  var skinObject = skinList[i];
                  outputArmatureData.addSkinData(Data3Parser.parseSkinData(skinObject));
              }
              if (Data3Parser.tempDragonBonesData.isGlobal) {
                  dragonBones.DBDataUtil.transformArmatureData(outputArmatureData);
              }
              outputArmatureData.sortBoneDataList();
              var animationList = armatureDataToParse[dragonBones.ConstValues.ANIMATION];
              for (i = 0, len = animationList.length; i < len; i++) {
                  var animationObject = animationList[i];
                  var animationData = Data3Parser.parseAnimationData(animationObject, frameRate);
                  dragonBones.DBDataUtil.addHideTimeline(animationData, outputArmatureData);
                  dragonBones.DBDataUtil.transformAnimationData(animationData, outputArmatureData, Data3Parser.tempDragonBonesData.isGlobal);
                  outputArmatureData.addAnimationData(animationData);
              }
              return outputArmatureData;
          };
          Data3Parser.parseBoneData = function (boneObject) {
              var boneData = new dragonBones.BoneData();
              boneData.name = boneObject[dragonBones.ConstValues.A_NAME];
              boneData.parent = boneObject[dragonBones.ConstValues.A_PARENT];
              boneData.length = Number(boneObject[dragonBones.ConstValues.A_LENGTH]) || 0;
              boneData.inheritRotation = Data3Parser.getBoolean(boneObject, dragonBones.ConstValues.A_INHERIT_ROTATION, true);
              boneData.inheritScale = Data3Parser.getBoolean(boneObject, dragonBones.ConstValues.A_INHERIT_SCALE, true);
              Data3Parser.parseTransform(boneObject[dragonBones.ConstValues.TRANSFORM], boneData.transform);
              if (Data3Parser.tempDragonBonesData.isGlobal) {
                  boneData.global.copy(boneData.transform);
              }
              return boneData;
          };
          Data3Parser.parseSkinData = function (skinObject) {
              var skinData = new dragonBones.SkinData();
              skinData.name = skinObject[dragonBones.ConstValues.A_NAME];
              var slotList = skinObject[dragonBones.ConstValues.SLOT];
              for (var i = 0, len = slotList.length; i < len; i++) {
                  var slotObject = slotList[i];
                  skinData.addSlotData(Data3Parser.parseSkinSlotData(slotObject));
              }
              return skinData;
          };
          Data3Parser.parseSkinSlotData = function (slotObject) {
              var slotData = new dragonBones.SlotData();
              slotData.name = slotObject[dragonBones.ConstValues.A_NAME];
              slotData.parent = slotObject[dragonBones.ConstValues.A_PARENT];
              slotData.zOrder = (slotObject[dragonBones.ConstValues.A_Z_ORDER]);
              slotData.zOrder = Data3Parser.getNumber(slotObject, dragonBones.ConstValues.A_Z_ORDER, 0) || 0;
              slotData.blendMode = slotObject[dragonBones.ConstValues.A_BLENDMODE];
              var displayList = slotObject[dragonBones.ConstValues.DISPLAY];
              if (displayList) {
                  for (var i = 0, len = displayList.length; i < len; i++) {
                      var displayObject = displayList[i];
                      slotData.addDisplayData(Data3Parser.parseDisplayData(displayObject));
                  }
              }
              return slotData;
          };
          Data3Parser.parseSlotData = function (slotObject) {
              var slotData = new dragonBones.SlotData();
              slotData.name = slotObject[dragonBones.ConstValues.A_NAME];
              slotData.parent = slotObject[dragonBones.ConstValues.A_PARENT];
              slotData.zOrder = (slotObject[dragonBones.ConstValues.A_Z_ORDER]);
              slotData.zOrder = Data3Parser.getNumber(slotObject, dragonBones.ConstValues.A_Z_ORDER, 0) || 0;
              slotData.blendMode = slotObject[dragonBones.ConstValues.A_BLENDMODE];
              slotData.displayIndex = 0;
              return slotData;
          };
          Data3Parser.parseDisplayData = function (displayObject) {
              var displayData = new dragonBones.DisplayData();
              displayData.name = displayObject[dragonBones.ConstValues.A_NAME];
              displayData.type = displayObject[dragonBones.ConstValues.A_TYPE];
              Data3Parser.parseTransform(displayObject[dragonBones.ConstValues.TRANSFORM], displayData.transform, displayData.pivot);
              if (Data3Parser.tempDragonBonesData != null) {
                  Data3Parser.tempDragonBonesData.addDisplayData(displayData);
              }
              return displayData;
          };
          Data3Parser.parseAnimationData = function (animationObject, frameRate) {
              var animationData = new dragonBones.AnimationData();
              animationData.name = animationObject[dragonBones.ConstValues.A_NAME];
              animationData.frameRate = frameRate;
              animationData.duration = Math.round((Data3Parser.getNumber(animationObject, dragonBones.ConstValues.A_DURATION, 1) || 1) * 1000 / frameRate);
              animationData.playTimes = Data3Parser.getNumber(animationObject, dragonBones.ConstValues.A_LOOP, 1);
              animationData.playTimes = animationData.playTimes != NaN ? animationData.playTimes : 1;
              animationData.fadeTime = Data3Parser.getNumber(animationObject, dragonBones.ConstValues.A_FADE_IN_TIME, 0) || 0;
              animationData.scale = Data3Parser.getNumber(animationObject, dragonBones.ConstValues.A_SCALE, 1) || 0;
              animationData.tweenEasing = Data3Parser.getNumber(animationObject, dragonBones.ConstValues.A_TWEEN_EASING, NaN);
              animationData.autoTween = Data3Parser.getBoolean(animationObject, dragonBones.ConstValues.A_AUTO_TWEEN, true);
              var frameObjectList = animationObject[dragonBones.ConstValues.FRAME];
              var i = 0;
              var len = 0;
              if (frameObjectList) {
                  for (i = 0, len = frameObjectList.length; i < len; i++) {
                      var frameObject = frameObjectList[i];
                      var frame = Data3Parser.parseTransformFrame(frameObject, null, frameRate);
                      animationData.addFrame(frame);
                  }
              }
              Data3Parser.parseTimeline(animationObject, animationData);
              var lastFrameDuration = animationData.duration;
              var displayIndexChangeSlotTimelines = [];
              var displayIndexChangeTimelines = [];
              var timelineObjectList = animationObject[dragonBones.ConstValues.TIMELINE];
              var displayIndexChange;
              if (timelineObjectList) {
                  for (i = 0, len = timelineObjectList.length; i < len; i++) {
                      var timelineObject = timelineObjectList[i];
                      var timeline = Data3Parser.parseTransformTimeline(timelineObject, animationData.duration, frameRate);
                      timeline = Data3Parser.parseTransformTimeline(timelineObject, animationData.duration, frameRate);
                      lastFrameDuration = Math.min(lastFrameDuration, timeline.frameList[timeline.frameList.length - 1].duration);
                      animationData.addTimeline(timeline);
                      var slotTimeline = Data3Parser.parseSlotTimeline(timelineObject, animationData.duration, frameRate);
                      animationData.addSlotTimeline(slotTimeline);
                      if (animationData.autoTween && !displayIndexChange) {
                          var slotFrame;
                          for (var j = 0, jlen = slotTimeline.frameList.length; j < jlen; j++) {
                              slotFrame = slotTimeline.frameList[j];
                              if (slotFrame && slotFrame.displayIndex < 0) {
                                  displayIndexChange = true;
                                  break;
                              }
                          }
                      }
                  }
                  var animationTween = animationData.tweenEasing;
                  if (displayIndexChange) {
                      len = animationData.slotTimelineList.length;
                      for (i = 0; i < len; i++) {
                          slotTimeline = animationData.slotTimelineList[i];
                          timeline = animationData.timelineList[i];
                          var curFrame;
                          var curSlotFrame;
                          var nextSlotFrame;
                          for (j = 0, jlen = slotTimeline.frameList.length; j < jlen; j++) {
                              curSlotFrame = slotTimeline.frameList[j];
                              curFrame = timeline.frameList[j];
                              nextSlotFrame = (j == jlen - 1) ? slotTimeline.frameList[0] : slotTimeline.frameList[j + 1];
                              if (curSlotFrame.displayIndex < 0 || nextSlotFrame.displayIndex < 0) {
                                  curFrame.tweenEasing = curSlotFrame.tweenEasing = NaN;
                              }
                              else if (animationTween == 10) {
                                  curFrame.tweenEasing = curSlotFrame.tweenEasing = 0;
                              }
                              else if (!isNaN(animationTween)) {
                                  curFrame.tweenEasing = curSlotFrame.tweenEasing = animationTween;
                              }
                              else if (curFrame.tweenEasing == 10) {
                                  curFrame.tweenEasing = 0;
                              }
                          }
                      }
                      animationData.autoTween = false;
                  }
              }
              if (animationData.frameList.length > 0) {
                  lastFrameDuration = Math.min(lastFrameDuration, animationData.frameList[animationData.frameList.length - 1].duration);
              }
              animationData.lastFrameDuration = lastFrameDuration;
              return animationData;
          };
          Data3Parser.parseSlotTimeline = function (timelineObject, duration, frameRate) {
              var outputTimeline = new dragonBones.SlotTimeline();
              outputTimeline.name = timelineObject[dragonBones.ConstValues.A_NAME];
              outputTimeline.scale = Data3Parser.getNumber(timelineObject, dragonBones.ConstValues.A_SCALE, 1) || 0;
              outputTimeline.offset = Data3Parser.getNumber(timelineObject, dragonBones.ConstValues.A_OFFSET, 0) || 0;
              outputTimeline.duration = duration;
              var frameList = timelineObject[dragonBones.ConstValues.FRAME];
              for (var i = 0, len = frameList.length; i < len; i++) {
                  var frameObject = frameList[i];
                  var frame = Data3Parser.parseSlotFrame(frameObject, frameRate);
                  outputTimeline.addFrame(frame);
              }
              Data3Parser.parseTimeline(timelineObject, outputTimeline);
              return outputTimeline;
          };
          Data3Parser.parseSlotFrame = function (frameObject, frameRate) {
              var outputFrame = new dragonBones.SlotFrame();
              Data3Parser.parseFrame(frameObject, outputFrame, frameRate);
              outputFrame.visible = !Data3Parser.getBoolean(frameObject, dragonBones.ConstValues.A_HIDE, false);
              outputFrame.tweenEasing = Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_TWEEN_EASING, 10);
              outputFrame.displayIndex = Math.floor(Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_DISPLAY_INDEX, 0) || 0);
              outputFrame.zOrder = Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_Z_ORDER, Data3Parser.tempDragonBonesData.isGlobal ? NaN : 0);
              var colorTransformObject = frameObject[dragonBones.ConstValues.COLOR_TRANSFORM];
              if (colorTransformObject) {
                  outputFrame.color = new dragonBones.ColorTransform();
                  Data3Parser.parseColorTransform(colorTransformObject, outputFrame.color);
              }
              return outputFrame;
          };
          Data3Parser.parseTransformTimeline = function (timelineObject, duration, frameRate) {
              var outputTimeline = new dragonBones.TransformTimeline();
              outputTimeline.name = timelineObject[dragonBones.ConstValues.A_NAME];
              outputTimeline.scale = Data3Parser.getNumber(timelineObject, dragonBones.ConstValues.A_SCALE, 1) || 0;
              outputTimeline.offset = Data3Parser.getNumber(timelineObject, dragonBones.ConstValues.A_OFFSET, 0) || 0;
              outputTimeline.originPivot.x = Data3Parser.getNumber(timelineObject, dragonBones.ConstValues.A_PIVOT_X, 0) || 0;
              outputTimeline.originPivot.y = Data3Parser.getNumber(timelineObject, dragonBones.ConstValues.A_PIVOT_Y, 0) || 0;
              outputTimeline.duration = duration;
              var frameList = timelineObject[dragonBones.ConstValues.FRAME];
              var nextFrameObject;
              for (var i = 0, len = frameList.length; i < len; i++) {
                  var frameObject = frameList[i];
                  if (i < len - 1) {
                      nextFrameObject = frameList[i + 1];
                  }
                  else if (i != 0) {
                      nextFrameObject = frameList[0];
                  }
                  else {
                      nextFrameObject = null;
                  }
                  var frame = Data3Parser.parseTransformFrame(frameObject, nextFrameObject, frameRate);
                  outputTimeline.addFrame(frame);
              }
              Data3Parser.parseTimeline(timelineObject, outputTimeline);
              return outputTimeline;
          };
          Data3Parser.parseTransformFrame = function (frameObject, nextFrameObject, frameRate) {
              var outputFrame = new dragonBones.TransformFrame();
              Data3Parser.parseFrame(frameObject, outputFrame, frameRate);
              outputFrame.visible = !Data3Parser.getBoolean(frameObject, dragonBones.ConstValues.A_HIDE, false);
              outputFrame.tweenEasing = Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_TWEEN_EASING, 10);
              outputFrame.tweenRotate = Math.floor(Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_TWEEN_ROTATE, 0) || 0);
              outputFrame.tweenScale = Data3Parser.getBoolean(frameObject, dragonBones.ConstValues.A_TWEEN_SCALE, true);
              if (nextFrameObject && Math.floor(Data3Parser.getNumber(nextFrameObject, dragonBones.ConstValues.A_DISPLAY_INDEX, 0) || 0) == -1) {
                  outputFrame.tweenEasing = NaN;
              }
              Data3Parser.parseTransform(frameObject[dragonBones.ConstValues.TRANSFORM], outputFrame.transform, outputFrame.pivot);
              if (Data3Parser.tempDragonBonesData.isGlobal) {
                  outputFrame.global.copy(outputFrame.transform);
              }
              outputFrame.scaleOffset.x = Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_SCALE_X_OFFSET, 0) || 0;
              outputFrame.scaleOffset.y = Data3Parser.getNumber(frameObject, dragonBones.ConstValues.A_SCALE_Y_OFFSET, 0) || 0;
              return outputFrame;
          };
          Data3Parser.parseTimeline = function (timelineObject, outputTimeline) {
              var position = 0;
              var frame;
              var frameList = outputTimeline.frameList;
              for (var i = 0, len = frameList.length; i < len; i++) {
                  frame = frameList[i];
                  frame.position = position;
                  position += frame.duration;
              }
              if (frame) {
                  frame.duration = outputTimeline.duration - frame.position;
              }
          };
          Data3Parser.parseFrame = function (frameObject, outputFrame, frameRate) {
              if (frameRate === void 0) { frameRate = 0; }
              outputFrame.duration = Math.round(((frameObject[dragonBones.ConstValues.A_DURATION]) || 1) * 1000 / frameRate);
              outputFrame.action = frameObject[dragonBones.ConstValues.A_ACTION];
              outputFrame.event = frameObject[dragonBones.ConstValues.A_EVENT];
              outputFrame.sound = frameObject[dragonBones.ConstValues.A_SOUND];
          };
          Data3Parser.parseTransform = function (transformObject, transform, pivot) {
              if (pivot === void 0) { pivot = null; }
              if (transformObject) {
                  if (transform) {
                      transform.x = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_X, 0) || 0;
                      transform.y = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_Y, 0) || 0;
                      transform.skewX = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_SKEW_X, 0) * dragonBones.ConstValues.ANGLE_TO_RADIAN || 0;
                      transform.skewY = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_SKEW_Y, 0) * dragonBones.ConstValues.ANGLE_TO_RADIAN || 0;
                      transform.scaleX = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_SCALE_X, 1) || 0;
                      transform.scaleY = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_SCALE_Y, 1) || 0;
                  }
                  if (pivot) {
                      pivot.x = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_PIVOT_X, 0) || 0;
                      pivot.y = Data3Parser.getNumber(transformObject, dragonBones.ConstValues.A_PIVOT_Y, 0) || 0;
                  }
              }
          };
          Data3Parser.parseColorTransform = function (colorTransformObject, colorTransform) {
              if (colorTransformObject) {
                  if (colorTransform) {
                      colorTransform.alphaOffset = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_ALPHA_OFFSET, 0);
                      colorTransform.redOffset = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_RED_OFFSET, 0);
                      colorTransform.greenOffset = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_GREEN_OFFSET, 0);
                      colorTransform.blueOffset = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_BLUE_OFFSET, 0);
                      colorTransform.alphaMultiplier = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_ALPHA_MULTIPLIER, 100) * 0.01;
                      colorTransform.redMultiplier = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_RED_MULTIPLIER, 100) * 0.01;
                      colorTransform.greenMultiplier = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_GREEN_MULTIPLIER, 100) * 0.01;
                      colorTransform.blueMultiplier = Data3Parser.getNumber(colorTransformObject, dragonBones.ConstValues.A_BLUE_MULTIPLIER, 100) * 0.01;
                  }
              }
          };
          Data3Parser.getBoolean = function (data, key, defaultValue) {
              if (data && key in data) {
                  switch (String(data[key])) {
                      case "0":
                      case "NaN":
                      case "":
                      case "false":
                      case "null":
                      case "undefined":
                          return false;
                      case "1":
                      case "true":
                      default:
                          return true;
                  }
              }
              return defaultValue;
          };
          Data3Parser.getNumber = function (data, key, defaultValue) {
              if (data && key in data) {
                  switch (String(data[key])) {
                      case "NaN":
                      case "":
                      case "false":
                      case "null":
                      case "undefined":
                          return NaN;
                      default:
                          return Number(data[key]);
                  }
              }
              return defaultValue;
          };
          return Data3Parser;
      })();
      dragonBones.Data3Parser = Data3Parser;
      egret.registerClass(Data3Parser,'dragonBones.Data3Parser');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var DataParser = (function () {
          function DataParser() {
          }
          var d = __define,c=DataParser,p=c.prototype;
          DataParser.parseTextureAtlasData = function (rawData, scale) {
              if (scale === void 0) { scale = 1; }
              var textureAtlasData = {};
              var subTextureFrame;
              var subTextureList = rawData[dragonBones.ConstValues.SUB_TEXTURE];
              for (var i = 0, len = subTextureList.length; i < len; i++) {
                  var subTextureObject = subTextureList[i];
                  var subTextureName = subTextureObject[dragonBones.ConstValues.A_NAME];
                  var subTextureRegion = new dragonBones.Rectangle();
                  subTextureRegion.x = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_X, 0) / scale;
                  subTextureRegion.y = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_Y, 0) / scale;
                  subTextureRegion.width = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_WIDTH, 0) / scale;
                  subTextureRegion.height = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_HEIGHT, 0) / scale;
                  var rotated = subTextureObject[dragonBones.ConstValues.A_ROTATED] == "true";
                  var frameWidth = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_FRAME_WIDTH, 0) / scale;
                  var frameHeight = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_FRAME_HEIGHT, 0) / scale;
                  if (frameWidth > 0 && frameHeight > 0) {
                      subTextureFrame = new dragonBones.Rectangle();
                      subTextureFrame.x = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_FRAME_X, 0) / scale;
                      subTextureFrame.y = DataParser.getNumber(subTextureObject, dragonBones.ConstValues.A_FRAME_Y, 0) / scale;
                      subTextureFrame.width = frameWidth;
                      subTextureFrame.height = frameHeight;
                  }
                  else {
                      subTextureFrame = null;
                  }
                  textureAtlasData[subTextureName] = new dragonBones.TextureData(subTextureRegion, subTextureFrame, rotated);
              }
              return textureAtlasData;
          };
          DataParser.parseDragonBonesData = function (rawDataToParse) {
              if (!rawDataToParse) {
                  throw new Error();
              }
              var version = rawDataToParse[dragonBones.ConstValues.A_VERSION];
              version = version.toString();
              if (version.toString() == dragonBones.DragonBones.PARENT_COORDINATE_DATA_VERSION ||
                  version.toString() == "2.3") {
                  return dragonBones.Data3Parser.parseDragonBonesData(rawDataToParse);
              }
              var frameRate = DataParser.getNumber(rawDataToParse, dragonBones.ConstValues.A_FRAME_RATE, 0) || 0;
              var outputDragonBonesData = new dragonBones.DragonBonesData();
              outputDragonBonesData.name = rawDataToParse[dragonBones.ConstValues.A_NAME];
              outputDragonBonesData.isGlobal = rawDataToParse[dragonBones.ConstValues.A_IS_GLOBAL] == "0" ? false : true;
              DataParser.tempDragonBonesData = outputDragonBonesData;
              var armatureList = rawDataToParse[dragonBones.ConstValues.ARMATURE];
              for (var i = 0, len = armatureList.length; i < len; i++) {
                  var armatureObject = armatureList[i];
                  outputDragonBonesData.addArmatureData(DataParser.parseArmatureData(armatureObject, frameRate));
              }
              DataParser.tempDragonBonesData = null;
              return outputDragonBonesData;
          };
          DataParser.parseArmatureData = function (armatureDataToParse, frameRate) {
              var outputArmatureData = new dragonBones.ArmatureData();
              outputArmatureData.name = armatureDataToParse[dragonBones.ConstValues.A_NAME];
              var boneList = armatureDataToParse[dragonBones.ConstValues.BONE];
              var i;
              var len;
              for (i = 0, len = boneList.length; i < len; i++) {
                  var boneObject = boneList[i];
                  outputArmatureData.addBoneData(DataParser.parseBoneData(boneObject));
              }
              var slotList = armatureDataToParse[dragonBones.ConstValues.SLOT];
              for (i = 0, len = slotList.length; i < len; i++) {
                  var slotObject = slotList[i];
                  outputArmatureData.addSlotData(DataParser.parseSlotData(slotObject));
              }
              var skinList = armatureDataToParse[dragonBones.ConstValues.SKIN];
              for (i = 0, len = skinList.length; i < len; i++) {
                  var skinObject = skinList[i];
                  outputArmatureData.addSkinData(DataParser.parseSkinData(skinObject));
              }
              if (DataParser.tempDragonBonesData.isGlobal) {
                  dragonBones.DBDataUtil.transformArmatureData(outputArmatureData);
              }
              outputArmatureData.sortBoneDataList();
              var animationList = armatureDataToParse[dragonBones.ConstValues.ANIMATION];
              for (i = 0, len = animationList.length; i < len; i++) {
                  var animationObject = animationList[i];
                  var animationData = DataParser.parseAnimationData(animationObject, frameRate);
                  dragonBones.DBDataUtil.addHideTimeline(animationData, outputArmatureData, true);
                  dragonBones.DBDataUtil.transformAnimationData(animationData, outputArmatureData, DataParser.tempDragonBonesData.isGlobal);
                  outputArmatureData.addAnimationData(animationData);
              }
              return outputArmatureData;
          };
          DataParser.parseBoneData = function (boneObject) {
              var boneData = new dragonBones.BoneData();
              boneData.name = boneObject[dragonBones.ConstValues.A_NAME];
              boneData.parent = boneObject[dragonBones.ConstValues.A_PARENT];
              boneData.length = Number(boneObject[dragonBones.ConstValues.A_LENGTH]) || 0;
              boneData.inheritRotation = DataParser.getBoolean(boneObject, dragonBones.ConstValues.A_INHERIT_ROTATION, true);
              boneData.inheritScale = DataParser.getBoolean(boneObject, dragonBones.ConstValues.A_INHERIT_SCALE, true);
              DataParser.parseTransform(boneObject[dragonBones.ConstValues.TRANSFORM], boneData.transform);
              if (DataParser.tempDragonBonesData.isGlobal) {
                  boneData.global.copy(boneData.transform);
              }
              return boneData;
          };
          DataParser.parseSkinData = function (skinObject) {
              var skinData = new dragonBones.SkinData();
              skinData.name = skinObject[dragonBones.ConstValues.A_NAME];
              var slotList = skinObject[dragonBones.ConstValues.SLOT];
              for (var i = 0, len = slotList.length; i < len; i++) {
                  var slotObject = slotList[i];
                  skinData.addSlotData(DataParser.parseSlotDisplayData(slotObject));
              }
              return skinData;
          };
          DataParser.parseSlotData = function (slotObject) {
              var slotData = new dragonBones.SlotData();
              slotData.name = slotObject[dragonBones.ConstValues.A_NAME];
              slotData.parent = slotObject[dragonBones.ConstValues.A_PARENT];
              slotData.zOrder = DataParser.getNumber(slotObject, dragonBones.ConstValues.A_Z_ORDER, 0) || 0;
              slotData.displayIndex = DataParser.getNumber(slotObject, dragonBones.ConstValues.A_DISPLAY_INDEX, 0);
              slotData.blendMode = slotObject[dragonBones.ConstValues.A_BLENDMODE];
              return slotData;
          };
          DataParser.parseSlotDisplayData = function (slotObject) {
              var slotData = new dragonBones.SlotData();
              slotData.name = slotObject[dragonBones.ConstValues.A_NAME];
              slotData.parent = slotObject[dragonBones.ConstValues.A_PARENT];
              slotData.zOrder = DataParser.getNumber(slotObject, dragonBones.ConstValues.A_Z_ORDER, 0) || 0;
              var displayList = slotObject[dragonBones.ConstValues.DISPLAY];
              if (displayList) {
                  for (var i = 0, len = displayList.length; i < len; i++) {
                      var displayObject = displayList[i];
                      slotData.addDisplayData(DataParser.parseDisplayData(displayObject));
                  }
              }
              return slotData;
          };
          DataParser.parseDisplayData = function (displayObject) {
              var displayData = new dragonBones.DisplayData();
              displayData.name = displayObject[dragonBones.ConstValues.A_NAME];
              displayData.type = displayObject[dragonBones.ConstValues.A_TYPE];
              DataParser.parseTransform(displayObject[dragonBones.ConstValues.TRANSFORM], displayData.transform, displayData.pivot);
              displayData.pivot.x = NaN;
              displayData.pivot.y = NaN;
              if (DataParser.tempDragonBonesData != null) {
                  DataParser.tempDragonBonesData.addDisplayData(displayData);
              }
              return displayData;
          };
          DataParser.parseAnimationData = function (animationObject, frameRate) {
              var animationData = new dragonBones.AnimationData();
              animationData.name = animationObject[dragonBones.ConstValues.A_NAME];
              animationData.frameRate = frameRate;
              animationData.duration = Math.ceil((DataParser.getNumber(animationObject, dragonBones.ConstValues.A_DURATION, 1) || 1) * 1000 / frameRate);
              animationData.playTimes = DataParser.getNumber(animationObject, dragonBones.ConstValues.A_PLAY_TIMES, 1);
              animationData.playTimes = animationData.playTimes != NaN ? animationData.playTimes : 1;
              animationData.fadeTime = DataParser.getNumber(animationObject, dragonBones.ConstValues.A_FADE_IN_TIME, 0) || 0;
              animationData.scale = DataParser.getNumber(animationObject, dragonBones.ConstValues.A_SCALE, 1) || 0;
              animationData.tweenEasing = DataParser.getNumber(animationObject, dragonBones.ConstValues.A_TWEEN_EASING, NaN);
              animationData.autoTween = DataParser.getBoolean(animationObject, dragonBones.ConstValues.A_AUTO_TWEEN, true);
              var frameObjectList = animationObject[dragonBones.ConstValues.FRAME];
              var i = 0;
              var len = 0;
              if (frameObjectList) {
                  for (i = 0, len = frameObjectList.length; i < len; i++) {
                      var frameObject = frameObjectList[i];
                      var frame = DataParser.parseTransformFrame(frameObject, frameRate);
                      animationData.addFrame(frame);
                  }
              }
              DataParser.parseTimeline(animationObject, animationData);
              var lastFrameDuration = animationData.duration;
              var timelineObjectList = animationObject[dragonBones.ConstValues.BONE];
              if (timelineObjectList) {
                  for (i = 0, len = timelineObjectList.length; i < len; i++) {
                      var timelineObject = timelineObjectList[i];
                      if (timelineObject) {
                          var timeline = DataParser.parseTransformTimeline(timelineObject, animationData.duration, frameRate);
                          if (timeline.frameList.length > 0) {
                              lastFrameDuration = Math.min(lastFrameDuration, timeline.frameList[timeline.frameList.length - 1].duration);
                          }
                          animationData.addTimeline(timeline);
                      }
                  }
              }
              var slotTimelineObjectList = animationObject[dragonBones.ConstValues.SLOT];
              if (slotTimelineObjectList) {
                  for (i = 0, len = slotTimelineObjectList.length; i < len; i++) {
                      var slotTimelineObject = slotTimelineObjectList[i];
                      if (slotTimelineObject) {
                          var slotTimeline = DataParser.parseSlotTimeline(slotTimelineObject, animationData.duration, frameRate);
                          if (slotTimeline.frameList.length > 0) {
                              lastFrameDuration = Math.min(lastFrameDuration, slotTimeline.frameList[slotTimeline.frameList.length - 1].duration);
                              animationData.addSlotTimeline(slotTimeline);
                          }
                      }
                  }
              }
              if (animationData.frameList.length > 0) {
                  lastFrameDuration = Math.min(lastFrameDuration, animationData.frameList[animationData.frameList.length - 1].duration);
              }
              animationData.lastFrameDuration = lastFrameDuration;
              return animationData;
          };
          DataParser.parseTransformTimeline = function (timelineObject, duration, frameRate) {
              var outputTimeline = new dragonBones.TransformTimeline();
              outputTimeline.name = timelineObject[dragonBones.ConstValues.A_NAME];
              outputTimeline.scale = DataParser.getNumber(timelineObject, dragonBones.ConstValues.A_SCALE, 1) || 0;
              outputTimeline.offset = DataParser.getNumber(timelineObject, dragonBones.ConstValues.A_OFFSET, 0) || 0;
              outputTimeline.originPivot.x = DataParser.getNumber(timelineObject, dragonBones.ConstValues.A_PIVOT_X, 0) || 0;
              outputTimeline.originPivot.y = DataParser.getNumber(timelineObject, dragonBones.ConstValues.A_PIVOT_Y, 0) || 0;
              outputTimeline.duration = duration;
              var frameList = timelineObject[dragonBones.ConstValues.FRAME];
              for (var i = 0, len = frameList.length; i < len; i++) {
                  var frameObject = frameList[i];
                  var frame = DataParser.parseTransformFrame(frameObject, frameRate);
                  outputTimeline.addFrame(frame);
              }
              DataParser.parseTimeline(timelineObject, outputTimeline);
              return outputTimeline;
          };
          DataParser.parseSlotTimeline = function (timelineObject, duration, frameRate) {
              var outputTimeline = new dragonBones.SlotTimeline();
              outputTimeline.name = timelineObject[dragonBones.ConstValues.A_NAME];
              outputTimeline.scale = DataParser.getNumber(timelineObject, dragonBones.ConstValues.A_SCALE, 1) || 0;
              outputTimeline.offset = DataParser.getNumber(timelineObject, dragonBones.ConstValues.A_OFFSET, 0) || 0;
              outputTimeline.duration = duration;
              var frameList = timelineObject[dragonBones.ConstValues.FRAME];
              for (var i = 0, len = frameList.length; i < len; i++) {
                  var frameObject = frameList[i];
                  var frame = DataParser.parseSlotFrame(frameObject, frameRate);
                  outputTimeline.addFrame(frame);
              }
              DataParser.parseTimeline(timelineObject, outputTimeline);
              return outputTimeline;
          };
          DataParser.parseTransformFrame = function (frameObject, frameRate) {
              var outputFrame = new dragonBones.TransformFrame();
              DataParser.parseFrame(frameObject, outputFrame, frameRate);
              outputFrame.visible = !DataParser.getBoolean(frameObject, dragonBones.ConstValues.A_HIDE, false);
              outputFrame.tweenEasing = DataParser.getNumber(frameObject, dragonBones.ConstValues.A_TWEEN_EASING, 10);
              outputFrame.tweenRotate = Math.floor(DataParser.getNumber(frameObject, dragonBones.ConstValues.A_TWEEN_ROTATE, 0) || 0);
              outputFrame.tweenScale = DataParser.getBoolean(frameObject, dragonBones.ConstValues.A_TWEEN_SCALE, true);
              outputFrame.displayIndex = Math.floor(DataParser.getNumber(frameObject, dragonBones.ConstValues.A_DISPLAY_INDEX, 0) || 0);
              DataParser.parseTransform(frameObject[dragonBones.ConstValues.TRANSFORM], outputFrame.transform, outputFrame.pivot);
              if (DataParser.tempDragonBonesData.isGlobal) {
                  outputFrame.global.copy(outputFrame.transform);
              }
              outputFrame.scaleOffset.x = DataParser.getNumber(frameObject, dragonBones.ConstValues.A_SCALE_X_OFFSET, 0) || 0;
              outputFrame.scaleOffset.y = DataParser.getNumber(frameObject, dragonBones.ConstValues.A_SCALE_Y_OFFSET, 0) || 0;
              return outputFrame;
          };
          DataParser.parseSlotFrame = function (frameObject, frameRate) {
              var outputFrame = new dragonBones.SlotFrame();
              DataParser.parseFrame(frameObject, outputFrame, frameRate);
              outputFrame.visible = !DataParser.getBoolean(frameObject, dragonBones.ConstValues.A_HIDE, false);
              outputFrame.tweenEasing = DataParser.getNumber(frameObject, dragonBones.ConstValues.A_TWEEN_EASING, 10);
              outputFrame.displayIndex = Math.floor(DataParser.getNumber(frameObject, dragonBones.ConstValues.A_DISPLAY_INDEX, 0) || 0);
              outputFrame.zOrder = DataParser.getNumber(frameObject, dragonBones.ConstValues.A_Z_ORDER, DataParser.tempDragonBonesData.isGlobal ? NaN : 0);
              var colorTransformObject = frameObject[dragonBones.ConstValues.COLOR];
              if (colorTransformObject) {
                  outputFrame.color = new dragonBones.ColorTransform();
                  DataParser.parseColorTransform(colorTransformObject, outputFrame.color);
              }
              return outputFrame;
          };
          DataParser.parseTimeline = function (timelineObject, outputTimeline) {
              var position = 0;
              var frame;
              var frameList = outputTimeline.frameList;
              for (var i = 0, len = frameList.length; i < len; i++) {
                  frame = frameList[i];
                  frame.position = position;
                  position += frame.duration;
              }
              if (frame) {
                  frame.duration = outputTimeline.duration - frame.position;
              }
          };
          DataParser.parseFrame = function (frameObject, outputFrame, frameRate) {
              if (frameRate === void 0) { frameRate = 0; }
              outputFrame.duration = Math.round(((frameObject[dragonBones.ConstValues.A_DURATION]) || 1) * 1000 / frameRate);
              outputFrame.action = frameObject[dragonBones.ConstValues.A_ACTION];
              outputFrame.event = frameObject[dragonBones.ConstValues.A_EVENT];
              outputFrame.sound = frameObject[dragonBones.ConstValues.A_SOUND];
              var curve = frameObject[dragonBones.ConstValues.A_CURVE];
              if (curve != null && curve.length == 4) {
                  outputFrame.curve = new dragonBones.CurveData();
                  outputFrame.curve.pointList = [new dragonBones.Point(curve[0], curve[1]),
                      new dragonBones.Point(curve[2], curve[3])];
              }
          };
          DataParser.parseTransform = function (transformObject, transform, pivot) {
              if (pivot === void 0) { pivot = null; }
              if (transformObject) {
                  if (transform) {
                      transform.x = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_X, 0) || 0;
                      transform.y = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_Y, 0) || 0;
                      transform.skewX = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_SKEW_X, 0) * dragonBones.ConstValues.ANGLE_TO_RADIAN || 0;
                      transform.skewY = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_SKEW_Y, 0) * dragonBones.ConstValues.ANGLE_TO_RADIAN || 0;
                      transform.scaleX = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_SCALE_X, 1) || 0;
                      transform.scaleY = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_SCALE_Y, 1) || 0;
                  }
                  if (pivot) {
                      pivot.x = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_PIVOT_X, 0) || 0;
                      pivot.y = DataParser.getNumber(transformObject, dragonBones.ConstValues.A_PIVOT_Y, 0) || 0;
                  }
              }
          };
          DataParser.parseColorTransform = function (colorTransformObject, colorTransform) {
              if (colorTransform) {
                  colorTransform.alphaOffset = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_ALPHA_OFFSET, 0);
                  colorTransform.redOffset = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_RED_OFFSET, 0);
                  colorTransform.greenOffset = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_GREEN_OFFSET, 0);
                  colorTransform.blueOffset = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_BLUE_OFFSET, 0);
                  colorTransform.alphaMultiplier = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_ALPHA_MULTIPLIER, 100) * 0.01;
                  colorTransform.redMultiplier = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_RED_MULTIPLIER, 100) * 0.01;
                  colorTransform.greenMultiplier = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_GREEN_MULTIPLIER, 100) * 0.01;
                  colorTransform.blueMultiplier = DataParser.getNumber(colorTransformObject, dragonBones.ConstValues.A_BLUE_MULTIPLIER, 100) * 0.01;
              }
          };
          DataParser.getBoolean = function (data, key, defaultValue) {
              if (data && key in data) {
                  switch (String(data[key])) {
                      case "0":
                      case "NaN":
                      case "":
                      case "false":
                      case "null":
                      case "undefined":
                          return false;
                      case "1":
                      case "true":
                      default:
                          return true;
                  }
              }
              return defaultValue;
          };
          DataParser.getNumber = function (data, key, defaultValue) {
              if (data && key in data) {
                  switch (String(data[key])) {
                      case "NaN":
                      case "":
                      case "false":
                      case "null":
                      case "undefined":
                          return NaN;
                      default:
                          return Number(data[key]);
                  }
              }
              return defaultValue;
          };
          return DataParser;
      })();
      dragonBones.DataParser = DataParser;
      egret.registerClass(DataParser,'dragonBones.DataParser');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Timeline = (function () {
          function Timeline() {
              this.duration = 0;
              this._frameList = [];
              this.duration = 0;
              this.scale = 1;
          }
          var d = __define,c=Timeline,p=c.prototype;
          p.dispose = function () {
              var i = this._frameList.length;
              while (i--) {
                  this._frameList[i].dispose();
              }
              this._frameList = null;
          };
          p.addFrame = function (frame) {
              if (!frame) {
                  throw new Error();
              }
              if (this._frameList.indexOf(frame) < 0) {
                  this._frameList[this._frameList.length] = frame;
              }
              else {
                  throw new Error();
              }
          };
          d(p, "frameList"
              ,function () {
                  return this._frameList;
              }
          );
          return Timeline;
      })();
      dragonBones.Timeline = Timeline;
      egret.registerClass(Timeline,'dragonBones.Timeline');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var AnimationData = (function (_super) {
          __extends(AnimationData, _super);
          function AnimationData() {
              _super.call(this);
              this.frameRate = 0;
              this.playTimes = 0;
              this.lastFrameDuration = 0;
              this.fadeTime = 0;
              this.playTimes = 0;
              this.autoTween = true;
              this.tweenEasing = NaN;
              this.hideTimelineNameMap = [];
              this.hideSlotTimelineNameMap = [];
              this._timelineList = [];
              this._slotTimelineList = [];
          }
          var d = __define,c=AnimationData,p=c.prototype;
          d(p, "timelineList"
              ,function () {
                  return this._timelineList;
              }
          );
          d(p, "slotTimelineList"
              ,function () {
                  return this._slotTimelineList;
              }
          );
          p.dispose = function () {
              _super.prototype.dispose.call(this);
              this.hideTimelineNameMap = null;
              var i = 0;
              var len = 0;
              for (i = 0, len = this._timelineList.length; i < len; i++) {
                  var timeline = this._timelineList[i];
                  timeline.dispose();
              }
              this._timelineList = null;
              for (i = 0, len = this._slotTimelineList.length; i < len; i++) {
                  var slotTimeline = this._slotTimelineList[i];
                  slotTimeline.dispose();
              }
              this._slotTimelineList = null;
          };
          p.getTimeline = function (timelineName) {
              var i = this._timelineList.length;
              while (i--) {
                  if (this._timelineList[i].name == timelineName) {
                      return this._timelineList[i];
                  }
              }
              return null;
          };
          p.addTimeline = function (timeline) {
              if (!timeline) {
                  throw new Error();
              }
              if (this._timelineList.indexOf(timeline) < 0) {
                  this._timelineList[this._timelineList.length] = timeline;
              }
          };
          p.getSlotTimeline = function (timelineName) {
              var i = this._slotTimelineList.length;
              while (i--) {
                  if (this._slotTimelineList[i].name == timelineName) {
                      return this._slotTimelineList[i];
                  }
              }
              return null;
          };
          p.addSlotTimeline = function (timeline) {
              if (!timeline) {
                  throw new Error();
              }
              if (this._slotTimelineList.indexOf(timeline) < 0) {
                  this._slotTimelineList[this._slotTimelineList.length] = timeline;
              }
          };
          return AnimationData;
      })(dragonBones.Timeline);
      dragonBones.AnimationData = AnimationData;
      egret.registerClass(AnimationData,'dragonBones.AnimationData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var ArmatureData = (function () {
          function ArmatureData() {
              this._boneDataList = [];
              this._skinDataList = [];
              this._slotDataList = [];
              this._animationDataList = [];
          }
          var d = __define,c=ArmatureData,p=c.prototype;
          ArmatureData.sortBoneDataHelpArray = function (object1, object2) {
              return object1[0] > object2[0] ? 1 : -1;
          };
          ArmatureData.sortBoneDataHelpArrayDescending = function (object1, object2) {
              return object1[0] > object2[0] ? -1 : 1;
          };
          p.setSkinData = function (skinName) {
              var i = 0;
              var len = this._slotDataList.length;
              for (i = 0; i < len; i++) {
                  this._slotDataList[i].dispose();
              }
              var skinData;
              if (!skinName && this._skinDataList.length > 0) {
                  skinData = this._skinDataList[0];
              }
              else {
                  i = 0,
                      len = this._skinDataList.length;
                  for (; i < len; i++) {
                      if (this._skinDataList[i].name == skinName) {
                          skinData = this._skinDataList[i];
                          break;
                      }
                  }
              }
              if (skinData) {
                  var slotData;
                  i = 0, len = skinData.slotDataList.length;
                  for (i = 0; i < len; i++) {
                      slotData = this.getSlotData(skinData.slotDataList[i].name);
                      if (slotData) {
                          var j = 0;
                          var jLen = skinData.slotDataList[i].displayDataList.length;
                          for (j = 0; j < jLen; j++) {
                              slotData.addDisplayData(skinData.slotDataList[i].displayDataList[j]);
                          }
                      }
                  }
              }
          };
          p.dispose = function () {
              var i = this._boneDataList.length;
              while (i--) {
                  this._boneDataList[i].dispose();
              }
              i = this._skinDataList.length;
              while (i--) {
                  this._skinDataList[i].dispose();
              }
              i = this._slotDataList.length;
              while (i--) {
                  this._slotDataList[i].dispose();
              }
              i = this._animationDataList.length;
              while (i--) {
                  this._animationDataList[i].dispose();
              }
              this._boneDataList = null;
              this._slotDataList = null;
              this._skinDataList = null;
              this._animationDataList = null;
          };
          p.getBoneData = function (boneName) {
              var i = this._boneDataList.length;
              while (i--) {
                  if (this._boneDataList[i].name == boneName) {
                      return this._boneDataList[i];
                  }
              }
              return null;
          };
          p.getSlotData = function (slotName) {
              var i = this._slotDataList.length;
              while (i--) {
                  if (this._slotDataList[i].name == slotName) {
                      return this._slotDataList[i];
                  }
              }
              return null;
          };
          p.getSkinData = function (skinName) {
              if (!skinName && this._skinDataList.length > 0) {
                  return this._skinDataList[0];
              }
              var i = this._skinDataList.length;
              while (i--) {
                  if (this._skinDataList[i].name == skinName) {
                      return this._skinDataList[i];
                  }
              }
              return null;
          };
          p.getAnimationData = function (animationName) {
              var i = this._animationDataList.length;
              while (i--) {
                  if (this._animationDataList[i].name == animationName) {
                      return this._animationDataList[i];
                  }
              }
              return null;
          };
          p.addBoneData = function (boneData) {
              if (!boneData) {
                  throw new Error();
              }
              if (this._boneDataList.indexOf(boneData) < 0) {
                  this._boneDataList[this._boneDataList.length] = boneData;
              }
              else {
                  throw new Error();
              }
          };
          p.addSlotData = function (slotData) {
              if (!slotData) {
                  throw new Error();
              }
              if (this._slotDataList.indexOf(slotData) < 0) {
                  this._slotDataList[this._slotDataList.length] = slotData;
              }
              else {
                  throw new Error();
              }
          };
          p.addSkinData = function (skinData) {
              if (!skinData) {
                  throw new Error();
              }
              if (this._skinDataList.indexOf(skinData) < 0) {
                  this._skinDataList[this._skinDataList.length] = skinData;
              }
              else {
                  throw new Error();
              }
          };
          p.addAnimationData = function (animationData) {
              if (!animationData) {
                  throw new Error();
              }
              if (this._animationDataList.indexOf(animationData) < 0) {
                  this._animationDataList[this._animationDataList.length] = animationData;
              }
          };
          p.sortBoneDataList = function () {
              var i = this._boneDataList.length;
              if (i == 0) {
                  return;
              }
              var helpArray = [];
              while (i--) {
                  var boneData = this._boneDataList[i];
                  var level = 0;
                  var parentData = boneData;
                  while (parentData) {
                      level++;
                      parentData = this.getBoneData(parentData.parent);
                  }
                  helpArray[i] = [level, boneData];
              }
              helpArray.sort(ArmatureData.sortBoneDataHelpArray);
              i = helpArray.length;
              while (i--) {
                  this._boneDataList[i] = helpArray[i][1];
              }
          };
          d(p, "boneDataList"
              ,function () {
                  return this._boneDataList;
              }
          );
          d(p, "slotDataList"
              ,function () {
                  return this._slotDataList;
              }
          );
          d(p, "skinDataList"
              ,function () {
                  return this._skinDataList;
              }
          );
          d(p, "animationDataList"
              ,function () {
                  return this._animationDataList;
              }
          );
          return ArmatureData;
      })();
      dragonBones.ArmatureData = ArmatureData;
      egret.registerClass(ArmatureData,'dragonBones.ArmatureData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var BoneData = (function () {
          function BoneData() {
              this.length = 0;
              this.global = new dragonBones.DBTransform();
              this.transform = new dragonBones.DBTransform();
              this.inheritRotation = true;
              this.inheritScale = false;
          }
          var d = __define,c=BoneData,p=c.prototype;
          p.dispose = function () {
              this.global = null;
              this.transform = null;
          };
          return BoneData;
      })();
      dragonBones.BoneData = BoneData;
      egret.registerClass(BoneData,'dragonBones.BoneData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var ColorTransform = (function () {
          function ColorTransform() {
              this.alphaMultiplier = 1;
              this.alphaOffset = 0;
              this.blueMultiplier = 1;
              this.blueOffset = 0;
              this.greenMultiplier = 1;
              this.greenOffset = 0;
              this.redMultiplier = 1;
              this.redOffset = 0;
          }
          var d = __define,c=ColorTransform,p=c.prototype;
          return ColorTransform;
      })();
      dragonBones.ColorTransform = ColorTransform;
      egret.registerClass(ColorTransform,'dragonBones.ColorTransform');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var CurveData = (function () {
          function CurveData() {
              this._dataChanged = false;
              this._pointList = [];
              this.sampling = new Array(CurveData.SamplingTimes);
              for (var i = 0; i < CurveData.SamplingTimes - 1; i++) {
                  this.sampling[i] = new dragonBones.Point();
              }
          }
          var d = __define,c=CurveData,p=c.prototype;
          p.getValueByProgress = function (progress) {
              if (this._dataChanged) {
                  this.refreshSampling();
              }
              for (var i = 0; i < CurveData.SamplingTimes - 1; i++) {
                  var point = this.sampling[i];
                  if (point.x >= progress) {
                      if (i == 0) {
                          return point.y * progress / point.x;
                      }
                      else {
                          var prevPoint = this.sampling[i - 1];
                          return prevPoint.y + (point.y - prevPoint.y) * (progress - prevPoint.x) / (point.x - prevPoint.x);
                      }
                  }
              }
              return point.y + (1 - point.y) * (progress - point.x) / (1 - point.x);
          };
          p.refreshSampling = function () {
              for (var i = 0; i < CurveData.SamplingTimes - 1; i++) {
                  this.bezierCurve(CurveData.SamplingStep * (i + 1), this.sampling[i]);
              }
              this._dataChanged = false;
          };
          p.bezierCurve = function (t, outputPoint) {
              var l_t = 1 - t;
              outputPoint.x = 3 * this.point1.x * t * l_t * l_t + 3 * this.point2.x * t * t * l_t + Math.pow(t, 3);
              outputPoint.y = 3 * this.point1.y * t * l_t * l_t + 3 * this.point2.y * t * t * l_t + Math.pow(t, 3);
          };
          d(p, "pointList"
              ,function () {
                  return this._pointList;
              }
              ,function (value) {
                  this._pointList = value;
                  this._dataChanged = true;
              }
          );
          p.isCurve = function () {
              return this.point1.x != 0 || this.point1.y != 0 || this.point2.x != 1 || this.point2.y != 1;
          };
          d(p, "point1"
              ,function () {
                  return this.pointList[0];
              }
          );
          d(p, "point2"
              ,function () {
                  return this.pointList[1];
              }
          );
          CurveData.SamplingTimes = 20;
          CurveData.SamplingStep = 0.05;
          return CurveData;
      })();
      dragonBones.CurveData = CurveData;
      egret.registerClass(CurveData,'dragonBones.CurveData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var DisplayData = (function () {
          function DisplayData() {
              this.transform = new dragonBones.DBTransform();
              this.pivot = new dragonBones.Point();
          }
          var d = __define,c=DisplayData,p=c.prototype;
          p.dispose = function () {
              this.transform = null;
              this.pivot = null;
          };
          DisplayData.ARMATURE = "armature";
          DisplayData.IMAGE = "image";
          return DisplayData;
      })();
      dragonBones.DisplayData = DisplayData;
      egret.registerClass(DisplayData,'dragonBones.DisplayData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var DragonBonesData = (function () {
          function DragonBonesData() {
              this._armatureDataList = [];
              this._displayDataDictionary = {};
          }
          var d = __define,c=DragonBonesData,p=c.prototype;
          p.dispose = function () {
              for (var i = 0, len = this._armatureDataList.length; i < len; i++) {
                  var armatureData = this._armatureDataList[i];
                  armatureData.dispose();
              }
              this._armatureDataList = null;
              this.removeAllDisplayData();
              this._displayDataDictionary = null;
          };
          d(p, "armatureDataList"
              ,function () {
                  return this._armatureDataList;
              }
          );
          p.getArmatureDataByName = function (armatureName) {
              var i = this._armatureDataList.length;
              while (i--) {
                  if (this._armatureDataList[i].name == armatureName) {
                      return this._armatureDataList[i];
                  }
              }
              return null;
          };
          p.addArmatureData = function (armatureData) {
              if (!armatureData) {
                  throw new Error();
              }
              if (this._armatureDataList.indexOf(armatureData) < 0) {
                  this._armatureDataList[this._armatureDataList.length] = armatureData;
              }
              else {
                  throw new Error();
              }
          };
          p.removeArmatureData = function (armatureData) {
              var index = this._armatureDataList.indexOf(armatureData);
              if (index >= 0) {
                  this._armatureDataList.splice(index, 1);
              }
          };
          p.removeArmatureDataByName = function (armatureName) {
              var i = this._armatureDataList.length;
              while (i--) {
                  if (this._armatureDataList[i].name == armatureName) {
                      this._armatureDataList.splice(i, 1);
                  }
              }
          };
          p.getDisplayDataByName = function (name) {
              return this._displayDataDictionary[name];
          };
          p.addDisplayData = function (displayData) {
              this._displayDataDictionary[displayData.name] = displayData;
          };
          p.removeDisplayDataByName = function (name) {
              delete this._displayDataDictionary[name];
          };
          p.removeAllDisplayData = function () {
              for (var name in this._displayDataDictionary) {
                  delete this._displayDataDictionary[name];
              }
          };
          return DragonBonesData;
      })();
      dragonBones.DragonBonesData = DragonBonesData;
      egret.registerClass(DragonBonesData,'dragonBones.DragonBonesData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var Frame = (function () {
          function Frame() {
              this.position = 0;
              this.duration = 0;
              this.position = 0;
              this.duration = 0;
          }
          var d = __define,c=Frame,p=c.prototype;
          p.dispose = function () {
          };
          return Frame;
      })();
      dragonBones.Frame = Frame;
      egret.registerClass(Frame,'dragonBones.Frame');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SkinData = (function () {
          function SkinData() {
              this._slotDataList = [];
          }
          var d = __define,c=SkinData,p=c.prototype;
          p.dispose = function () {
              var i = this._slotDataList.length;
              while (i--) {
                  this._slotDataList[i].dispose();
              }
              this._slotDataList = null;
          };
          p.getSlotData = function (slotName) {
              var i = this._slotDataList.length;
              while (i--) {
                  if (this._slotDataList[i].name == slotName) {
                      return this._slotDataList[i];
                  }
              }
              return null;
          };
          p.addSlotData = function (slotData) {
              if (!slotData) {
                  throw new Error();
              }
              if (this._slotDataList.indexOf(slotData) < 0) {
                  this._slotDataList[this._slotDataList.length] = slotData;
              }
              else {
                  throw new Error();
              }
          };
          d(p, "slotDataList"
              ,function () {
                  return this._slotDataList;
              }
          );
          return SkinData;
      })();
      dragonBones.SkinData = SkinData;
      egret.registerClass(SkinData,'dragonBones.SkinData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SlotData = (function () {
          function SlotData() {
              this._displayDataList = [];
              this.zOrder = 0;
          }
          var d = __define,c=SlotData,p=c.prototype;
          p.dispose = function () {
              this._displayDataList.length = 0;
          };
          p.addDisplayData = function (displayData) {
              if (!displayData) {
                  throw new Error();
              }
              if (this._displayDataList.indexOf(displayData) < 0) {
                  this._displayDataList[this._displayDataList.length] = displayData;
              }
              else {
                  throw new Error();
              }
          };
          p.getDisplayData = function (displayName) {
              var i = this._displayDataList.length;
              while (i--) {
                  if (this._displayDataList[i].name == displayName) {
                      return this._displayDataList[i];
                  }
              }
              return null;
          };
          d(p, "displayDataList"
              ,function () {
                  return this._displayDataList;
              }
          );
          return SlotData;
      })();
      dragonBones.SlotData = SlotData;
      egret.registerClass(SlotData,'dragonBones.SlotData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SlotFrame = (function (_super) {
          __extends(SlotFrame, _super);
          function SlotFrame() {
              _super.call(this);
              this.displayIndex = 0;
              this.tweenEasing = 10;
              this.displayIndex = 0;
              this.visible = true;
              this.zOrder = NaN;
          }
          var d = __define,c=SlotFrame,p=c.prototype;
          p.dispose = function () {
              _super.prototype.dispose.call(this);
              this.color = null;
          };
          return SlotFrame;
      })(dragonBones.Frame);
      dragonBones.SlotFrame = SlotFrame;
      egret.registerClass(SlotFrame,'dragonBones.SlotFrame');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var SlotTimeline = (function (_super) {
          __extends(SlotTimeline, _super);
          function SlotTimeline() {
              _super.call(this);
              this.offset = 0;
          }
          var d = __define,c=SlotTimeline,p=c.prototype;
          p.dispose = function () {
              _super.prototype.dispose.call(this);
          };
          return SlotTimeline;
      })(dragonBones.Timeline);
      dragonBones.SlotTimeline = SlotTimeline;
      egret.registerClass(SlotTimeline,'dragonBones.SlotTimeline');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var TransformFrame = (function (_super) {
          __extends(TransformFrame, _super);
          function TransformFrame() {
              _super.call(this);
              this.tweenRotate = 0;
              this.displayIndex = 0;
              this.tweenEasing = 10;
              this.tweenRotate = 0;
              this.tweenScale = true;
              this.displayIndex = 0;
              this.visible = true;
              this.zOrder = NaN;
              this.global = new dragonBones.DBTransform();
              this.transform = new dragonBones.DBTransform();
              this.pivot = new dragonBones.Point();
              this.scaleOffset = new dragonBones.Point();
          }
          var d = __define,c=TransformFrame,p=c.prototype;
          p.dispose = function () {
              _super.prototype.dispose.call(this);
              this.global = null;
              this.transform = null;
              this.pivot = null;
              this.scaleOffset = null;
              this.color = null;
          };
          return TransformFrame;
      })(dragonBones.Frame);
      dragonBones.TransformFrame = TransformFrame;
      egret.registerClass(TransformFrame,'dragonBones.TransformFrame');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var TransformTimeline = (function (_super) {
          __extends(TransformTimeline, _super);
          function TransformTimeline() {
              _super.call(this);
              this.originTransform = new dragonBones.DBTransform();
              this.originTransform.scaleX = 1;
              this.originTransform.scaleY = 1;
              this.originPivot = new dragonBones.Point();
              this.offset = 0;
          }
          var d = __define,c=TransformTimeline,p=c.prototype;
          p.dispose = function () {
              _super.prototype.dispose.call(this);
              this.originTransform = null;
              this.originPivot = null;
          };
          return TransformTimeline;
      })(dragonBones.Timeline);
      dragonBones.TransformTimeline = TransformTimeline;
      egret.registerClass(TransformTimeline,'dragonBones.TransformTimeline');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var TextureData = (function () {
          function TextureData(region, frame, rotated) {
              this.region = region;
              this.frame = frame;
              this.rotated = rotated;
          }
          var d = __define,c=TextureData,p=c.prototype;
          return TextureData;
      })();
      dragonBones.TextureData = TextureData;
      egret.registerClass(TextureData,'dragonBones.TextureData');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var ColorTransformUtil = (function () {
          function ColorTransformUtil() {
          }
          var d = __define,c=ColorTransformUtil,p=c.prototype;
          ColorTransformUtil.cloneColor = function (color) {
              var c = new dragonBones.ColorTransform();
              c.redMultiplier = color.redMultiplier;
              c.greenMultiplier = color.greenMultiplier;
              c.blueMultiplier = color.blueMultiplier;
              c.alphaMultiplier = color.alphaMultiplier;
              c.redOffset = color.redOffset;
              c.greenOffset = color.greenOffset;
              c.blueOffset = color.blueOffset;
              c.alphaOffset = color.alphaOffset;
              return c;
          };
          ColorTransformUtil.isEqual = function (color1, color2) {
              return color1.alphaOffset == color2.alphaOffset &&
                  color1.redOffset == color2.redOffset &&
                  color1.greenOffset == color2.greenOffset &&
                  color1.blueOffset == color2.blueOffset &&
                  color1.alphaMultiplier == color2.alphaMultiplier &&
                  color1.redMultiplier == color2.redMultiplier &&
                  color1.greenMultiplier == color2.greenMultiplier &&
                  color1.blueMultiplier == color2.blueMultiplier;
          };
          ColorTransformUtil.minus = function (color1, color2, outputColor) {
              outputColor.alphaOffset = color1.alphaOffset - color2.alphaOffset;
              outputColor.redOffset = color1.redOffset - color2.redOffset;
              outputColor.greenOffset = color1.greenOffset - color2.greenOffset;
              outputColor.blueOffset = color1.blueOffset - color2.blueOffset;
              outputColor.alphaMultiplier = color1.alphaMultiplier - color2.alphaMultiplier;
              outputColor.redMultiplier = color1.redMultiplier - color2.redMultiplier;
              outputColor.greenMultiplier = color1.greenMultiplier - color2.greenMultiplier;
              outputColor.blueMultiplier = color1.blueMultiplier - color2.blueMultiplier;
          };
          ColorTransformUtil.originalColor = new dragonBones.ColorTransform();
          return ColorTransformUtil;
      })();
      dragonBones.ColorTransformUtil = ColorTransformUtil;
      egret.registerClass(ColorTransformUtil,'dragonBones.ColorTransformUtil');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var ConstValues = (function () {
          function ConstValues() {
          }
          var d = __define,c=ConstValues,p=c.prototype;
          ConstValues.ANGLE_TO_RADIAN = Math.PI / 180;
          ConstValues.RADIAN_TO_ANGLE = 180 / Math.PI;
          ConstValues.DRAGON_BONES = "dragonBones";
          ConstValues.ARMATURE = "armature";
          ConstValues.SKIN = "skin";
          ConstValues.BONE = "bone";
          ConstValues.SLOT = "slot";
          ConstValues.DISPLAY = "display";
          ConstValues.ANIMATION = "animation";
          ConstValues.TIMELINE = "timeline";
          ConstValues.FRAME = "frame";
          ConstValues.TRANSFORM = "transform";
          ConstValues.COLOR_TRANSFORM = "colorTransform";
          ConstValues.COLOR = "color";
          ConstValues.RECTANGLE = "rectangle";
          ConstValues.ELLIPSE = "ellipse";
          ConstValues.TEXTURE_ATLAS = "TextureAtlas";
          ConstValues.SUB_TEXTURE = "SubTexture";
          ConstValues.A_ROTATED = "rotated";
          ConstValues.A_FRAME_X = "frameX";
          ConstValues.A_FRAME_Y = "frameY";
          ConstValues.A_FRAME_WIDTH = "frameWidth";
          ConstValues.A_FRAME_HEIGHT = "frameHeight";
          ConstValues.A_VERSION = "version";
          ConstValues.A_IMAGE_PATH = "imagePath";
          ConstValues.A_FRAME_RATE = "frameRate";
          ConstValues.A_NAME = "name";
          ConstValues.A_IS_GLOBAL = "isGlobal";
          ConstValues.A_PARENT = "parent";
          ConstValues.A_LENGTH = "length";
          ConstValues.A_TYPE = "type";
          ConstValues.A_FADE_IN_TIME = "fadeInTime";
          ConstValues.A_DURATION = "duration";
          ConstValues.A_SCALE = "scale";
          ConstValues.A_OFFSET = "offset";
          ConstValues.A_LOOP = "loop";
          ConstValues.A_PLAY_TIMES = "playTimes";
          ConstValues.A_EVENT = "event";
          ConstValues.A_EVENT_PARAMETERS = "eventParameters";
          ConstValues.A_SOUND = "sound";
          ConstValues.A_ACTION = "action";
          ConstValues.A_HIDE = "hide";
          ConstValues.A_AUTO_TWEEN = "autoTween";
          ConstValues.A_TWEEN_EASING = "tweenEasing";
          ConstValues.A_TWEEN_ROTATE = "tweenRotate";
          ConstValues.A_TWEEN_SCALE = "tweenScale";
          ConstValues.A_DISPLAY_INDEX = "displayIndex";
          ConstValues.A_Z_ORDER = "z";
          ConstValues.A_BLENDMODE = "blendMode";
          ConstValues.A_WIDTH = "width";
          ConstValues.A_HEIGHT = "height";
          ConstValues.A_INHERIT_SCALE = "inheritScale";
          ConstValues.A_INHERIT_ROTATION = "inheritRotation";
          ConstValues.A_X = "x";
          ConstValues.A_Y = "y";
          ConstValues.A_SKEW_X = "skX";
          ConstValues.A_SKEW_Y = "skY";
          ConstValues.A_SCALE_X = "scX";
          ConstValues.A_SCALE_Y = "scY";
          ConstValues.A_PIVOT_X = "pX";
          ConstValues.A_PIVOT_Y = "pY";
          ConstValues.A_ALPHA_OFFSET = "aO";
          ConstValues.A_RED_OFFSET = "rO";
          ConstValues.A_GREEN_OFFSET = "gO";
          ConstValues.A_BLUE_OFFSET = "bO";
          ConstValues.A_ALPHA_MULTIPLIER = "aM";
          ConstValues.A_RED_MULTIPLIER = "rM";
          ConstValues.A_GREEN_MULTIPLIER = "gM";
          ConstValues.A_BLUE_MULTIPLIER = "bM";
          ConstValues.A_CURVE = "curve";
          ConstValues.A_SCALE_X_OFFSET = "scXOffset";
          ConstValues.A_SCALE_Y_OFFSET = "scYOffset";
          ConstValues.A_SCALE_MODE = "scaleMode";
          ConstValues.A_FIXED_ROTATION = "fixedRotation";
          return ConstValues;
      })();
      dragonBones.ConstValues = ConstValues;
      egret.registerClass(ConstValues,'dragonBones.ConstValues');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var DBDataUtil = (function () {
          function DBDataUtil() {
          }
          var d = __define,c=DBDataUtil,p=c.prototype;
          DBDataUtil.transformArmatureData = function (armatureData) {
              var boneDataList = armatureData.boneDataList;
              var i = boneDataList.length;
              while (i--) {
                  var boneData = boneDataList[i];
                  if (boneData.parent) {
                      var parentBoneData = armatureData.getBoneData(boneData.parent);
                      if (parentBoneData) {
                          boneData.transform.copy(boneData.global);
                          dragonBones.TransformUtil.globalToLocal(boneData.transform, parentBoneData.global);
                      }
                  }
              }
          };
          DBDataUtil.transformArmatureDataAnimations = function (armatureData) {
              var animationDataList = armatureData.animationDataList;
              var i = animationDataList.length;
              while (i--) {
                  DBDataUtil.transformAnimationData(animationDataList[i], armatureData, false);
              }
          };
          DBDataUtil.transformRelativeAnimationData = function (animationData, armatureData) {
          };
          DBDataUtil.transformAnimationData = function (animationData, armatureData, isGlobalData) {
              if (!isGlobalData) {
                  DBDataUtil.transformRelativeAnimationData(animationData, armatureData);
                  return;
              }
              var skinData = armatureData.getSkinData(null);
              var boneDataList = armatureData.boneDataList;
              var slotDataList;
              if (skinData) {
                  slotDataList = skinData.slotDataList;
              }
              for (var i = 0; i < boneDataList.length; i++) {
                  var boneData = boneDataList[i];
                  var timeline = animationData.getTimeline(boneData.name);
                  var slotTimeline = animationData.getSlotTimeline(boneData.name);
                  if (!timeline && !slotTimeline) {
                      continue;
                  }
                  var slotData = null;
                  if (slotDataList) {
                      for (var j = 0, jLen = slotDataList.length; j < jLen; j++) {
                          slotData = slotDataList[j];
                          if (slotData.parent == boneData.name) {
                              break;
                          }
                      }
                  }
                  var frameList = timeline.frameList;
                  if (slotTimeline) {
                      var slotFrameList = slotTimeline.frameList;
                  }
                  var originTransform = null;
                  var originPivot = null;
                  var prevFrame = null;
                  var frameListLength = frameList.length;
                  for (var j = 0; j < frameListLength; j++) {
                      var frame = (frameList[j]);
                      DBDataUtil.setFrameTransform(animationData, armatureData, boneData, frame);
                      frame.transform.x -= boneData.transform.x;
                      frame.transform.y -= boneData.transform.y;
                      frame.transform.skewX -= boneData.transform.skewX;
                      frame.transform.skewY -= boneData.transform.skewY;
                      frame.transform.scaleX /= boneData.transform.scaleX;
                      frame.transform.scaleY /= boneData.transform.scaleY;
                      if (prevFrame) {
                          var dLX = frame.transform.skewX - prevFrame.transform.skewX;
                          if (prevFrame.tweenRotate) {
                              if (prevFrame.tweenRotate > 0) {
                                  if (dLX < 0) {
                                      frame.transform.skewX += Math.PI * 2;
                                      frame.transform.skewY += Math.PI * 2;
                                  }
                                  if (prevFrame.tweenRotate > 1) {
                                      frame.transform.skewX += Math.PI * 2 * (prevFrame.tweenRotate - 1);
                                      frame.transform.skewY += Math.PI * 2 * (prevFrame.tweenRotate - 1);
                                  }
                              }
                              else {
                                  if (dLX > 0) {
                                      frame.transform.skewX -= Math.PI * 2;
                                      frame.transform.skewY -= Math.PI * 2;
                                  }
                                  if (prevFrame.tweenRotate < 1) {
                                      frame.transform.skewX += Math.PI * 2 * (prevFrame.tweenRotate + 1);
                                      frame.transform.skewY += Math.PI * 2 * (prevFrame.tweenRotate + 1);
                                  }
                              }
                          }
                          else {
                              frame.transform.skewX = prevFrame.transform.skewX + dragonBones.TransformUtil.formatRadian(frame.transform.skewX - prevFrame.transform.skewX);
                              frame.transform.skewY = prevFrame.transform.skewY + dragonBones.TransformUtil.formatRadian(frame.transform.skewY - prevFrame.transform.skewY);
                          }
                      }
                      prevFrame = frame;
                  }
                  if (slotTimeline && slotFrameList) {
                      frameListLength = slotFrameList.length;
                      for (var j = 0; j < frameListLength; j++) {
                          var slotFrame = slotFrameList[j];
                          if (!slotTimeline.transformed) {
                              if (slotData) {
                                  slotFrame.zOrder -= slotData.zOrder;
                              }
                          }
                      }
                      slotTimeline.transformed = true;
                  }
                  timeline.transformed = true;
              }
          };
          DBDataUtil.setFrameTransform = function (animationData, armatureData, boneData, frame) {
              frame.transform.copy(frame.global);
              var parentData = armatureData.getBoneData(boneData.parent);
              if (parentData) {
                  var parentTimeline = animationData.getTimeline(parentData.name);
                  if (parentTimeline) {
                      var parentTimelineList = [];
                      var parentDataList = [];
                      while (parentTimeline) {
                          parentTimelineList.push(parentTimeline);
                          parentDataList.push(parentData);
                          parentData = armatureData.getBoneData(parentData.parent);
                          if (parentData) {
                              parentTimeline = animationData.getTimeline(parentData.name);
                          }
                          else {
                              parentTimeline = null;
                          }
                      }
                      var i = parentTimelineList.length;
                      var globalTransform;
                      var globalTransformMatrix = new dragonBones.Matrix();
                      var currentTransform = new dragonBones.DBTransform();
                      var currentTransformMatrix = new dragonBones.Matrix();
                      while (i--) {
                          parentTimeline = parentTimelineList[i];
                          parentData = parentDataList[i];
                          DBDataUtil.getTimelineTransform(parentTimeline, frame.position, currentTransform, !globalTransform);
                          if (!globalTransform) {
                              globalTransform = new dragonBones.DBTransform();
                              globalTransform.copy(currentTransform);
                          }
                          else {
                              currentTransform.x += parentTimeline.originTransform.x + parentData.transform.x;
                              currentTransform.y += parentTimeline.originTransform.y + parentData.transform.y;
                              currentTransform.skewX += parentTimeline.originTransform.skewX + parentData.transform.skewX;
                              currentTransform.skewY += parentTimeline.originTransform.skewY + parentData.transform.skewY;
                              currentTransform.scaleX *= parentTimeline.originTransform.scaleX * parentData.transform.scaleX;
                              currentTransform.scaleY *= parentTimeline.originTransform.scaleY * parentData.transform.scaleY;
                              dragonBones.TransformUtil.transformToMatrix(currentTransform, currentTransformMatrix, true);
                              currentTransformMatrix.concat(globalTransformMatrix);
                              dragonBones.TransformUtil.matrixToTransform(currentTransformMatrix, globalTransform, currentTransform.scaleX * globalTransform.scaleX >= 0, currentTransform.scaleY * globalTransform.scaleY >= 0);
                          }
                          dragonBones.TransformUtil.transformToMatrix(globalTransform, globalTransformMatrix, true);
                      }
                      dragonBones.TransformUtil.globalToLocal(frame.transform, globalTransform);
                  }
              }
          };
          DBDataUtil.getTimelineTransform = function (timeline, position, retult, isGlobal) {
              var frameList = timeline.frameList;
              var i = frameList.length;
              while (i--) {
                  var currentFrame = (frameList[i]);
                  if (currentFrame.position <= position && currentFrame.position + currentFrame.duration > position) {
                      if (i == frameList.length - 1 || position == currentFrame.position) {
                          retult.copy(isGlobal ? currentFrame.global : currentFrame.transform);
                      }
                      else {
                          var tweenEasing = currentFrame.tweenEasing;
                          var progress = (position - currentFrame.position) / currentFrame.duration;
                          if (tweenEasing && tweenEasing != 10) {
                              progress = dragonBones.MathUtil.getEaseValue(progress, tweenEasing);
                          }
                          var nextFrame = frameList[i + 1];
                          var currentTransform = isGlobal ? currentFrame.global : currentFrame.transform;
                          var nextTransform = isGlobal ? nextFrame.global : nextFrame.transform;
                          retult.x = currentTransform.x + (nextTransform.x - currentTransform.x) * progress;
                          retult.y = currentTransform.y + (nextTransform.y - currentTransform.y) * progress;
                          retult.skewX = dragonBones.TransformUtil.formatRadian(currentTransform.skewX + (nextTransform.skewX - currentTransform.skewX) * progress);
                          retult.skewY = dragonBones.TransformUtil.formatRadian(currentTransform.skewY + (nextTransform.skewY - currentTransform.skewY) * progress);
                          retult.scaleX = currentTransform.scaleX + (nextTransform.scaleX - currentTransform.scaleX) * progress;
                          retult.scaleY = currentTransform.scaleY + (nextTransform.scaleY - currentTransform.scaleY) * progress;
                      }
                      break;
                  }
              }
          };
          DBDataUtil.addHideTimeline = function (animationData, armatureData, addHideSlot) {
              if (addHideSlot === void 0) { addHideSlot = false; }
              var boneDataList = armatureData.boneDataList;
              var slotDataList = armatureData.slotDataList;
              var i = boneDataList.length;
              while (i--) {
                  var boneData = boneDataList[i];
                  var boneName = boneData.name;
                  if (!animationData.getTimeline(boneName)) {
                      if (animationData.hideTimelineNameMap.indexOf(boneName) < 0) {
                          animationData.hideTimelineNameMap.push(boneName);
                      }
                  }
              }
              if (addHideSlot) {
                  i = slotDataList.length;
                  var slotData;
                  var slotName;
                  while (i--) {
                      slotData = slotDataList[i];
                      slotName = slotData.name;
                      if (!animationData.getSlotTimeline(slotName)) {
                          if (animationData.hideSlotTimelineNameMap.indexOf(slotName) < 0) {
                              animationData.hideSlotTimelineNameMap.push(slotName);
                          }
                      }
                  }
              }
          };
          return DBDataUtil;
      })();
      dragonBones.DBDataUtil = DBDataUtil;
      egret.registerClass(DBDataUtil,'dragonBones.DBDataUtil');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var MathUtil = (function () {
          function MathUtil() {
          }
          var d = __define,c=MathUtil,p=c.prototype;
          MathUtil.getEaseValue = function (value, easing) {
              var valueEase = 1;
              if (easing > 1) {
                  valueEase = 0.5 * (1 - MathUtil.cos(value * Math.PI));
                  easing -= 1;
              }
              else if (easing > 0) {
                  valueEase = 1 - Math.pow(1 - value, 2);
              }
              else if (easing < 0) {
                  easing *= -1;
                  valueEase = Math.pow(value, 2);
              }
              return (valueEase - value) * easing + value;
          };
          MathUtil.isNumber = function (value) {
              return typeof (value) === "number" && !isNaN(value);
          };
          MathUtil.sin = function (value) {
              value *= MathUtil.RADIAN_TO_ANGLE;
              var valueFloor = Math.floor(value);
              var valueCeil = valueFloor + 1;
              var resultFloor = MathUtil.sinInt(valueFloor);
              var resultCeil = MathUtil.sinInt(valueCeil);
              return (value - valueFloor) * resultCeil + (valueCeil - value) * resultFloor;
          };
          MathUtil.sinInt = function (value) {
              value = value % 360;
              if (value < 0) {
                  value += 360;
              }
              if (value < 90) {
                  return db_sin_map[value];
              }
              if (value < 180) {
                  return db_sin_map[180 - value];
              }
              if (value < 270) {
                  return -db_sin_map[value - 180];
              }
              return -db_sin_map[360 - value];
          };
          MathUtil.cos = function (value) {
              return MathUtil.sin(Math.PI / 2 - value);
          };
          MathUtil.ANGLE_TO_RADIAN = Math.PI / 180;
          MathUtil.RADIAN_TO_ANGLE = 180 / Math.PI;
          return MathUtil;
      })();
      dragonBones.MathUtil = MathUtil;
      egret.registerClass(MathUtil,'dragonBones.MathUtil');
  })(dragonBones || (dragonBones = {}));
  var db_sin_map = {};
  for (var dbMathIndex = 0; dbMathIndex <= 90; dbMathIndex++) {
      db_sin_map[dbMathIndex] = Math.sin(dbMathIndex * dragonBones.MathUtil.ANGLE_TO_RADIAN);
  }
  var dragonBones;
  (function (dragonBones) {
      var TransformUtil = (function () {
          function TransformUtil() {
          }
          var d = __define,c=TransformUtil,p=c.prototype;
          TransformUtil.globalToLocal = function (transform, parent) {
              TransformUtil.transformToMatrix(transform, TransformUtil._helpTransformMatrix, true);
              TransformUtil.transformToMatrix(parent, TransformUtil._helpParentTransformMatrix, true);
              TransformUtil._helpParentTransformMatrix.invert();
              TransformUtil._helpTransformMatrix.concat(TransformUtil._helpParentTransformMatrix);
              TransformUtil.matrixToTransform(TransformUtil._helpTransformMatrix, transform, transform.scaleX * parent.scaleX >= 0, transform.scaleY * parent.scaleY >= 0);
          };
          TransformUtil.transformToMatrix = function (transform, matrix, keepScale) {
              if (keepScale === void 0) { keepScale = false; }
              if (keepScale) {
                  matrix.a = transform.scaleX * dragonBones.MathUtil.cos(transform.skewY);
                  matrix.b = transform.scaleX * dragonBones.MathUtil.sin(transform.skewY);
                  matrix.c = -transform.scaleY * dragonBones.MathUtil.sin(transform.skewX);
                  matrix.d = transform.scaleY * dragonBones.MathUtil.cos(transform.skewX);
                  matrix.tx = transform.x;
                  matrix.ty = transform.y;
              }
              else {
                  matrix.a = dragonBones.MathUtil.cos(transform.skewY);
                  matrix.b = dragonBones.MathUtil.sin(transform.skewY);
                  matrix.c = -dragonBones.MathUtil.sin(transform.skewX);
                  matrix.d = dragonBones.MathUtil.cos(transform.skewX);
                  matrix.tx = transform.x;
                  matrix.ty = transform.y;
              }
          };
          TransformUtil.matrixToTransform = function (matrix, transform, scaleXF, scaleYF) {
              transform.x = matrix.tx;
              transform.y = matrix.ty;
              transform.scaleX = Math.sqrt(matrix.a * matrix.a + matrix.b * matrix.b) * (scaleXF ? 1 : -1);
              transform.scaleY = Math.sqrt(matrix.d * matrix.d + matrix.c * matrix.c) * (scaleYF ? 1 : -1);
              var skewXArray = [];
              skewXArray[0] = Math.acos(matrix.d / transform.scaleY);
              skewXArray[1] = -skewXArray[0];
              skewXArray[2] = Math.asin(-matrix.c / transform.scaleY);
              skewXArray[3] = skewXArray[2] >= 0 ? Math.PI - skewXArray[2] : skewXArray[2] - Math.PI;
              if (Number(skewXArray[0]).toFixed(4) == Number(skewXArray[2]).toFixed(4) || Number(skewXArray[0]).toFixed(4) == Number(skewXArray[3]).toFixed(4)) {
                  transform.skewX = skewXArray[0];
              }
              else {
                  transform.skewX = skewXArray[1];
              }
              var skewYArray = [];
              skewYArray[0] = Math.acos(matrix.a / transform.scaleX);
              skewYArray[1] = -skewYArray[0];
              skewYArray[2] = Math.asin(matrix.b / transform.scaleX);
              skewYArray[3] = skewYArray[2] >= 0 ? Math.PI - skewYArray[2] : skewYArray[2] - Math.PI;
              if (Number(skewYArray[0]).toFixed(4) == Number(skewYArray[2]).toFixed(4) || Number(skewYArray[0]).toFixed(4) == Number(skewYArray[3]).toFixed(4)) {
                  transform.skewY = skewYArray[0];
              }
              else {
                  transform.skewY = skewYArray[1];
              }
          };
          TransformUtil.formatRadian = function (radian) {
              if (radian > Math.PI) {
                  radian -= TransformUtil.DOUBLE_PI;
              }
              if (radian < -Math.PI) {
                  radian += TransformUtil.DOUBLE_PI;
              }
              return radian;
          };
          TransformUtil.normalizeRotation = function (rotation) {
              rotation = (rotation + Math.PI) % (2 * Math.PI);
              rotation = rotation > 0 ? rotation : 2 * Math.PI + rotation;
              return rotation - Math.PI;
          };
          TransformUtil.HALF_PI = Math.PI * 0.5;
          TransformUtil.DOUBLE_PI = Math.PI * 2;
          TransformUtil._helpTransformMatrix = new dragonBones.Matrix();
          TransformUtil._helpParentTransformMatrix = new dragonBones.Matrix();
          return TransformUtil;
      })();
      dragonBones.TransformUtil = TransformUtil;
      egret.registerClass(TransformUtil,'dragonBones.TransformUtil');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastAnimation = (function () {
          function FastAnimation(armature) {
              this.animationState = new dragonBones.FastAnimationState();
              this._armature = armature;
              this.animationState._armature = armature;
              this.animationList = [];
              this._animationDataObj = {};
              this._isPlaying = false;
              this._timeScale = 1;
          }
          var d = __define,c=FastAnimation,p=c.prototype;
          p.dispose = function () {
              if (!this._armature) {
                  return;
              }
              this._armature = null;
              this._animationDataList = null;
              this.animationList = null;
              this.animationState = null;
          };
          p.gotoAndPlay = function (animationName, fadeInTime, duration, playTimes) {
              if (fadeInTime === void 0) { fadeInTime = -1; }
              if (duration === void 0) { duration = -1; }
              if (playTimes === void 0) { playTimes = NaN; }
              if (!this._animationDataList) {
                  return null;
              }
              var animationData = this._animationDataObj[animationName];
              if (!animationData) {
                  return null;
              }
              this._isPlaying = true;
              fadeInTime = fadeInTime < 0 ? (animationData.fadeTime < 0 ? 0.3 : animationData.fadeTime) : fadeInTime;
              var durationScale;
              if (duration < 0) {
                  durationScale = animationData.scale < 0 ? 1 : animationData.scale;
              }
              else {
                  durationScale = duration * 1000 / animationData.duration;
              }
              playTimes = isNaN(playTimes) ? animationData.playTimes : playTimes;
              this.animationState._fadeIn(animationData, playTimes, 1 / durationScale, fadeInTime);
              if (this._armature.enableCache && this.animationCacheManager) {
                  this.animationState.animationCache = this.animationCacheManager.getAnimationCache(animationName);
              }
              var i = this._armature.slotHasChildArmatureList.length;
              while (i--) {
                  var slot = this._armature.slotHasChildArmatureList[i];
                  var childArmature = slot.childArmature;
                  if (childArmature) {
                      childArmature.getAnimation().gotoAndPlay(animationName);
                  }
              }
              return this.animationState;
          };
          p.gotoAndStop = function (animationName, time, normalizedTime, fadeInTime, duration) {
              if (normalizedTime === void 0) { normalizedTime = -1; }
              if (fadeInTime === void 0) { fadeInTime = 0; }
              if (duration === void 0) { duration = -1; }
              if (this.animationState.name != animationName) {
                  this.gotoAndPlay(animationName, fadeInTime, duration);
              }
              if (normalizedTime >= 0) {
                  this.animationState.setCurrentTime(this.animationState.totalTime * normalizedTime);
              }
              else {
                  this.animationState.setCurrentTime(time);
              }
              this.animationState.stop();
              return this.animationState;
          };
          p.play = function () {
              if (!this._animationDataList) {
                  return;
              }
              if (!this.animationState.name) {
                  this.gotoAndPlay(this._animationDataList[0].name);
              }
              else if (!this._isPlaying) {
                  this._isPlaying = true;
              }
              else {
                  this.gotoAndPlay(this.animationState.name);
              }
          };
          p.stop = function () {
              this._isPlaying = false;
          };
          p.advanceTime = function (passedTime) {
              if (!this._isPlaying) {
                  return;
              }
              this.animationState._advanceTime(passedTime * this._timeScale);
          };
          p.hasAnimation = function (animationName) {
              return this._animationDataObj[animationName] != null;
          };
          d(p, "timeScale"
              ,function () {
                  return this._timeScale;
              }
              ,function (value) {
                  if (isNaN(value) || value < 0) {
                      value = 1;
                  }
                  this._timeScale = value;
              }
          );
          d(p, "animationDataList"
              ,function () {
                  return this._animationDataList;
              }
              ,function (value) {
                  this._animationDataList = value;
                  this.animationList.length = 0;
                  var length = this._animationDataList.length;
                  for (var i = 0; i < length; i++) {
                      var animationData = this._animationDataList[i];
                      this.animationList.push(animationData.name);
                      this._animationDataObj[animationData.name] = animationData;
                  }
              }
          );
          d(p, "movementList"
              ,function () {
                  return this.animationList;
              }
          );
          d(p, "movementID"
              ,function () {
                  return this.lastAnimationName;
              }
          );
          p.isPlaying = function () {
              return this._isPlaying && !this.isComplete;
          };
          d(p, "isComplete"
              ,function () {
                  return this.animationState.isComplete;
              }
          );
          d(p, "lastAnimationState"
              ,function () {
                  return this.animationState;
              }
          );
          d(p, "lastAnimationName"
              ,function () {
                  return this.animationState ? this.animationState.name : null;
              }
          );
          return FastAnimation;
      })();
      dragonBones.FastAnimation = FastAnimation;
      egret.registerClass(FastAnimation,'dragonBones.FastAnimation');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastAnimationState = (function () {
          function FastAnimationState() {
              this._boneTimelineStateList = [];
              this._slotTimelineStateList = [];
              this._currentFrameIndex = 0;
              this._currentFramePosition = 0;
              this._currentFrameDuration = 0;
              this._currentPlayTimes = 0;
              this._totalTime = 0;
              this._currentTime = 0;
              this._lastTime = 0;
              this._playTimes = 0;
              this._fading = false;
          }
          var d = __define,c=FastAnimationState,p=c.prototype;
          p.dispose = function () {
              this._resetTimelineStateList();
              this._armature = null;
          };
          p.play = function () {
              this._isPlaying = true;
              return this;
          };
          p.stop = function () {
              this._isPlaying = false;
              return this;
          };
          p.setCurrentTime = function (value) {
              if (value < 0 || isNaN(value)) {
                  value = 0;
              }
              this._time = value;
              this._currentTime = this._time * 1000;
              return this;
          };
          p._resetTimelineStateList = function () {
              var i = this._boneTimelineStateList.length;
              while (i--) {
                  dragonBones.FastBoneTimelineState.returnObject(this._boneTimelineStateList[i]);
              }
              this._boneTimelineStateList.length = 0;
              i = this._slotTimelineStateList.length;
              while (i--) {
                  dragonBones.FastSlotTimelineState.returnObject(this._slotTimelineStateList[i]);
              }
              this._slotTimelineStateList.length = 0;
              this.name = null;
          };
          p._fadeIn = function (aniData, playTimes, timeScale, fadeTotalTime) {
              this.animationData = aniData;
              this.name = this.animationData.name;
              this._totalTime = this.animationData.duration;
              this.autoTween = aniData.autoTween;
              this.setTimeScale(timeScale);
              this.setPlayTimes(playTimes);
              this._isComplete = false;
              this._currentFrameIndex = -1;
              this._currentPlayTimes = -1;
              if (Math.round(this._totalTime * this.animationData.frameRate * 0.001) < 2) {
                  this._currentTime = this._totalTime;
              }
              else {
                  this._currentTime = -1;
              }
              this._fadeTotalTime = fadeTotalTime * this._timeScale;
              this._fading = this._fadeTotalTime > 0;
              this._isPlaying = true;
              if (this._armature.enableCache && this.animationCache && this._fading && this._boneTimelineStateList) {
                  this.updateTransformTimeline(this.progress);
              }
              this._time = 0;
              this._progress = 0;
              this._updateTimelineStateList();
              this.hideBones();
              return;
          };
          p._updateTimelineStateList = function () {
              this._resetTimelineStateList();
              var timelineName;
              var length = this.animationData.timelineList.length;
              for (var i = 0; i < length; i++) {
                  var boneTimeline = this.animationData.timelineList[i];
                  timelineName = boneTimeline.name;
                  var bone = this._armature.getBone(timelineName);
                  if (bone) {
                      var boneTimelineState = dragonBones.FastBoneTimelineState.borrowObject();
                      boneTimelineState.fadeIn(bone, this, boneTimeline);
                      this._boneTimelineStateList.push(boneTimelineState);
                  }
              }
              var length1 = this.animationData.slotTimelineList.length;
              for (var i1 = 0; i1 < length1; i1++) {
                  var slotTimeline = this.animationData.slotTimelineList[i1];
                  timelineName = slotTimeline.name;
                  var slot = this._armature.getSlot(timelineName);
                  if (slot && slot.displayList.length > 0) {
                      var slotTimelineState = dragonBones.FastSlotTimelineState.borrowObject();
                      slotTimelineState.fadeIn(slot, this, slotTimeline);
                      this._slotTimelineStateList.push(slotTimelineState);
                  }
              }
          };
          p._advanceTime = function (passedTime) {
              passedTime *= this._timeScale;
              if (this._fading) {
                  this._time += passedTime;
                  this._progress = this._time / this._fadeTotalTime;
                  if (this._progress >= 1) {
                      this._progress = 0;
                      this._time = 0;
                      this._fading = false;
                  }
              }
              if (this._fading) {
                  var length = this._boneTimelineStateList.length;
                  for (var i = 0; i < length; i++) {
                      var timeline = this._boneTimelineStateList[i];
                      timeline.updateFade(this.progress);
                  }
                  var length1 = this._slotTimelineStateList.length;
                  for (var i1 = 0; i1 < length1; i1++) {
                      var slotTimeline = this._slotTimelineStateList[i1];
                      slotTimeline.updateFade(this.progress);
                  }
              }
              else {
                  this.advanceTimelinesTime(passedTime);
              }
          };
          p.advanceTimelinesTime = function (passedTime) {
              if (this._isPlaying) {
                  this._time += passedTime;
              }
              var startFlg = false;
              var loopCompleteFlg = false;
              var completeFlg = false;
              var isThisComplete = false;
              var currentPlayTimes = 0;
              var currentTime = this._time * 1000;
              if (this._playTimes == 0 ||
                  currentTime < this._playTimes * this._totalTime) {
                  isThisComplete = false;
                  this._progress = currentTime / this._totalTime;
                  currentPlayTimes = Math.ceil(this.progress) || 1;
                  this._progress -= Math.floor(this.progress);
                  currentTime %= this._totalTime;
              }
              else {
                  currentPlayTimes = this._playTimes;
                  currentTime = this._totalTime;
                  isThisComplete = true;
                  this._progress = 1;
              }
              this._isComplete = isThisComplete;
              if (this.isUseCache()) {
                  this.animationCache.update(this.progress);
              }
              else {
                  this.updateTransformTimeline(this.progress);
              }
              if (this._currentTime != currentTime) {
                  if (this._currentPlayTimes != currentPlayTimes) {
                      if (this._currentPlayTimes > 0 && currentPlayTimes > 1) {
                          loopCompleteFlg = true;
                      }
                      this._currentPlayTimes = currentPlayTimes;
                  }
                  if (this._currentTime < 0) {
                      startFlg = true;
                  }
                  if (this._isComplete) {
                      completeFlg = true;
                  }
                  this._lastTime = this._currentTime;
                  this._currentTime = currentTime;
                  this.updateMainTimeline(isThisComplete);
              }
              var event;
              if (startFlg) {
                  if (this._armature.hasEventListener(dragonBones.AnimationEvent.START)) {
                      event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.START);
                      event.animationState = this;
                      this._armature._addEvent(event);
                  }
              }
              if (completeFlg) {
                  if (this._armature.hasEventListener(dragonBones.AnimationEvent.COMPLETE)) {
                      event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.COMPLETE);
                      event.animationState = this;
                      this._armature._addEvent(event);
                  }
              }
              else if (loopCompleteFlg) {
                  if (this._armature.hasEventListener(dragonBones.AnimationEvent.LOOP_COMPLETE)) {
                      event = new dragonBones.AnimationEvent(dragonBones.AnimationEvent.LOOP_COMPLETE);
                      event.animationState = this;
                      this._armature._addEvent(event);
                  }
              }
          };
          p.updateTransformTimeline = function (progress) {
              var i = this._boneTimelineStateList.length;
              var boneTimeline;
              var slotTimeline;
              if (this._isComplete) {
                  while (i--) {
                      boneTimeline = this._boneTimelineStateList[i];
                      boneTimeline.update(progress);
                      this._isComplete = boneTimeline._isComplete && this._isComplete;
                  }
                  i = this._slotTimelineStateList.length;
                  while (i--) {
                      slotTimeline = this._slotTimelineStateList[i];
                      slotTimeline.update(progress);
                      this._isComplete = slotTimeline._isComplete && this._isComplete;
                  }
              }
              else {
                  while (i--) {
                      boneTimeline = this._boneTimelineStateList[i];
                      boneTimeline.update(progress);
                  }
                  i = this._slotTimelineStateList.length;
                  while (i--) {
                      slotTimeline = this._slotTimelineStateList[i];
                      slotTimeline.update(progress);
                  }
              }
          };
          p.updateMainTimeline = function (isThisComplete) {
              var frameList = this.animationData.frameList;
              if (frameList.length > 0) {
                  var prevFrame;
                  var currentFrame;
                  for (var i = 0, l = this.animationData.frameList.length; i < l; ++i) {
                      if (this._currentFrameIndex < 0) {
                          this._currentFrameIndex = 0;
                      }
                      else if (this._currentTime < this._currentFramePosition || this._currentTime >= this._currentFramePosition + this._currentFrameDuration || this._currentTime < this._lastTime) {
                          this._lastTime = this._currentTime;
                          this._currentFrameIndex++;
                          if (this._currentFrameIndex >= frameList.length) {
                              if (isThisComplete) {
                                  this._currentFrameIndex--;
                                  break;
                              }
                              else {
                                  this._currentFrameIndex = 0;
                              }
                          }
                      }
                      else {
                          break;
                      }
                      currentFrame = frameList[this._currentFrameIndex];
                      if (prevFrame) {
                          this._armature.arriveAtFrame(prevFrame, this);
                      }
                      this._currentFrameDuration = currentFrame.duration;
                      this._currentFramePosition = currentFrame.position;
                      prevFrame = currentFrame;
                  }
                  if (currentFrame) {
                      this._armature.arriveAtFrame(currentFrame, this);
                  }
              }
          };
          p.setTimeScale = function (value) {
              if (isNaN(value) || value == Infinity) {
                  value = 1;
              }
              this._timeScale = value;
              return this;
          };
          p.setPlayTimes = function (value) {
              if (value === void 0) { value = 0; }
              if (Math.round(this._totalTime * 0.001 * this.animationData.frameRate) < 2) {
                  this._playTimes = 1;
              }
              else {
                  this._playTimes = value;
              }
              return this;
          };
          d(p, "playTimes"
              ,function () {
                  return this._playTimes;
              }
          );
          d(p, "currentPlayTimes"
              ,function () {
                  return this._currentPlayTimes < 0 ? 0 : this._currentPlayTimes;
              }
          );
          d(p, "isComplete"
              ,function () {
                  return this._isComplete;
              }
          );
          d(p, "isPlaying"
              ,function () {
                  return (this._isPlaying && !this._isComplete);
              }
          );
          d(p, "totalTime"
              ,function () {
                  return this._totalTime * 0.001;
              }
          );
          d(p, "currentTime"
              ,function () {
                  return this._currentTime < 0 ? 0 : this._currentTime * 0.001;
              }
          );
          p.isUseCache = function () {
              return this._armature.enableCache && this.animationCache && !this._fading;
          };
          p.hideBones = function () {
              var length = this.animationData.hideTimelineNameMap.length;
              for (var i = 0; i < length; i++) {
                  var timelineName = this.animationData.hideTimelineNameMap[i];
                  var bone = this._armature.getBone(timelineName);
                  if (bone) {
                      bone._hideSlots();
                  }
              }
              var slotTimelineName;
              for (i = 0, length = this.animationData.hideSlotTimelineNameMap.length; i < length; i++) {
                  slotTimelineName = this.animationData.hideSlotTimelineNameMap[i];
                  var slot = this._armature.getSlot(slotTimelineName);
                  if (slot) {
                      slot._resetToOrigin();
                  }
              }
          };
          d(p, "progress"
              ,function () {
                  return this._progress;
              }
          );
          return FastAnimationState;
      })();
      dragonBones.FastAnimationState = FastAnimationState;
      egret.registerClass(FastAnimationState,'dragonBones.FastAnimationState',["dragonBones.IAnimationState"]);
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastBoneTimelineState = (function () {
          function FastBoneTimelineState() {
              this._totalTime = 0;
              this._currentTime = 0;
              this._lastTime = 0;
              this._currentFrameIndex = 0;
              this._currentFramePosition = 0;
              this._currentFrameDuration = 0;
              this._updateMode = 0;
              this._transform = new dragonBones.DBTransform();
              this._durationTransform = new dragonBones.DBTransform();
              this._transformToFadein = new dragonBones.DBTransform();
              this._pivot = new dragonBones.Point();
              this._durationPivot = new dragonBones.Point();
          }
          var d = __define,c=FastBoneTimelineState,p=c.prototype;
          FastBoneTimelineState.borrowObject = function () {
              if (FastBoneTimelineState._pool.length == 0) {
                  return new FastBoneTimelineState();
              }
              return FastBoneTimelineState._pool.pop();
          };
          FastBoneTimelineState.returnObject = function (timeline) {
              if (FastBoneTimelineState._pool.indexOf(timeline) < 0) {
                  FastBoneTimelineState._pool[FastBoneTimelineState._pool.length] = timeline;
              }
              timeline.clear();
          };
          FastBoneTimelineState.clear = function () {
              var i = FastBoneTimelineState._pool.length;
              while (i--) {
                  FastBoneTimelineState._pool[i].clear();
              }
              FastBoneTimelineState._pool.length = 0;
          };
          p.clear = function () {
              if (this._bone) {
                  this._bone._timelineState = null;
                  this._bone = null;
              }
              this._animationState = null;
              this._timelineData = null;
              this._originPivot = null;
          };
          p.fadeIn = function (bone, animationState, timelineData) {
              this._bone = bone;
              this._animationState = animationState;
              this._timelineData = timelineData;
              this.name = timelineData.name;
              this._totalTime = this._timelineData.duration;
              this._isComplete = false;
              this._tweenTransform = false;
              this._currentFrameIndex = -1;
              this._currentTime = -1;
              this._tweenEasing = NaN;
              this._durationPivot.x = 0;
              this._durationPivot.y = 0;
              this._pivot.x = 0;
              this._pivot.y = 0;
              this._originPivot = this._timelineData.originPivot;
              switch (this._timelineData.frameList.length) {
                  case 0:
                      this._updateMode = 0;
                      break;
                  case 1:
                      this._updateMode = 1;
                      break;
                  default:
                      this._updateMode = -1;
                      break;
              }
              if (animationState._fadeTotalTime > 0) {
                  var pivotToFadein;
                  if (this._bone._timelineState) {
                      this._transformToFadein.copy(this._bone._timelineState._transform);
                  }
                  else {
                      this._transformToFadein = new dragonBones.DBTransform();
                  }
                  var firstFrame = (this._timelineData.frameList[0]);
                  this._durationTransform.copy(firstFrame.transform);
                  this._durationTransform.minus(this._transformToFadein);
              }
              this._bone._timelineState = this;
          };
          p.updateFade = function (progress) {
              this._transform.x = this._transformToFadein.x + this._durationTransform.x * progress;
              this._transform.y = this._transformToFadein.y + this._durationTransform.y * progress;
              this._transform.scaleX = this._transformToFadein.scaleX * (1 + (this._durationTransform.scaleX - 1) * progress);
              this._transform.scaleY = this._transformToFadein.scaleX * (1 + (this._durationTransform.scaleY - 1) * progress);
              this._transform.rotation = this._transformToFadein.rotation + this._durationTransform.rotation * progress;
              this._bone.invalidUpdate();
          };
          p.update = function (progress) {
              if (this._updateMode == 1) {
                  this._updateMode = 0;
                  this.updateSingleFrame();
              }
              else if (this._updateMode == -1) {
                  this.updateMultipleFrame(progress);
              }
          };
          p.updateSingleFrame = function () {
              var currentFrame = (this._timelineData.frameList[0]);
              this._bone.arriveAtFrame(currentFrame, this._animationState);
              this._isComplete = true;
              this._tweenEasing = NaN;
              this._tweenTransform = false;
              this._pivot.x = this._originPivot.x + currentFrame.pivot.x;
              this._pivot.y = this._originPivot.y + currentFrame.pivot.y;
              this._transform.copy(currentFrame.transform);
              this._bone.invalidUpdate();
          };
          p.updateMultipleFrame = function (progress) {
              var currentPlayTimes = 0;
              progress /= this._timelineData.scale;
              progress += this._timelineData.offset;
              var currentTime = this._totalTime * progress;
              var playTimes = this._animationState.playTimes;
              if (playTimes == 0) {
                  this._isComplete = false;
                  currentPlayTimes = Math.ceil(Math.abs(currentTime) / this._totalTime) || 1;
                  currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  if (currentTime < 0) {
                      currentTime += this._totalTime;
                  }
              }
              else {
                  var totalTimes = playTimes * this._totalTime;
                  if (currentTime >= totalTimes) {
                      currentTime = totalTimes;
                      this._isComplete = true;
                  }
                  else if (currentTime <= -totalTimes) {
                      currentTime = -totalTimes;
                      this._isComplete = true;
                  }
                  else {
                      this._isComplete = false;
                  }
                  if (currentTime < 0) {
                      currentTime += totalTimes;
                  }
                  currentPlayTimes = Math.ceil(currentTime / this._totalTime) || 1;
                  if (this._isComplete) {
                      currentTime = this._totalTime;
                  }
                  else {
                      currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  }
              }
              if (this._currentTime != currentTime) {
                  this._lastTime = this._currentTime;
                  this._currentTime = currentTime;
                  var frameList = this._timelineData.frameList;
                  var prevFrame;
                  var currentFrame;
                  for (var i = 0, l = this._timelineData.frameList.length; i < l; ++i) {
                      if (this._currentFrameIndex < 0) {
                          this._currentFrameIndex = 0;
                      }
                      else if (this._currentTime < this._currentFramePosition || this._currentTime >= this._currentFramePosition + this._currentFrameDuration || this._currentTime < this._lastTime) {
                          this._currentFrameIndex++;
                          this._lastTime = this._currentTime;
                          if (this._currentFrameIndex >= frameList.length) {
                              if (this._isComplete) {
                                  this._currentFrameIndex--;
                                  break;
                              }
                              else {
                                  this._currentFrameIndex = 0;
                              }
                          }
                      }
                      else {
                          break;
                      }
                      currentFrame = (frameList[this._currentFrameIndex]);
                      if (prevFrame) {
                          this._bone.arriveAtFrame(prevFrame, this._animationState);
                      }
                      this._currentFrameDuration = currentFrame.duration;
                      this._currentFramePosition = currentFrame.position;
                      prevFrame = currentFrame;
                  }
                  if (currentFrame) {
                      this._bone.arriveAtFrame(currentFrame, this._animationState);
                      this.updateToNextFrame(currentPlayTimes);
                  }
                  if (this._tweenTransform) {
                      this.updateTween();
                  }
              }
          };
          p.updateToNextFrame = function (currentPlayTimes) {
              if (currentPlayTimes === void 0) { currentPlayTimes = 0; }
              var nextFrameIndex = this._currentFrameIndex + 1;
              if (nextFrameIndex >= this._timelineData.frameList.length) {
                  nextFrameIndex = 0;
              }
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              var nextFrame = (this._timelineData.frameList[nextFrameIndex]);
              var tweenEnabled = false;
              if (nextFrameIndex == 0 && (this._animationState.playTimes &&
                  this._animationState.currentPlayTimes >= this._animationState.playTimes &&
                  ((this._currentFramePosition + this._currentFrameDuration) / this._totalTime + currentPlayTimes - this._timelineData.offset) * this._timelineData.scale > 0.999999)) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (this._animationState.autoTween) {
                  this._tweenEasing = this._animationState.animationData.tweenEasing;
                  if (isNaN(this._tweenEasing)) {
                      this._tweenEasing = currentFrame.tweenEasing;
                      this._tweenCurve = currentFrame.curve;
                      if (isNaN(this._tweenEasing) && this._tweenCurve == null) {
                          tweenEnabled = false;
                      }
                      else {
                          if (this._tweenEasing == 10) {
                              this._tweenEasing = 0;
                          }
                          tweenEnabled = true;
                      }
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              else {
                  this._tweenEasing = currentFrame.tweenEasing;
                  this._tweenCurve = currentFrame.curve;
                  if ((isNaN(this._tweenEasing) || this._tweenEasing == 10) && this._tweenCurve == null) {
                      this._tweenEasing = NaN;
                      tweenEnabled = false;
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              if (tweenEnabled) {
                  this._durationTransform.x = nextFrame.transform.x - currentFrame.transform.x;
                  this._durationTransform.y = nextFrame.transform.y - currentFrame.transform.y;
                  this._durationTransform.skewX = nextFrame.transform.skewX - currentFrame.transform.skewX;
                  this._durationTransform.skewY = nextFrame.transform.skewY - currentFrame.transform.skewY;
                  this._durationTransform.scaleX = nextFrame.transform.scaleX - currentFrame.transform.scaleX + nextFrame.scaleOffset.x;
                  this._durationTransform.scaleY = nextFrame.transform.scaleY - currentFrame.transform.scaleY + nextFrame.scaleOffset.y;
                  this._durationPivot.x = nextFrame.pivot.x - currentFrame.pivot.x;
                  this._durationPivot.y = nextFrame.pivot.y - currentFrame.pivot.y;
                  this._durationTransform.normalizeRotation();
                  if (nextFrameIndex == 0) {
                      this._durationTransform.skewX = dragonBones.TransformUtil.formatRadian(this._durationTransform.skewX);
                      this._durationTransform.skewY = dragonBones.TransformUtil.formatRadian(this._durationTransform.skewY);
                  }
                  if (this._durationTransform.x ||
                      this._durationTransform.y ||
                      this._durationTransform.skewX ||
                      this._durationTransform.skewY ||
                      this._durationTransform.scaleX != 1 ||
                      this._durationTransform.scaleY != 1 ||
                      this._durationPivot.x ||
                      this._durationPivot.y) {
                      this._tweenTransform = true;
                  }
                  else {
                      this._tweenTransform = false;
                  }
              }
              else {
                  this._tweenTransform = false;
              }
              if (!this._tweenTransform) {
                  this._transform.copy(currentFrame.transform);
                  this._pivot.x = this._originPivot.x + currentFrame.pivot.x;
                  this._pivot.y = this._originPivot.y + currentFrame.pivot.y;
                  this._bone.invalidUpdate();
              }
          };
          p.updateTween = function () {
              var progress = (this._currentTime - this._currentFramePosition) / this._currentFrameDuration;
              if (this._tweenCurve) {
                  progress = this._tweenCurve.getValueByProgress(progress);
              }
              else if (this._tweenEasing) {
                  progress = dragonBones.MathUtil.getEaseValue(progress, this._tweenEasing);
              }
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              var currentTransform = currentFrame.transform;
              var currentPivot = currentFrame.pivot;
              this._transform.x = currentTransform.x + this._durationTransform.x * progress;
              this._transform.y = currentTransform.y + this._durationTransform.y * progress;
              this._transform.skewX = currentTransform.skewX + this._durationTransform.skewX * progress;
              this._transform.skewY = currentTransform.skewY + this._durationTransform.skewY * progress;
              this._transform.scaleX = currentTransform.scaleX + this._durationTransform.scaleX * progress;
              this._transform.scaleY = currentTransform.scaleY + this._durationTransform.scaleY * progress;
              this._pivot.x = currentPivot.x + this._durationPivot.x * progress;
              this._pivot.y = currentPivot.y + this._durationPivot.y * progress;
              this._bone.invalidUpdate();
          };
          FastBoneTimelineState._pool = [];
          return FastBoneTimelineState;
      })();
      dragonBones.FastBoneTimelineState = FastBoneTimelineState;
      egret.registerClass(FastBoneTimelineState,'dragonBones.FastBoneTimelineState');
  })(dragonBones || (dragonBones = {}));
  var dragonBones;
  (function (dragonBones) {
      var FastSlotTimelineState = (function () {
          function FastSlotTimelineState() {
              this._totalTime = 0;
              this._currentTime = 0;
              this._currentFrameIndex = 0;
              this._currentFramePosition = 0;
              this._currentFrameDuration = 0;
              this._updateMode = 0;
              this._durationColor = new dragonBones.ColorTransform();
          }
          var d = __define,c=FastSlotTimelineState,p=c.prototype;
          FastSlotTimelineState.borrowObject = function () {
              if (FastSlotTimelineState._pool.length == 0) {
                  return new FastSlotTimelineState();
              }
              return FastSlotTimelineState._pool.pop();
          };
          FastSlotTimelineState.returnObject = function (timeline) {
              if (FastSlotTimelineState._pool.indexOf(timeline) < 0) {
                  FastSlotTimelineState._pool[FastSlotTimelineState._pool.length] = timeline;
              }
              timeline.clear();
          };
          FastSlotTimelineState.clear = function () {
              var i = FastSlotTimelineState._pool.length;
              while (i--) {
                  FastSlotTimelineState._pool[i].clear();
              }
              FastSlotTimelineState._pool.length = 0;
          };
          p.clear = function () {
              this._slot = null;
              this._armature = null;
              this._animation = null;
              this._animationState = null;
              this._timelineData = null;
          };
          p.fadeIn = function (slot, animationState, timelineData) {
              this._slot = slot;
              this._armature = this._slot.armature;
              this._animation = this._armature.animation;
              this._animationState = animationState;
              this._timelineData = timelineData;
              this.name = timelineData.name;
              this._totalTime = this._timelineData.duration;
              this._isComplete = false;
              this._blendEnabled = false;
              this._tweenColor = false;
              this._currentFrameIndex = -1;
              this._currentTime = -1;
              this._tweenEasing = NaN;
              this._weight = 1;
              switch (this._timelineData.frameList.length) {
                  case 0:
                      this._updateMode = 0;
                      break;
                  case 1:
                      this._updateMode = 1;
                      break;
                  default:
                      this._updateMode = -1;
                      break;
              }
          };
          p.updateFade = function (progress) {
          };
          p.update = function (progress) {
              if (this._updateMode == -1) {
                  this.updateMultipleFrame(progress);
              }
              else if (this._updateMode == 1) {
                  this._updateMode = 0;
                  this.updateSingleFrame();
              }
          };
          p.updateMultipleFrame = function (progress) {
              var currentPlayTimes = 0;
              progress /= this._timelineData.scale;
              progress += this._timelineData.offset;
              var currentTime = this._totalTime * progress;
              var playTimes = this._animationState.playTimes;
              if (playTimes == 0) {
                  this._isComplete = false;
                  currentPlayTimes = Math.ceil(Math.abs(currentTime) / this._totalTime) || 1;
                  currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  if (currentTime < 0) {
                      currentTime += this._totalTime;
                  }
              }
              else {
                  var totalTimes = playTimes * this._totalTime;
                  if (currentTime >= totalTimes) {
                      currentTime = totalTimes;
                      this._isComplete = true;
                  }
                  else if (currentTime <= -totalTimes) {
                      currentTime = -totalTimes;
                      this._isComplete = true;
                  }
                  else {
                      this._isComplete = false;
                  }
                  if (currentTime < 0) {
                      currentTime += totalTimes;
                  }
                  currentPlayTimes = Math.ceil(currentTime / this._totalTime) || 1;
                  if (this._isComplete) {
                      currentTime = this._totalTime;
                  }
                  else {
                      currentTime -= Math.floor(currentTime / this._totalTime) * this._totalTime;
                  }
              }
              if (this._currentTime != currentTime) {
                  this._currentTime = currentTime;
                  var frameList = this._timelineData.frameList;
                  var prevFrame;
                  var currentFrame;
                  for (var i = 0, l = this._timelineData.frameList.length; i < l; ++i) {
                      if (this._currentFrameIndex < 0) {
                          this._currentFrameIndex = 0;
                      }
                      else if (this._currentTime < this._currentFramePosition || this._currentTime >= this._currentFramePosition + this._currentFrameDuration) {
                          this._currentFrameIndex++;
                          if (this._currentFrameIndex >= frameList.length) {
                              if (this._isComplete) {
                                  this._currentFrameIndex--;
                                  break;
                              }
                              else {
                                  this._currentFrameIndex = 0;
                              }
                          }
                      }
                      else {
                          break;
                      }
                      currentFrame = (frameList[this._currentFrameIndex]);
                      if (prevFrame) {
                          this._slot._arriveAtFrame(prevFrame, this._animationState);
                      }
                      this._currentFrameDuration = currentFrame.duration;
                      this._currentFramePosition = currentFrame.position;
                      prevFrame = currentFrame;
                  }
                  if (currentFrame) {
                      this._slot._arriveAtFrame(currentFrame, this._animationState);
                      this._blendEnabled = currentFrame.displayIndex >= 0;
                      if (this._blendEnabled) {
                          this.updateToNextFrame(currentPlayTimes);
                      }
                      else {
                          this._tweenEasing = NaN;
                          this._tweenColor = false;
                      }
                  }
                  if (this._blendEnabled) {
                      this.updateTween();
                  }
              }
          };
          p.updateToNextFrame = function (currentPlayTimes) {
              if (currentPlayTimes === void 0) { currentPlayTimes = 0; }
              var nextFrameIndex = this._currentFrameIndex + 1;
              if (nextFrameIndex >= this._timelineData.frameList.length) {
                  nextFrameIndex = 0;
              }
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              var nextFrame = (this._timelineData.frameList[nextFrameIndex]);
              var tweenEnabled = false;
              if (nextFrameIndex == 0 &&
                  (this._animationState.playTimes &&
                      this._animationState.currentPlayTimes >= this._animationState.playTimes &&
                      ((this._currentFramePosition + this._currentFrameDuration) / this._totalTime + currentPlayTimes - this._timelineData.offset) * this._timelineData.scale > 0.999999)) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (currentFrame.displayIndex < 0 || nextFrame.displayIndex < 0) {
                  this._tweenEasing = NaN;
                  tweenEnabled = false;
              }
              else if (this._animationState.autoTween) {
                  this._tweenEasing = this._animationState.animationData.tweenEasing;
                  if (isNaN(this._tweenEasing)) {
                      this._tweenEasing = currentFrame.tweenEasing;
                      this._tweenCurve = currentFrame.curve;
                      if (isNaN(this._tweenEasing) && this._tweenCurve == null) {
                          tweenEnabled = false;
                      }
                      else {
                          if (this._tweenEasing == 10) {
                              this._tweenEasing = 0;
                          }
                          tweenEnabled = true;
                      }
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              else {
                  this._tweenEasing = currentFrame.tweenEasing;
                  this._tweenCurve = currentFrame.curve;
                  if ((isNaN(this._tweenEasing) || this._tweenEasing == 10) && this._tweenCurve == null) {
                      this._tweenEasing = NaN;
                      tweenEnabled = false;
                  }
                  else {
                      tweenEnabled = true;
                  }
              }
              if (tweenEnabled) {
                  if (currentFrame.color || nextFrame.color) {
                      dragonBones.ColorTransformUtil.minus(nextFrame.color || dragonBones.ColorTransformUtil.originalColor, currentFrame.color || dragonBones.ColorTransformUtil.originalColor, this._durationColor);
                      this._tweenColor = this._durationColor.alphaOffset != 0 ||
                          this._durationColor.redOffset != 0 ||
                          this._durationColor.greenOffset != 0 ||
                          this._durationColor.blueOffset != 0 ||
                          this._durationColor.alphaMultiplier != 0 ||
                          this._durationColor.redMultiplier != 0 ||
                          this._durationColor.greenMultiplier != 0 ||
                          this._durationColor.blueMultiplier != 0;
                  }
                  else {
                      this._tweenColor = false;
                  }
              }
              else {
                  this._tweenColor = false;
              }
              if (!this._tweenColor) {
                  var targetColor;
                  var colorChanged;
                  if (currentFrame.color) {
                      targetColor = currentFrame.color;
                      colorChanged = true;
                  }
                  else {
                      targetColor = dragonBones.ColorTransformUtil.originalColor;
                      colorChanged = false;
                  }
                  if ((this._slot._isColorChanged || colorChanged)) {
                      if (!dragonBones.ColorTransformUtil.isEqual(this._slot._colorTransform, targetColor)) {
                          this._slot._updateDisplayColor(targetColor.alphaOffset, targetColor.redOffset, targetColor.greenOffset, targetColor.blueOffset, targetColor.alphaMultiplier, targetColor.redMultiplier, targetColor.greenMultiplier, targetColor.blueMultiplier, colorChanged);
                      }
                  }
              }
          };
          p.updateTween = function () {
              var currentFrame = (this._timelineData.frameList[this._currentFrameIndex]);
              if (this._tweenColor) {
                  var progress = (this._currentTime - this._currentFramePosition) / this._currentFrameDuration;
                  if (this._tweenCurve != null) {
                      progress = this._tweenCurve.getValueByProgress(progress);
                  }
                  else if (this._tweenEasing) {
                      progress = dragonBones.MathUtil.getEaseValue(progress, this._tweenEasing);
                  }
                  if (currentFrame.color) {
                      this._slot._updateDisplayColor(currentFrame.color.alphaOffset + this._durationColor.alphaOffset * progress, currentFrame.color.redOffset + this._durationColor.redOffset * progress, currentFrame.color.greenOffset + this._durationColor.greenOffset * progress, currentFrame.color.blueOffset + this._durationColor.blueOffset * progress, currentFrame.color.alphaMultiplier + this._durationColor.alphaMultiplier * progress, currentFrame.color.redMultiplier + this._durationColor.redMultiplier * progress, currentFrame.color.greenMultiplier + this._durationColor.greenMultiplier * progress, currentFrame.color.blueMultiplier + this._durationColor.blueMultiplier * progress, true);
                  }
                  else {
                      this._slot._updateDisplayColor(this._durationColor.alphaOffset * progress, this._durationColor.redOffset * progress, this._durationColor.greenOffset * progress, this._durationColor.blueOffset * progress, this._durationColor.alphaMultiplier * progress + 1, this._durationColor.redMultiplier * progress + 1, this._durationColor.greenMultiplier * progress + 1, this._durationColor.blueMultiplier * progress + 1, true);
                  }
              }
          };
          p.updateSingleFrame = function () {
              var currentFrame = (this._timelineData.frameList[0]);
              this._slot._arriveAtFrame(currentFrame, this._animationState);
              this._isComplete = true;
              this._tweenEasing = NaN;
              this._tweenColor = false;
              this._blendEnabled = currentFrame.displayIndex >= 0;
              if (this._blendEnabled) {
                  var targetColor;
                  var colorChanged;
                  if (currentFrame.color) {
                      targetColor = currentFrame.color;
                      colorChanged = true;
                  }
                  else {
                      targetColor = dragonBones.ColorTransformUtil.originalColor;
                      colorChanged = false;
                  }
                  if ((this._slot._isColorChanged || colorChanged)) {
                      if (!dragonBones.ColorTransformUtil.isEqual(this._slot._colorTransform, targetColor)) {
                          this._slot._updateDisplayColor(targetColor.alphaOffset, targetColor.redOffset, targetColor.greenOffset, targetColor.blueOffset, targetColor.alphaMultiplier, targetColor.redMultiplier, targetColor.greenMultiplier, targetColor.blueMultiplier, colorChanged);
                      }
                  }
              }
          };
          FastSlotTimelineState.HALF_PI = Math.PI * 0.5;
          FastSlotTimelineState.DOUBLE_PI = Math.PI * 2;
          FastSlotTimelineState._pool = [];
          return FastSlotTimelineState;
      })();
      dragonBones.FastSlotTimelineState = FastSlotTimelineState;
      egret.registerClass(FastSlotTimelineState,'dragonBones.FastSlotTimelineState');
  })(dragonBones || (dragonBones = {}));
  
  (function(){
      var DataParser = dragonBones.DataParser;
      var TextureData = dragonBones.TextureData;
  
      var TextureAtlas = function(texture, textureAtlasRawData, scale){
          this._textureDatas = {};
          this.scale = scale||1;
          this.texture = texture;
          this.name = textureAtlasRawData.name;
  
          this.parseData(textureAtlasRawData);
      };
  
      TextureAtlas.rotatedDic = {};
  
      TextureAtlas.prototype = {
          constructor:TextureAtlas,
          getTexture:function(fullName){
              var data = this._textureDatas[fullName];
              if(data){
                  data.texture = this.texture;
                  if(data.rotated)
                  {
                      TextureAtlas.rotatedDic[fullName] = 1;
                  }
              }
              return data;
          },
          dispose:function(){
              this.texture = null;
              this._textureDatas = {};
          },
          getRegion:function(subTextureName){
              var textureData = this._textureDatas[subTextureName];
              if(textureData && textureData instanceof TextureData){
                  return textureData.region;
              }
              return null;
          },
          getFrame:function(subTextureName){
              var textureData = this._textureDatas[subTextureName];
              if(textureData && textureData instanceof TextureData)
              {
                  return textureData.frame;
              }
              return null;
          },
          parseData:function(textureAtlasRawData){
              this._textureDatas = DataParser.parseTextureAtlasData(textureAtlasRawData, this.scale);
          }
      };
      dragonBones.TextureAtlas = TextureAtlas;
  })();
  /**
   * CreatejsSlot
   */
  (function(superClass) {
      var RAD2DEG = 180/Math.PI;
      var TextureAtlas = dragonBones.TextureAtlas;
      var CreatejsSlot = function() {
          superClass.call(this, this);
          this._display = null;
      };
  
      __extends(CreatejsSlot, superClass, {
          dispose: function() {
              if (this._displayList) {
                  var length = this._displayList.length;
                  for (var i = 0; i < length; i++) {
                      var content = this._displayList[i];
                      if (content instanceof Armature) {
                          content.dispose();
                      }
                  }
              }
  
              superClass.prototype.dispose();
              this._display = null;
          },
          _updateDisplay: function(value) {
              this._display = value;
          },
          _getDisplayIndex: function() {
              if (this._display && this._display.parent) {
                  return this._display.parent.getChildIndex(this._display);
              }
              return -1;
          },
          _addDisplayToContainer: function(container, index) {
              if (this._display && container) {
                  if(index){
                      container.addChildAt(this._display, index);
                  }
                  else{
                      container.addChild(this._display);
                  }
              }
          },
          _removeDisplayFromContainer: function() {
              if (this._display && this._display.parent) {
                  this._display.parent.removeChild(this._display);
              }
          },
          _updateTransform: function() {
              if (this._display) {
                  this._display.x = this._global.x;
                  this._display.y = this._global.y;
                  this._display.scaleX = this._global.scaleX;
                  this._display.scaleY = this._global.scaleY;
                  this._display.rotation = this._global.skewX * RAD2DEG;
              }
          },
          _updateDisplayVisible: function(value) {
              if (this._display && this._parent) {
                  this._display.visible = this._parent._visible && this._visible && value;
              }
          },
          _updateDisplayColor: function(aOffset, rOffset, gOffset, bOffset, aMultiplier, rMultiplier, gMultiplier, bMultiplier, colorChange) {
              superClass.prototype._updateDisplayColor.call(this, aOffset, rOffset, gOffset, bOffset, aMultiplier, rMultiplier, gMultiplier, bMultiplier, colorChange);
              if (this._display) {
                  this._display.alpha = aMultiplier;
              }
          },
          _updateDisplayBlendMode: function(value) {
              // if (this._display && value) {
              //     this._display.blendMode = value;
              // }
          },
          _calculateRelativeParentTransform: function() {
              this._global.scaleX = this._origin.scaleX * this._offset.scaleX;
              this._global.scaleY = this._origin.scaleY * this._offset.scaleY;
              this._global.skewX = this._origin.skewX + this._offset.skewX;
              this._global.skewY = this._origin.skewY + this._offset.skewY;
              this._global.x = this._origin.x + this._offset.x + this._parent._tweenPivot.x;
              this._global.y = this._origin.y + this._offset.y + this._parent._tweenPivot.y;
  
              if (this._displayDataList &&
                  this._currentDisplayIndex >= 0 &&
                  this._displayDataList[this._currentDisplayIndex] &&
                  TextureAtlas.rotatedDic[this._displayDataList[this._currentDisplayIndex].name] == 1) {
                  this._global.skewX -= 1.57;
                  this._global.skewY -= 1.57;
              }
          }
      });
  
      dragonBones.CreatejsSlot = CreatejsSlot;
  })(dragonBones.Slot);
  
  /**
   * CreatejsFactory
   */
  (function(superClass){
      var Armature = dragonBones.Armature;
      var CreatejsSlot = dragonBones.CreatejsSlot;
  
      var CreatejsFactory = function(){
          superClass.call(this, this);
      };
      __extends(CreatejsFactory, superClass, {
          _generateArmature:function(){
              var armature = new Armature(new createjs.Container);
              return armature;
          },
          _generateSlot:function(){
              var slot = new CreatejsSlot();
              return slot;
          },
          _generateDisplay:function(textureAtlas, fullName, pivotX, pivotY){
              var texture = textureAtlas.getTexture(fullName);
              var region = texture.region;
  
              var bitmap = new createjs.Bitmap(textureAtlas.texture);
              bitmap.sourceRect = new createjs.Rectangle(region.x, region.y, region.width, region.height);
  
              if(isNaN(pivotX)||isNaN(pivotY))
              {
                  var subTextureFrame = textureAtlas.getFrame(fullName);
                  if(subTextureFrame != null)
                  {
                      pivotX = (subTextureFrame.width/2)+subTextureFrame.x;
                      pivotY = (subTextureFrame.height/2)+subTextureFrame.y;
                  }
                  else
                  {
                      pivotX = texture.region.width/2;
                      pivotY = texture.region.height/2;
                  }
              }
              bitmap.regX = pivotX;
              bitmap.regY = pivotY;
              return bitmap;
          }
      });
  
      dragonBones.CreatejsFactory = CreatejsFactory;
  }(dragonBones.BaseFactory));
  