@eva/eva.js 1.2.7-editor.9 → 1.2.8-alpha.0

package/dist/miniprogram.js

@@ -0,0 +1,3683 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import { __extends as __extends$1, __spread, __values, __decorate, __awaiter, __generator } from 'tslib';
+import EventEmitter from 'eventemitter3';
+import { isEqual, isObject } from 'lodash-es';
+import { type, step } from '@eva/inspector-decorator';
+import { requestAnimationFrame, windowAlias, navigator, documentAlias, XMLHttpRequestAlias } from '@eva/miniprogram-adapter';
+
+function getComponentName(component) {
+  if (component instanceof Component) {
+    return component.name;
+  } else if (component instanceof Function) {
+    return component.componentName;
+  }
+}
+
+var Component = function (_super) {
+  __extends$1(Component, _super);
+
+  function Component(params) {
+    var _this = _super.call(this) || this;
+
+    _this.started = false;
+    _this.name = _this.constructor.componentName;
+    _this.__componentDefaultParams = params;
+    return _this;
+  }
+
+  return Component;
+}(EventEmitter);
+
+var Component$1 = Component;
+var ObserverType;
+
+(function (ObserverType) {
+  ObserverType["ADD"] = "ADD";
+  ObserverType["REMOVE"] = "REMOVE";
+  ObserverType["CHANGE"] = "CHANGE";
+})(ObserverType || (ObserverType = {}));
+
+var objectCache = {};
+var systemInstance = {};
+var observerInfos = {};
+var componentProps = {};
+
+function getObjectCache(component, keys) {
+  if (!objectCache[component.gameObject.id]) {
+    objectCache[component.gameObject.id] = {};
+  }
+
+  var cache = objectCache[component.gameObject.id];
+  var key = component.name + '_' + keys.join(',');
+
+  if (cache[key]) {
+    return cache[key];
+  }
+
+  var keyIndex = keys.length - 1;
+  var property = component;
+
+  for (var i = 0; i < keyIndex; i++) {
+    property = property[keys[i]];
+  }
+
+  cache[key] = {
+    property: property,
+    key: keys[keyIndex]
+  };
+  return cache[key];
+}
+
+function removeObjectCache(component) {
+  if (component.gameObject) {
+    delete objectCache[component.gameObject.id];
+  }
+}
+
+function addObserver(_a) {
+  var _b, _c;
+
+  var systemName = _a.systemName,
+      componentName = _a.componentName,
+      component = _a.component,
+      prop = _a.prop,
+      type = _a.type;
+  (_c = (_b = systemInstance[systemName]) === null || _b === void 0 ? void 0 : _b.componentObserver) === null || _c === void 0 ? void 0 : _c.add({
+    component: component,
+    prop: prop,
+    type: type,
+    componentName: componentName
+  });
+}
+
+function pushToQueue(_a) {
+  var prop = _a.prop,
+      component = _a.component,
+      componentName = _a.componentName;
+
+  for (var systemName in observerInfos) {
+    var observerInfo = observerInfos[systemName] || {};
+    var info = observerInfo[componentName];
+    if (!info) continue;
+    var index = info.findIndex(function (p) {
+      return isEqual(p, prop);
+    });
+
+    if (index > -1) {
+      addObserver({
+        systemName: systemName,
+        componentName: componentName,
+        component: component,
+        prop: prop,
+        type: ObserverType.CHANGE
+      });
+    }
+  }
+}
+
+function defineProperty(_a) {
+  var e_1, _b;
+
+  var obj = _a.obj,
+      key = _a.key,
+      prop = _a.prop,
+      component = _a.component,
+      componentName = _a.componentName;
+
+  if (obj === undefined) {
+    return;
+  }
+
+  if (!(key in obj)) {
+    console.error("prop " + key + " not in component: " + componentName + ", Can not observer");
+    return;
+  }
+
+  Object.defineProperty(obj, "_" + key, {
+    enumerable: false,
+    writable: true,
+    value: obj[key]
+  });
+
+  if (prop.deep && isObject(obj[key])) {
+    try {
+      for (var _c = __values(Object.keys(obj[key])), _d = _c.next(); !_d.done; _d = _c.next()) {
+        var childKey = _d.value;
+        defineProperty({
+          obj: obj[key],
+          key: childKey,
+          prop: prop,
+          component: component,
+          componentName: componentName
+        });
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+  }
+
+  Object.defineProperty(obj, key, {
+    enumerable: true,
+    set: function set(val) {
+      if (obj["_" + key] === val) return;
+      obj["_" + key] = val;
+      pushToQueue({
+        prop: prop,
+        component: component,
+        componentName: componentName
+      });
+    },
+    get: function get() {
+      return obj["_" + key];
+    }
+  });
+}
+
+function isComponent(comp) {
+  return comp && comp.constructor && 'componentName' in comp.constructor;
+}
+
+function initObserver(Systems) {
+  var e_2, _a, e_3, _b;
+
+  var Ss = [];
+
+  if (Systems instanceof Array) {
+    Ss.push.apply(Ss, __spread(Systems));
+  } else {
+    Ss.push(Systems);
+  }
+
+  try {
+    for (var Ss_1 = __values(Ss), Ss_1_1 = Ss_1.next(); !Ss_1_1.done; Ss_1_1 = Ss_1.next()) {
+      var S = Ss_1_1.value;
+
+      for (var componentName in S.observerInfo) {
+        componentProps[componentName] = componentProps[componentName] || [];
+        var props = componentProps[componentName];
+
+        var _loop_1 = function _loop_1(prop) {
+          var index = props.findIndex(function (p) {
+            return isEqual(p, prop);
+          });
+
+          if (index === -1) {
+            componentProps[componentName].push(prop);
+          }
+        };
+
+        try {
+          for (var _c = (e_3 = void 0, __values(S.observerInfo[componentName])), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var prop = _d.value;
+
+            _loop_1(prop);
+          }
+        } catch (e_3_1) {
+          e_3 = {
+            error: e_3_1
+          };
+        } finally {
+          try {
+            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+          } finally {
+            if (e_3) throw e_3.error;
+          }
+        }
+      }
+    }
+  } catch (e_2_1) {
+    e_2 = {
+      error: e_2_1
+    };
+  } finally {
+    try {
+      if (Ss_1_1 && !Ss_1_1.done && (_a = Ss_1.return)) _a.call(Ss_1);
+    } finally {
+      if (e_2) throw e_2.error;
+    }
+  }
+}
+
+function observer(component, componentName) {
+  var e_4, _a;
+
+  if (componentName === void 0) {
+    componentName = component.name;
+  }
+
+  if (!componentName || !componentProps[componentName]) {
+    return;
+  }
+
+  if (!component || !isComponent(component)) {
+    throw new Error('component param must be an instance of Component');
+  }
+
+  if (!component.gameObject || !component.gameObject.id) {
+    throw new Error('component should be add to a gameObject');
+  }
+
+  try {
+    for (var _b = __values(componentProps[componentName]), _c = _b.next(); !_c.done; _c = _b.next()) {
+      var item = _c.value;
+
+      var _d = getObjectCache(component, item.prop),
+          property = _d.property,
+          key = _d.key;
+
+      defineProperty({
+        obj: property,
+        key: key,
+        prop: item,
+        component: component,
+        componentName: componentName
+      });
+    }
+  } catch (e_4_1) {
+    e_4 = {
+      error: e_4_1
+    };
+  } finally {
+    try {
+      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    } finally {
+      if (e_4) throw e_4.error;
+    }
+  }
+}
+
+function observerAdded(component, componentName) {
+  var _a, _b;
+
+  if (componentName === void 0) {
+    componentName = component.name;
+  }
+
+  for (var systemName in observerInfos) {
+    var observerInfo = observerInfos[systemName] || {};
+    var info = observerInfo[componentName];
+
+    if (info) {
+      (_b = (_a = systemInstance[systemName]) === null || _a === void 0 ? void 0 : _a.componentObserver) === null || _b === void 0 ? void 0 : _b.add({
+        component: component,
+        type: ObserverType.ADD,
+        componentName: componentName
+      });
+    }
+  }
+}
+
+function observerRemoved(component, componentName) {
+  var _a, _b;
+
+  if (componentName === void 0) {
+    componentName = component.name;
+  }
+
+  for (var systemName in observerInfos) {
+    var observerInfo = observerInfos[systemName] || {};
+    var info = observerInfo[componentName];
+
+    if (info) {
+      (_b = (_a = systemInstance[systemName]) === null || _a === void 0 ? void 0 : _a.componentObserver) === null || _b === void 0 ? void 0 : _b.add({
+        component: component,
+        type: ObserverType.REMOVE,
+        componentName: componentName
+      });
+    }
+  }
+
+  removeObjectCache(component);
+}
+
+function setSystemObserver(system, S) {
+  observerInfos[S.systemName] = S.observerInfo;
+  systemInstance[S.systemName] = system;
+}
+
+var Transform = function (_super) {
+  __extends$1(Transform, _super);
+
+  function Transform() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+
+    _this.name = 'Transform';
+    _this._parent = null;
+    _this.inScene = false;
+    _this.children = [];
+    _this.position = {
+      x: 0,
+      y: 0
+    };
+    _this.size = {
+      width: 0,
+      height: 0
+    };
+    _this.origin = {
+      x: 0,
+      y: 0
+    };
+    _this.anchor = {
+      x: 0,
+      y: 0
+    };
+    _this.scale = {
+      x: 1,
+      y: 1
+    };
+    _this.skew = {
+      x: 0,
+      y: 0
+    };
+    _this.rotation = 0;
+    return _this;
+  }
+
+  Transform.prototype.init = function (params) {
+    var e_1, _a;
+
+    if (params === void 0) {
+      params = {};
+    }
+
+    var props = ['position', 'size', 'origin', 'anchor', 'scale', 'skew'];
+
+    try {
+      for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
+        var key = props_1_1.value;
+
+        _extends(this[key], params[key]);
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+
+    this.rotation = params.rotation || this.rotation;
+  };
+
+  Object.defineProperty(Transform.prototype, "parent", {
+    get: function get() {
+      return this._parent;
+    },
+    set: function set(val) {
+      if (val) {
+        val.addChild(this);
+      } else if (this.parent) {
+        this.parent.removeChild(this);
+      }
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  Transform.prototype.addChild = function (child) {
+    if (child.parent === this) {
+      var index = this.children.findIndex(function (item) {
+        return item === child;
+      });
+      this.children.splice(index, 1);
+    } else if (child.parent) {
+      child.parent.removeChild(child);
+    }
+
+    child._parent = this;
+    this.children.push(child);
+  };
+
+  Transform.prototype.removeChild = function (child) {
+    var index = this.children.findIndex(function (item) {
+      return item === child;
+    });
+
+    if (index > -1) {
+      this.children.splice(index, 1);
+      child._parent = null;
+    }
+  };
+
+  Transform.prototype.clearChildren = function () {
+    this.children.length = 0;
+  };
+
+  Transform.componentName = 'Transform';
+
+  __decorate([type('vector2'), step(1)], Transform.prototype, "position", void 0);
+
+  __decorate([type('size'), step(1)], Transform.prototype, "size", void 0);
+
+  __decorate([type('vector2'), step(0.1)], Transform.prototype, "origin", void 0);
+
+  __decorate([type('vector2'), step(0.1)], Transform.prototype, "anchor", void 0);
+
+  __decorate([type('vector2'), step(0.1)], Transform.prototype, "scale", void 0);
+
+  __decorate([type('vector2'), step(0.1)], Transform.prototype, "skew", void 0);
+
+  __decorate([type('number'), step(0.1)], Transform.prototype, "rotation", void 0);
+
+  return Transform;
+}(Component$1);
+
+var Transform$1 = Transform;
+var _id = 0;
+
+function getId() {
+  return ++_id;
+}
+
+var GameObject = function () {
+  function GameObject(name, obj) {
+    this._componentCache = {};
+    this.components = [];
+    this.destroyed = false;
+    this._name = name;
+    this.id = getId();
+    this.addComponent(Transform$1, obj);
+  }
+
+  Object.defineProperty(GameObject.prototype, "transform", {
+    get: function get() {
+      return this.getComponent(Transform$1);
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(GameObject.prototype, "parent", {
+    get: function get() {
+      return this.transform && this.transform.parent && this.transform.parent.gameObject;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(GameObject.prototype, "name", {
+    get: function get() {
+      return this._name;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(GameObject.prototype, "scene", {
+    get: function get() {
+      return this._scene;
+    },
+    set: function set(val) {
+      var e_1, _a;
+
+      if (this._scene === val) return;
+      var scene = this._scene;
+      this._scene = val;
+
+      if (this.transform && this.transform.children) {
+        try {
+          for (var _b = __values(this.transform.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            child.gameObject.scene = val;
+          }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+
+      if (val) {
+        val.addGameObject(this);
+      } else {
+        scene && scene.removeGameObject(this);
+      }
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  GameObject.prototype.addChild = function (gameObject) {
+    if (!gameObject || !gameObject.transform || gameObject === this) return;
+
+    if (!(gameObject instanceof GameObject)) {
+      throw new Error('addChild only receive GameObject');
+    }
+
+    if (!this.transform) {
+      throw new Error("gameObject '" + this.name + "' has been destroy");
+    }
+
+    gameObject.transform.parent = this.transform;
+    gameObject.scene = this.scene;
+  };
+
+  GameObject.prototype.removeChild = function (gameObject) {
+    if (!(gameObject instanceof GameObject) || !gameObject.parent || gameObject.parent !== this) {
+      return gameObject;
+    }
+
+    gameObject.transform.parent = null;
+    gameObject.scene = null;
+    return gameObject;
+  };
+
+  GameObject.prototype.addComponent = function (C, obj) {
+    if (this.destroyed) return;
+    var componentName = getComponentName(C);
+    if (this._componentCache[componentName]) return;
+    var component;
+
+    if (C instanceof Function) {
+      component = new C(obj);
+    } else if (C instanceof Component$1) {
+      component = C;
+    } else {
+      throw new Error('addComponent recieve Component and Component Constructor');
+    }
+
+    if (component.gameObject) {
+      throw new Error("component has been added on gameObject " + component.gameObject.name);
+    }
+
+    component.gameObject = this;
+    component.init && component.init(component.__componentDefaultParams);
+    observerAdded(component, component.name);
+    observer(component, component.name);
+    this.components.push(component);
+    this._componentCache[componentName] = component;
+    component.awake && component.awake();
+    return component;
+  };
+
+  GameObject.prototype.removeComponent = function (c) {
+    var componentName;
+
+    if (typeof c === 'string') {
+      componentName = c;
+    } else if (c instanceof Component$1) {
+      componentName = c.name;
+    } else if (c.componentName) {
+      componentName = c.componentName;
+    }
+
+    if (componentName === 'Transform') {
+      throw new Error("Transform can't be removed");
+    }
+
+    return this._removeComponent(componentName);
+  };
+
+  GameObject.prototype._removeComponent = function (componentName) {
+    var index = this.components.findIndex(function (_a) {
+      var name = _a.name;
+      return name === componentName;
+    });
+    if (index === -1) return;
+    var component = this.components.splice(index, 1)[0];
+    delete this._componentCache[componentName];
+    delete component.__componentDefaultParams;
+    component.onDestroy && component.onDestroy();
+    observerRemoved(component, componentName);
+    component.gameObject = undefined;
+    return component;
+  };
+
+  GameObject.prototype.getComponent = function (c) {
+    var componentName;
+
+    if (typeof c === 'string') {
+      componentName = c;
+    } else if (c instanceof Component$1) {
+      componentName = c.name;
+    } else if (c.componentName) {
+      componentName = c.componentName;
+    }
+
+    if (typeof this._componentCache[componentName] !== 'undefined') {
+      return this._componentCache[componentName];
+    } else {
+      return;
+    }
+  };
+
+  GameObject.prototype.remove = function () {
+    if (this.parent) return this.parent.removeChild(this);
+  };
+
+  GameObject.prototype.destroy = function () {
+    if (!this.transform) {
+      console.error('Cannot destroy gameObject that have already been destroyed.');
+      return;
+    }
+
+    Array.from(this.transform.children).forEach(function (_a) {
+      var gameObject = _a.gameObject;
+      gameObject.destroy();
+    });
+    this.remove();
+    this.transform.clearChildren();
+
+    for (var key in this._componentCache) {
+      this._removeComponent(key);
+    }
+
+    this.components.length = 0;
+    this.destroyed = true;
+  };
+
+  return GameObject;
+}();
+
+var GameObject$1 = GameObject;
+
+var ComponentObserver = function () {
+  function ComponentObserver() {
+    this.events = [];
+  }
+
+  ComponentObserver.prototype.add = function (_a) {
+    var component = _a.component,
+        prop = _a.prop,
+        type = _a.type,
+        componentName = _a.componentName;
+
+    if (type === ObserverType.REMOVE) {
+      if (this.events.find(function (changed) {
+        return changed.component === component && changed.type === ObserverType.ADD;
+      })) {
+        this.events = this.events.filter(function (changed) {
+          return changed.component !== component;
+        });
+        return;
+      }
+
+      this.events = this.events.filter(function (changed) {
+        return changed.component !== component;
+      });
+    }
+
+    var index = this.events.findIndex(function (changed) {
+      return changed.component === component && isEqual(changed.prop, prop) && changed.type === type;
+    });
+
+    if (index > -1) {
+      this.events.splice(index, 1);
+    }
+
+    this.events.push({
+      gameObject: component.gameObject,
+      component: component,
+      prop: prop,
+      type: type,
+      componentName: componentName
+    });
+  };
+
+  ComponentObserver.prototype.getChanged = function () {
+    return this.events;
+  };
+
+  Object.defineProperty(ComponentObserver.prototype, "changed", {
+    get: function get() {
+      return this.events;
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  ComponentObserver.prototype.clear = function () {
+    var events = this.events;
+    this.events = [];
+    return events;
+  };
+
+  return ComponentObserver;
+}();
+
+var ComponentObserver$1 = ComponentObserver;
+
+var System = function () {
+  function System(params) {
+    this.started = false;
+    this.componentObserver = new ComponentObserver$1();
+    this.__systemDefaultParams = params;
+    this.name = this.constructor.systemName;
+  }
+
+  System.prototype.destroy = function () {
+    var _a;
+
+    this.componentObserver = null;
+    this.__systemDefaultParams = null;
+    (_a = this.onDestroy) === null || _a === void 0 ? void 0 : _a.call(this);
+  };
+
+  return System;
+}();
+
+var System$1 = System;
+
+function createNowTime() {
+  var nowtime = null;
+
+  if (Date.now) {
+    nowtime = Date.now;
+  } else {
+    nowtime = function nowtime() {
+      return new Date().getTime();
+    };
+  }
+
+  return nowtime;
+}
+
+var _nowtime = createNowTime();
+
+var defaultOptions$1 = {
+  originTime: 0,
+  playbackRate: 1.0
+};
+
+var Timeline = function () {
+  function Timeline(options, parent) {
+    if (options instanceof Timeline) {
+      parent = options;
+      options = {};
+    }
+
+    options = _extends({}, defaultOptions$1, options);
+
+    if (parent) {
+      this._parent = parent;
+    }
+
+    this._createTime = _nowtime();
+    this._timeMark = [{
+      globalTime: this.globalTime,
+      localTime: -options.originTime,
+      entropy: -options.originTime,
+      playbackRate: options.playbackRate,
+      globalEntropy: 0
+    }];
+
+    if (this._parent) {
+      this._timeMark[0].globalEntropy = this._parent.entropy;
+    }
+
+    this._playbackRate = options.playbackRate;
+  }
+
+  Object.defineProperty(Timeline.prototype, "globalTime", {
+    get: function get() {
+      return this.parent ? this.parent.currentTime : _nowtime() - this._createTime;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Timeline.prototype, "parent", {
+    get: function get() {
+      return this._parent;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Timeline.prototype, "lastTimeMark", {
+    get: function get() {
+      return this._timeMark[this._timeMark.length - 1];
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  Timeline.prototype.markTime = function (_a) {
+    var _b = _a === void 0 ? {} : _a,
+        _c = _b.time,
+        time = _c === void 0 ? this.currentTime : _c,
+        _d = _b.entropy,
+        entropy = _d === void 0 ? this.entropy : _d,
+        _e = _b.playbackRate,
+        playbackRate = _e === void 0 ? this.playbackRate : _e;
+
+    var timeMark = {
+      globalTime: this.globalTime,
+      localTime: time,
+      entropy: entropy,
+      playbackRate: playbackRate,
+      globalEntropy: this.globalEntropy
+    };
+
+    this._timeMark.push(timeMark);
+  };
+
+  Object.defineProperty(Timeline.prototype, "currentTime", {
+    get: function get() {
+      var _a = this.lastTimeMark,
+          localTime = _a.localTime,
+          globalTime = _a.globalTime;
+      return localTime + (this.globalTime - globalTime) * this.playbackRate;
+    },
+    set: function set(time) {
+      this.markTime({
+        time: time
+      });
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Timeline.prototype, "globalEntropy", {
+    get: function get() {
+      return this._parent ? this._parent.entropy : this.globalTime;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Timeline.prototype, "entropy", {
+    get: function get() {
+      var _a = this.lastTimeMark,
+          entropy = _a.entropy,
+          globalEntropy = _a.globalEntropy;
+      return entropy + Math.abs((this.globalEntropy - globalEntropy) * this.playbackRate);
+    },
+    set: function set(entropy) {
+      if (this.entropy > entropy) {
+        var idx = this.seekTimeMark(entropy);
+        this._timeMark.length = idx + 1;
+      }
+
+      this.markTime({
+        entropy: entropy
+      });
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  Timeline.prototype.fork = function (options) {
+    return new Timeline(options, this);
+  };
+
+  Timeline.prototype.seekGlobalTime = function (seekEntropy) {
+    var idx = this.seekTimeMark(seekEntropy),
+        timeMark = this._timeMark[idx];
+    var entropy = timeMark.entropy,
+        playbackRate = timeMark.playbackRate,
+        globalTime = timeMark.globalTime;
+    return globalTime + (seekEntropy - entropy) / Math.abs(playbackRate);
+  };
+
+  Timeline.prototype.seekLocalTime = function (seekEntropy) {
+    var idx = this.seekTimeMark(seekEntropy),
+        timeMark = this._timeMark[idx];
+    var localTime = timeMark.localTime,
+        entropy = timeMark.entropy,
+        playbackRate = timeMark.playbackRate;
+
+    if (playbackRate > 0) {
+      return localTime + (seekEntropy - entropy);
+    }
+
+    return localTime - (seekEntropy - entropy);
+  };
+
+  Timeline.prototype.seekTimeMark = function (entropy) {
+    var timeMark = this._timeMark;
+    var l = 0,
+        r = timeMark.length - 1;
+
+    if (entropy <= timeMark[l].entropy) {
+      return l;
+    }
+
+    if (entropy >= timeMark[r].entropy) {
+      return r;
+    }
+
+    var m = Math.floor((l + r) / 2);
+
+    while (m > l && m < r) {
+      if (entropy === timeMark[m].entropy) {
+        return m;
+      }
+
+      if (entropy < timeMark[m].entropy) {
+        r = m;
+      } else if (entropy > timeMark[m].entropy) {
+        l = m;
+      }
+
+      m = Math.floor((l + r) / 2);
+    }
+
+    return l;
+  };
+
+  Object.defineProperty(Timeline.prototype, "playbackRate", {
+    get: function get() {
+      return this._playbackRate;
+    },
+    set: function set(rate) {
+      if (rate !== this.playbackRate) {
+        this.markTime({
+          playbackRate: rate
+        });
+        this._playbackRate = rate;
+      }
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Timeline.prototype, "paused", {
+    get: function get() {
+      if (this.playbackRate === 0) return true;
+      var parent = this.parent;
+
+      while (parent) {
+        if (parent.playbackRate === 0) return true;
+        parent = parent.parent;
+      }
+
+      return false;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return Timeline;
+}();
+
+var Timeline$1 = Timeline;
+var defaultOptions = {
+  autoStart: true,
+  frameRate: 60
+};
+
+var Ticker = function () {
+  function Ticker(options) {
+    var _this = this;
+
+    options = _extends({}, defaultOptions, options);
+    this._frameCount = 0;
+    this._frameDuration = 1000 / options.frameRate;
+    this.autoStart = options.autoStart;
+    this.frameRate = options.frameRate;
+    this.timeline = new Timeline$1({
+      originTime: 0,
+      playbackRate: 1.0
+    });
+    this._lastFrameTime = this.timeline.currentTime;
+    this._tickers = new Set();
+    this._requestId = null;
+
+    this._ticker = function () {
+      if (_this._started) {
+        _this._requestId = requestAnimationFrame(_this._ticker);
+
+        _this.update();
+      }
+    };
+
+    if (this.autoStart) {
+      this.start();
+    }
+  }
+
+  Ticker.prototype.update = function () {
+    var e_1, _a;
+
+    var currentTime = this.timeline.currentTime;
+    var durationTime = currentTime - this._lastFrameTime;
+
+    if (durationTime >= this._frameDuration) {
+      var frameTime = currentTime - durationTime % this._frameDuration;
+      var deltaTime = frameTime - this._lastFrameTime;
+      this._lastFrameTime = frameTime;
+      var options = {
+        deltaTime: deltaTime,
+        time: frameTime,
+        currentTime: frameTime,
+        frameCount: ++this._frameCount,
+        fps: Math.round(1000 / deltaTime)
+      };
+
+      try {
+        for (var _b = __values(this._tickers), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var func = _c.value;
+
+          if (typeof func === 'function') {
+            func(options);
+          }
+        }
+      } catch (e_1_1) {
+        e_1 = {
+          error: e_1_1
+        };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+    }
+  };
+
+  Ticker.prototype.add = function (fn) {
+    this._tickers.add(fn);
+  };
+
+  Ticker.prototype.remove = function (fn) {
+    this._tickers.delete(fn);
+  };
+
+  Ticker.prototype.start = function () {
+    if (this._started) return;
+    this._started = true;
+    this.timeline.playbackRate = 1.0;
+    this._requestId = requestAnimationFrame(this._ticker);
+  };
+
+  Ticker.prototype.pause = function () {
+    this._started = false;
+    this.timeline.playbackRate = 0;
+  };
+
+  Ticker.prototype.setPlaybackRate = function (rate) {
+    this.timeline.playbackRate = rate;
+  };
+
+  return Ticker;
+}();
+
+var Ticker$1 = Ticker;
+
+var Scene = function (_super) {
+  __extends$1(Scene, _super);
+
+  function Scene(name, obj) {
+    var _this = _super.call(this, name, obj) || this;
+
+    _this.gameObjects = [];
+    _this.scene = _this;
+    return _this;
+  }
+
+  Scene.prototype.addGameObject = function (gameObject) {
+    this.gameObjects.push(gameObject);
+
+    if (gameObject.transform) {
+      gameObject.transform.inScene = true;
+    }
+  };
+
+  Scene.prototype.removeGameObject = function (gameObject) {
+    var index = this.gameObjects.indexOf(gameObject);
+    if (index === -1) return;
+
+    if (gameObject.transform) {
+      gameObject.transform.inScene = false;
+    }
+
+    this.gameObjects.splice(index, 1);
+  };
+
+  Scene.prototype.destroy = function () {
+    this.scene = null;
+
+    _super.prototype.destroy.call(this);
+
+    this.gameObjects = null;
+    this.canvas = null;
+  };
+
+  return Scene;
+}(GameObject$1);
+
+var Scene$1 = Scene;
+var LOAD_SCENE_MODE;
+
+(function (LOAD_SCENE_MODE) {
+  LOAD_SCENE_MODE["SINGLE"] = "SINGLE";
+  LOAD_SCENE_MODE["MULTI_CANVAS"] = "MULTI_CANVAS";
+})(LOAD_SCENE_MODE || (LOAD_SCENE_MODE = {}));
+
+var triggerStart = function triggerStart(obj) {
+  if (!(obj instanceof System$1) && !(obj instanceof Component$1)) return;
+  if (obj.started) return;
+  obj.started = true;
+
+  try {
+    obj.start && obj.start();
+  } catch (e) {
+    if (obj instanceof Component$1) {
+      console.error(obj.constructor.componentName + " start error", e);
+    } else {
+      console.error(obj.constructor.systemName + " start error", e);
+    }
+  }
+};
+
+var getAllGameObjects = function getAllGameObjects(game) {
+  var e_1, _a;
+
+  var _b;
+
+  var mainSceneGameObjects = ((_b = game === null || game === void 0 ? void 0 : game.scene) === null || _b === void 0 ? void 0 : _b.gameObjects) || [];
+  var gameObjectsArray = game === null || game === void 0 ? void 0 : game.multiScenes.map(function (_a) {
+    var gameObjects = _a.gameObjects;
+    return gameObjects;
+  });
+  var otherSceneGameObjects = [];
+
+  try {
+    for (var gameObjectsArray_1 = __values(gameObjectsArray), gameObjectsArray_1_1 = gameObjectsArray_1.next(); !gameObjectsArray_1_1.done; gameObjectsArray_1_1 = gameObjectsArray_1.next()) {
+      var gameObjects = gameObjectsArray_1_1.value;
+      otherSceneGameObjects = __spread(otherSceneGameObjects, gameObjects);
+    }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (gameObjectsArray_1_1 && !gameObjectsArray_1_1.done && (_a = gameObjectsArray_1.return)) _a.call(gameObjectsArray_1);
+    } finally {
+      if (e_1) throw e_1.error;
+    }
+  }
+
+  return __spread(mainSceneGameObjects, otherSceneGameObjects);
+};
+
+var gameObjectLoop = function gameObjectLoop(e, gameObjects) {
+  var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
+
+  if (gameObjects === void 0) {
+    gameObjects = [];
+  }
+
+  try {
+    for (var gameObjects_1 = __values(gameObjects), gameObjects_1_1 = gameObjects_1.next(); !gameObjects_1_1.done; gameObjects_1_1 = gameObjects_1.next()) {
+      var gameObject = gameObjects_1_1.value;
+
+      try {
+        for (var _e = (e_3 = void 0, __values(gameObject.components)), _f = _e.next(); !_f.done; _f = _e.next()) {
+          var component = _f.value;
+
+          try {
+            triggerStart(component);
+            component.update && component.update(e);
+          } catch (e) {
+            console.error("gameObject: " + gameObject.name + " " + component.name + " update error", e);
+          }
+        }
+      } catch (e_3_1) {
+        e_3 = {
+          error: e_3_1
+        };
+      } finally {
+        try {
+          if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        } finally {
+          if (e_3) throw e_3.error;
+        }
+      }
+    }
+  } catch (e_2_1) {
+    e_2 = {
+      error: e_2_1
+    };
+  } finally {
+    try {
+      if (gameObjects_1_1 && !gameObjects_1_1.done && (_a = gameObjects_1.return)) _a.call(gameObjects_1);
+    } finally {
+      if (e_2) throw e_2.error;
+    }
+  }
+
+  try {
+    for (var gameObjects_2 = __values(gameObjects), gameObjects_2_1 = gameObjects_2.next(); !gameObjects_2_1.done; gameObjects_2_1 = gameObjects_2.next()) {
+      var gameObject = gameObjects_2_1.value;
+
+      try {
+        for (var _g = (e_5 = void 0, __values(gameObject.components)), _h = _g.next(); !_h.done; _h = _g.next()) {
+          var component = _h.value;
+
+          try {
+            component.lateUpdate && component.lateUpdate(e);
+          } catch (e) {
+            console.error("gameObject: " + gameObject.name + " " + component.name + " lateUpdate error", e);
+          }
+        }
+      } catch (e_5_1) {
+        e_5 = {
+          error: e_5_1
+        };
+      } finally {
+        try {
+          if (_h && !_h.done && (_d = _g.return)) _d.call(_g);
+        } finally {
+          if (e_5) throw e_5.error;
+        }
+      }
+    }
+  } catch (e_4_1) {
+    e_4 = {
+      error: e_4_1
+    };
+  } finally {
+    try {
+      if (gameObjects_2_1 && !gameObjects_2_1.done && (_c = gameObjects_2.return)) _c.call(gameObjects_2);
+    } finally {
+      if (e_4) throw e_4.error;
+    }
+  }
+};
+
+var gameObjectResume = function gameObjectResume(gameObjects) {
+  var e_6, _a, e_7, _b;
+
+  try {
+    for (var gameObjects_3 = __values(gameObjects), gameObjects_3_1 = gameObjects_3.next(); !gameObjects_3_1.done; gameObjects_3_1 = gameObjects_3.next()) {
+      var gameObject = gameObjects_3_1.value;
+
+      try {
+        for (var _c = (e_7 = void 0, __values(gameObject.components)), _d = _c.next(); !_d.done; _d = _c.next()) {
+          var component = _d.value;
+
+          try {
+            component.onResume && component.onResume();
+          } catch (e) {
+            console.error("gameObject: " + gameObject.name + ", " + component.name + ", onResume error", e);
+          }
+        }
+      } catch (e_7_1) {
+        e_7 = {
+          error: e_7_1
+        };
+      } finally {
+        try {
+          if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+        } finally {
+          if (e_7) throw e_7.error;
+        }
+      }
+    }
+  } catch (e_6_1) {
+    e_6 = {
+      error: e_6_1
+    };
+  } finally {
+    try {
+      if (gameObjects_3_1 && !gameObjects_3_1.done && (_a = gameObjects_3.return)) _a.call(gameObjects_3);
+    } finally {
+      if (e_6) throw e_6.error;
+    }
+  }
+};
+
+var gameObjectPause = function gameObjectPause(gameObjects) {
+  var e_8, _a, e_9, _b;
+
+  try {
+    for (var gameObjects_4 = __values(gameObjects), gameObjects_4_1 = gameObjects_4.next(); !gameObjects_4_1.done; gameObjects_4_1 = gameObjects_4.next()) {
+      var gameObject = gameObjects_4_1.value;
+
+      try {
+        for (var _c = (e_9 = void 0, __values(gameObject.components)), _d = _c.next(); !_d.done; _d = _c.next()) {
+          var component = _d.value;
+
+          try {
+            component.onPause && component.onPause();
+          } catch (e) {
+            console.error("gameObject: " + gameObject.name + ", " + component.name + ", onResume error", e);
+          }
+        }
+      } catch (e_9_1) {
+        e_9 = {
+          error: e_9_1
+        };
+      } finally {
+        try {
+          if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+        } finally {
+          if (e_9) throw e_9.error;
+        }
+      }
+    }
+  } catch (e_8_1) {
+    e_8 = {
+      error: e_8_1
+    };
+  } finally {
+    try {
+      if (gameObjects_4_1 && !gameObjects_4_1.done && (_a = gameObjects_4.return)) _a.call(gameObjects_4);
+    } finally {
+      if (e_8) throw e_8.error;
+    }
+  }
+};
+
+var Game = function (_super) {
+  __extends$1(Game, _super);
+
+  function Game(_a) {
+    var e_10, _b;
+
+    var _c = _a === void 0 ? {} : _a,
+        systems = _c.systems,
+        _d = _c.frameRate,
+        frameRate = _d === void 0 ? 60 : _d,
+        _e = _c.autoStart,
+        autoStart = _e === void 0 ? true : _e,
+        _f = _c.needScene,
+        needScene = _f === void 0 ? true : _f;
+
+    var _this = _super.call(this) || this;
+
+    _this.playing = false;
+    _this.started = false;
+    _this.multiScenes = [];
+    _this.systems = [];
+
+    if (windowAlias.__EVA_INSPECTOR_ENV__) {
+      windowAlias.__EVA_GAME_INSTANCE__ = _this;
+    }
+
+    _this.ticker = new Ticker$1({
+      autoStart: false,
+      frameRate: frameRate
+    });
+
+    _this.initTicker();
+
+    if (systems && systems.length) {
+      try {
+        for (var systems_1 = __values(systems), systems_1_1 = systems_1.next(); !systems_1_1.done; systems_1_1 = systems_1.next()) {
+          var system = systems_1_1.value;
+
+          _this.addSystem(system);
+        }
+      } catch (e_10_1) {
+        e_10 = {
+          error: e_10_1
+        };
+      } finally {
+        try {
+          if (systems_1_1 && !systems_1_1.done && (_b = systems_1.return)) _b.call(systems_1);
+        } finally {
+          if (e_10) throw e_10.error;
+        }
+      }
+    }
+
+    if (needScene) {
+      _this.loadScene(new Scene$1('scene'));
+    }
+
+    if (autoStart) {
+      _this.start();
+    }
+
+    return _this;
+  }
+
+  Object.defineProperty(Game.prototype, "scene", {
+    get: function get() {
+      return this._scene;
+    },
+    set: function set(scene) {
+      this._scene = scene;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Game.prototype, "gameObjects", {
+    get: function get() {
+      return getAllGameObjects(this);
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  Game.prototype.addSystem = function (S, obj) {
+    var system;
+
+    if (S instanceof Function) {
+      system = new S(obj);
+    } else if (S instanceof System$1) {
+      system = S;
+    } else {
+      console.warn('can only add System');
+      return;
+    }
+
+    var hasTheSystem = this.systems.find(function (item) {
+      return item.constructor === system.constructor;
+    });
+
+    if (hasTheSystem) {
+      console.warn(system.constructor.systemName + " System has been added");
+      return;
+    }
+
+    system.game = this;
+    system.init && system.init(system.__systemDefaultParams);
+    setSystemObserver(system, system.constructor);
+    initObserver(system.constructor);
+
+    try {
+      system.awake && system.awake();
+    } catch (e) {
+      console.error(system.constructor.systemName + " awake error", e);
+    }
+
+    this.systems.push(system);
+    return system;
+  };
+
+  Game.prototype.removeSystem = function (system) {
+    if (!system) return;
+    var index = -1;
+
+    if (typeof system === 'string') {
+      index = this.systems.findIndex(function (s) {
+        return s.name === system;
+      });
+    } else if (system instanceof Function) {
+      index = this.systems.findIndex(function (s) {
+        return s.constructor === system;
+      });
+    } else if (system instanceof System$1) {
+      index = this.systems.findIndex(function (s) {
+        return s === system;
+      });
+    }
+
+    if (index > -1) {
+      this.systems[index].destroy && this.systems[index].destroy();
+      this.systems.splice(index, 1);
+    }
+  };
+
+  Game.prototype.getSystem = function (S) {
+    return this.systems.find(function (system) {
+      if (typeof S === 'string') {
+        return system.name === S;
+      } else {
+        return system instanceof S;
+      }
+    });
+  };
+
+  Game.prototype.pause = function () {
+    if (!this.playing) return;
+    this.playing = false;
+    this.ticker.pause();
+    this.triggerPause();
+  };
+
+  Game.prototype.start = function () {
+    if (this.playing) return;
+    this.playing = true;
+    this.started = true;
+    this.ticker.start();
+  };
+
+  Game.prototype.resume = function () {
+    if (this.playing) return;
+    this.playing = true;
+    this.ticker.start();
+    this.triggerResume();
+  };
+
+  Game.prototype.initTicker = function () {
+    var _this = this;
+
+    this.ticker.add(function (e) {
+      var e_11, _a, e_12, _b;
+
+      _this.scene && gameObjectLoop(e, _this.gameObjects);
+
+      try {
+        for (var _c = __values(_this.systems), _d = _c.next(); !_d.done; _d = _c.next()) {
+          var system = _d.value;
+
+          try {
+            triggerStart(system);
+            system.update && system.update(e);
+          } catch (e) {
+            console.error(system.constructor.systemName + " update error", e);
+          }
+        }
+      } catch (e_11_1) {
+        e_11 = {
+          error: e_11_1
+        };
+      } finally {
+        try {
+          if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        } finally {
+          if (e_11) throw e_11.error;
+        }
+      }
+
+      try {
+        for (var _e = __values(_this.systems), _f = _e.next(); !_f.done; _f = _e.next()) {
+          var system = _f.value;
+
+          try {
+            system.lateUpdate && system.lateUpdate(e);
+          } catch (e) {
+            console.error(system.constructor.systemName + " lateUpdate error", e);
+          }
+        }
+      } catch (e_12_1) {
+        e_12 = {
+          error: e_12_1
+        };
+      } finally {
+        try {
+          if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        } finally {
+          if (e_12) throw e_12.error;
+        }
+      }
+    });
+  };
+
+  Game.prototype.triggerResume = function () {
+    var e_13, _a;
+
+    gameObjectResume(this.gameObjects);
+
+    try {
+      for (var _b = __values(this.systems), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var system = _c.value;
+
+        try {
+          system.onResume && system.onResume();
+        } catch (e) {
+          console.error(system.constructor.systemName + ", onResume error", e);
+        }
+      }
+    } catch (e_13_1) {
+      e_13 = {
+        error: e_13_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_13) throw e_13.error;
+      }
+    }
+  };
+
+  Game.prototype.triggerPause = function () {
+    var e_14, _a;
+
+    gameObjectPause(this.gameObjects);
+
+    try {
+      for (var _b = __values(this.systems), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var system = _c.value;
+
+        try {
+          system.onPause && system.onPause();
+        } catch (e) {
+          console.error(system.constructor.systemName + ", onPause error", e);
+        }
+      }
+    } catch (e_14_1) {
+      e_14 = {
+        error: e_14_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_14) throw e_14.error;
+      }
+    }
+  };
+
+  Game.prototype.destroySystems = function () {
+    var e_15, _a;
+
+    try {
+      for (var _b = __values(__spread(this.systems)), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var system = _c.value;
+        this.removeSystem(system);
+      }
+    } catch (e_15_1) {
+      e_15 = {
+        error: e_15_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_15) throw e_15.error;
+      }
+    }
+
+    this.systems.length = 0;
+  };
+
+  Game.prototype.destroy = function () {
+    this.removeAllListeners();
+    this.pause();
+    this.scene.destroy();
+    this.destroySystems();
+    this.ticker = null;
+    this.scene = null;
+    this.canvas = null;
+    this.multiScenes = null;
+  };
+
+  Game.prototype.loadScene = function (_a) {
+    var scene = _a.scene,
+        _b = _a.mode,
+        mode = _b === void 0 ? LOAD_SCENE_MODE.SINGLE : _b,
+        _c = _a.params,
+        params = _c === void 0 ? {} : _c;
+
+    if (!scene) {
+      return;
+    }
+
+    switch (mode) {
+      case LOAD_SCENE_MODE.SINGLE:
+        this.scene = scene;
+        break;
+
+      case LOAD_SCENE_MODE.MULTI_CANVAS:
+        this.multiScenes.push(scene);
+        break;
+    }
+
+    this.emit('sceneChanged', {
+      scene: scene,
+      mode: mode,
+      params: params
+    });
+  };
+
+  return Game;
+}(EventEmitter);
+
+var Game$1 = Game;
+
+function IDEProp(target, propertyKey) {
+  if (!target.constructor.IDEProps) {
+    target.constructor.IDEProps = [];
+  }
+
+  target.constructor.IDEProps.push(propertyKey);
+}
+
+function componentObserver(observerInfo) {
+  if (observerInfo === void 0) {
+    observerInfo = {};
+  }
+
+  return function (constructor) {
+    if (!constructor.observerInfo) {
+      for (var key in observerInfo) {
+        for (var index in observerInfo[key]) {
+          if (typeof observerInfo[key][index] === 'string') {
+            observerInfo[key][index] = [observerInfo[key][index]];
+          }
+
+          var observerProp = void 0;
+
+          if (Array.isArray(observerInfo[key][index])) {
+            observerProp = {
+              prop: observerInfo[key][index],
+              deep: false
+            };
+            observerInfo[key][index] = observerProp;
+          }
+
+          observerProp = observerInfo[key][index];
+
+          if (typeof observerProp.prop === 'string') {
+            observerProp.prop = [observerProp.prop];
+          }
+        }
+      }
+
+      constructor.observerInfo = observerInfo;
+    }
+  };
+}
+
+var SignalBindingImpl = function () {
+  function SignalBindingImpl(fn, once, thisArg) {
+    if (once === void 0) {
+      once = false;
+    }
+
+    this.next = null;
+    this.prev = null;
+    this.owner = null;
+    this.fn = fn;
+    this.once = once;
+    this.thisArg = thisArg;
+  }
+
+  SignalBindingImpl.prototype.detach = function () {
+    if (this.owner === null) return false;
+    this.owner.detach(this);
+    return true;
+  };
+
+  SignalBindingImpl.prototype.dispose = function () {
+    this.detach();
+  };
+
+  return SignalBindingImpl;
+}();
+
+var Signal = function () {
+  function Signal() {
+    this._head = null;
+    this._tail = null;
+    this._filter = null;
+  }
+
+  Signal.prototype.handlers = function () {
+    var node = this._head;
+    var handlers = [];
+
+    while (node) {
+      handlers.push(node);
+      node = node.next;
+    }
+
+    return handlers;
+  };
+
+  Signal.prototype.hasAny = function () {
+    return !!this._head;
+  };
+
+  Signal.prototype.has = function (node) {
+    return node.owner === this;
+  };
+
+  Signal.prototype.dispatch = function () {
+    var args = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+
+    var node = this._head;
+    if (!node) return false;
+    if (this._filter && !this._filter.apply(this, args)) return false;
+
+    while (node) {
+      if (node.once) this.detach(node);
+      node.fn.apply(node.thisArg, args);
+      node = node.next;
+    }
+
+    return true;
+  };
+
+  Signal.prototype.add = function (fn, thisArg) {
+    if (thisArg === void 0) {
+      thisArg = null;
+    }
+
+    return this._addSignalBinding(new SignalBindingImpl(fn, false, thisArg));
+  };
+
+  Signal.prototype.once = function (fn, thisArg) {
+    if (thisArg === void 0) {
+      thisArg = null;
+    }
+
+    return this._addSignalBinding(new SignalBindingImpl(fn, true, thisArg));
+  };
+
+  Signal.prototype.detach = function (node_) {
+    var node = node_;
+    if (node.owner !== this) return this;
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+
+    if (node === this._head) {
+      this._head = node.next;
+
+      if (node.next === null) {
+        this._tail = null;
+      }
+    } else if (node === this._tail) {
+      this._tail = node.prev;
+      if (this._tail) this._tail.next = null;
+    }
+
+    node.owner = null;
+    return this;
+  };
+
+  Signal.prototype.detachAll = function () {
+    var node = this._head;
+    if (!node) return this;
+    this._head = null;
+    this._tail = null;
+
+    while (node) {
+      node.owner = null;
+      node = node.next;
+    }
+
+    return this;
+  };
+
+  Signal.prototype.filter = function (filter) {
+    this._filter = filter;
+  };
+
+  Signal.prototype.proxy = function () {
+    var _this = this;
+
+    var signals = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      signals[_i] = arguments[_i];
+    }
+
+    var fn = function fn() {
+      var args = [];
+
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+
+      return _this.dispatch.apply(_this, args);
+    };
+
+    for (var i = 0; i < signals.length; ++i) {
+      signals[i].add(fn);
+    }
+
+    return this;
+  };
+
+  Signal.prototype._addSignalBinding = function (node_) {
+    var node = node_;
+
+    if (!this._head) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      if (this._tail) this._tail.next = node;
+      node.prev = this._tail;
+      this._tail = node;
+    }
+
+    node.owner = this;
+    return node;
+  };
+
+  return Signal;
+}();
+
+var src = function src(str, opts) {
+  if (opts === void 0) {
+    opts = {};
+  }
+
+  if (!str) return undefined;
+  var o = {
+    key: ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'],
+    q: {
+      name: 'queryKey',
+      parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+    },
+    parser: {
+      strict: /^(?:([^:/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:/?#]*)(?::(\d*))?))?((((?:[^?#/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+      loose: /^(?:(?![^:@]+:[^:@/]*@)([^:/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#/]*\.[^?#/.]+(?:[?#]|$)))*\/?)?([^?#/]*))(?:\?([^#]*))?(?:#(.*))?)/
+    }
+  };
+  var m = o.parser[opts.strictMode ? 'strict' : 'loose'].exec(str);
+  var uri = {};
+  var i = 14;
+
+  while (i--) {
+    uri[o.key[i]] = m[i] || '';
+  }
+
+  uri[o.q.name] = {};
+  uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+    if ($1) uri[o.q.name][$1] = $2;
+  });
+  return uri;
+};
+
+var parseUri = src;
+
+var AbstractLoadStrategy = function () {
+  function AbstractLoadStrategy(config) {
+    this.config = config;
+    this.onError = new Signal();
+    this.onComplete = new Signal();
+    this.onProgress = new Signal();
+  }
+
+  return AbstractLoadStrategy;
+}();
+
+var _extendStatics = function extendStatics(d, b) {
+  _extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) {
+      if (b.hasOwnProperty(p)) d[p] = b[p];
+    }
+  };
+
+  return _extendStatics(d, b);
+};
+
+function __extends(d, b) {
+  _extendStatics(d, b);
+
+  function __() {
+    this.constructor = d;
+  }
+
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __spreadArrays() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) {
+    s += arguments[i].length;
+  }
+
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) {
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) {
+      r[k] = a[j];
+    }
+  }
+
+  return r;
+}
+
+function getExtension(url) {
+  var isDataUrl = url.indexOf('data:') === 0;
+  var ext = '';
+
+  if (isDataUrl) {
+    var slashIndex = url.indexOf('/');
+    ext = url.substring(slashIndex + 1, url.indexOf(';', slashIndex));
+  } else {
+    var queryStart = url.indexOf('?');
+    var hashStart = url.indexOf('#');
+    var index = Math.min(queryStart > -1 ? queryStart : url.length, hashStart > -1 ? hashStart : url.length);
+    url = url.substring(0, index);
+    ext = url.substring(url.lastIndexOf('.') + 1);
+  }
+
+  return ext.toLowerCase();
+}
+
+function assertNever(x) {
+  throw new Error('Unexpected value. Should have been never.');
+}
+
+var ResourceType;
+
+(function (ResourceType) {
+  ResourceType[ResourceType["Unknown"] = 0] = "Unknown";
+  ResourceType[ResourceType["Buffer"] = 1] = "Buffer";
+  ResourceType[ResourceType["Blob"] = 2] = "Blob";
+  ResourceType[ResourceType["Json"] = 3] = "Json";
+  ResourceType[ResourceType["Xml"] = 4] = "Xml";
+  ResourceType[ResourceType["Image"] = 5] = "Image";
+  ResourceType[ResourceType["Audio"] = 6] = "Audio";
+  ResourceType[ResourceType["Video"] = 7] = "Video";
+  ResourceType[ResourceType["Text"] = 8] = "Text";
+})(ResourceType || (ResourceType = {}));
+
+var ResourceState;
+
+(function (ResourceState) {
+  ResourceState[ResourceState["NotStarted"] = 0] = "NotStarted";
+  ResourceState[ResourceState["Loading"] = 1] = "Loading";
+  ResourceState[ResourceState["Complete"] = 2] = "Complete";
+})(ResourceState || (ResourceState = {}));
+
+var MediaElementLoadStrategy = function (_super) {
+  __extends(MediaElementLoadStrategy, _super);
+
+  function MediaElementLoadStrategy(config, elementType) {
+    var _this = _super.call(this, config) || this;
+
+    _this.elementType = elementType;
+    _this._boundOnLoad = _this._onLoad.bind(_this);
+    _this._boundOnError = _this._onError.bind(_this);
+    _this._boundOnTimeout = _this._onTimeout.bind(_this);
+    _this._element = _this._createElement();
+    _this._elementTimer = 0;
+    return _this;
+  }
+
+  MediaElementLoadStrategy.prototype.load = function () {
+    var config = this.config;
+    if (config.crossOrigin) this._element.crossOrigin = config.crossOrigin;
+    var urls = config.sourceSet || [config.url];
+
+    if (navigator.isCocoonJS) {
+      this._element.src = urls[0];
+    } else {
+      for (var i = 0; i < urls.length; ++i) {
+        var url = urls[i];
+        var mimeType = config.mimeTypes ? config.mimeTypes[i] : undefined;
+        if (!mimeType) mimeType = this.elementType + "/" + getExtension(url);
+        var source = documentAlias.createElement('source');
+        source.src = url;
+        source.type = mimeType;
+
+        this._element.appendChild(source);
+      }
+    }
+
+    this._element.addEventListener('load', this._boundOnLoad, false);
+
+    this._element.addEventListener('canplaythrough', this._boundOnLoad, false);
+
+    this._element.addEventListener('error', this._boundOnError, false);
+
+    this._element.load();
+
+    if (config.timeout) this._elementTimer = windowAlias.setTimeout(this._boundOnTimeout, config.timeout);
+  };
+
+  MediaElementLoadStrategy.prototype.abort = function () {
+    this._clearEvents();
+
+    while (this._element.firstChild) {
+      this._element.removeChild(this._element.firstChild);
+    }
+
+    this._error(this.elementType + " load aborted by the user.");
+  };
+
+  MediaElementLoadStrategy.prototype._createElement = function () {
+    if (this.config.loadElement) return this.config.loadElement;else return documentAlias.createElement(this.elementType);
+  };
+
+  MediaElementLoadStrategy.prototype._clearEvents = function () {
+    clearTimeout(this._elementTimer);
+
+    this._element.removeEventListener('load', this._boundOnLoad, false);
+
+    this._element.removeEventListener('canplaythrough', this._boundOnLoad, false);
+
+    this._element.removeEventListener('error', this._boundOnError, false);
+  };
+
+  MediaElementLoadStrategy.prototype._error = function (errMessage) {
+    this._clearEvents();
+
+    this.onError.dispatch(errMessage);
+  };
+
+  MediaElementLoadStrategy.prototype._complete = function () {
+    this._clearEvents();
+
+    var resourceType = ResourceType.Unknown;
+
+    switch (this.elementType) {
+      case 'audio':
+        resourceType = ResourceType.Audio;
+        break;
+
+      case 'video':
+        resourceType = ResourceType.Video;
+        break;
+
+      default:
+        assertNever(this.elementType);
+    }
+
+    this.onComplete.dispatch(resourceType, this._element);
+  };
+
+  MediaElementLoadStrategy.prototype._onLoad = function () {
+    this._complete();
+  };
+
+  MediaElementLoadStrategy.prototype._onError = function () {
+    this._error(this.elementType + " failed to load.");
+  };
+
+  MediaElementLoadStrategy.prototype._onTimeout = function () {
+    this._error(this.elementType + " load timed out.");
+  };
+
+  return MediaElementLoadStrategy;
+}(AbstractLoadStrategy);
+
+var AudioLoadStrategy = function (_super) {
+  __extends(AudioLoadStrategy, _super);
+
+  function AudioLoadStrategy(config) {
+    return _super.call(this, config, 'audio') || this;
+  }
+
+  return AudioLoadStrategy;
+}(MediaElementLoadStrategy);
+
+var EMPTY_GIF = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
+
+var ImageLoadStrategy = function (_super) {
+  __extends(ImageLoadStrategy, _super);
+
+  function ImageLoadStrategy() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+
+    _this._boundOnLoad = _this._onLoad.bind(_this);
+    _this._boundOnError = _this._onError.bind(_this);
+    _this._boundOnTimeout = _this._onTimeout.bind(_this);
+    _this._element = _this._createElement();
+    _this._elementTimer = 0;
+    return _this;
+  }
+
+  ImageLoadStrategy.prototype.load = function () {
+    var config = this.config;
+    if (config.crossOrigin) this._element.crossOrigin = config.crossOrigin;
+    this._element.src = config.url;
+
+    this._element.addEventListener('load', this._boundOnLoad, false);
+
+    this._element.addEventListener('error', this._boundOnError, false);
+
+    if (config.timeout) this._elementTimer = windowAlias.setTimeout(this._boundOnTimeout, config.timeout);
+  };
+
+  ImageLoadStrategy.prototype.abort = function () {
+    this._clearEvents();
+
+    this._element.src = EMPTY_GIF;
+
+    this._error('Image load aborted by the user.');
+  };
+
+  ImageLoadStrategy.prototype._createElement = function () {
+    if (this.config.loadElement) return this.config.loadElement;else return documentAlias.createElement('img');
+  };
+
+  ImageLoadStrategy.prototype._clearEvents = function () {
+    clearTimeout(this._elementTimer);
+
+    this._element.removeEventListener('load', this._boundOnLoad, false);
+
+    this._element.removeEventListener('error', this._boundOnError, false);
+  };
+
+  ImageLoadStrategy.prototype._error = function (errMessage) {
+    this._clearEvents();
+
+    this.onError.dispatch(errMessage);
+  };
+
+  ImageLoadStrategy.prototype._complete = function () {
+    this._clearEvents();
+
+    this.onComplete.dispatch(ResourceType.Image, this._element);
+  };
+
+  ImageLoadStrategy.prototype._onLoad = function () {
+    this._complete();
+  };
+
+  ImageLoadStrategy.prototype._onError = function () {
+    this._error('Image failed to load.');
+  };
+
+  ImageLoadStrategy.prototype._onTimeout = function () {
+    this._error('Image load timed out.');
+  };
+
+  return ImageLoadStrategy;
+}(AbstractLoadStrategy);
+
+var VideoLoadStrategy = function (_super) {
+  __extends(VideoLoadStrategy, _super);
+
+  function VideoLoadStrategy(config) {
+    return _super.call(this, config, 'video') || this;
+  }
+
+  return VideoLoadStrategy;
+}(MediaElementLoadStrategy);
+
+var useXdr = !!(windowAlias.XDomainRequest && !('withCredentials' in new XMLHttpRequestAlias()));
+var XhrResponseType;
+
+(function (XhrResponseType) {
+  XhrResponseType["Default"] = "text";
+  XhrResponseType["Buffer"] = "arraybuffer";
+  XhrResponseType["Blob"] = "blob";
+  XhrResponseType["Document"] = "document";
+  XhrResponseType["Json"] = "json";
+  XhrResponseType["Text"] = "text";
+})(XhrResponseType || (XhrResponseType = {}));
+
+function reqType(xhr) {
+  return xhr.toString().replace('object ', '');
+}
+
+var XhrLoadStrategy = function (_super) {
+  __extends(XhrLoadStrategy, _super);
+
+  function XhrLoadStrategy() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+
+    _this._boundOnLoad = _this._onLoad.bind(_this);
+    _this._boundOnAbort = _this._onAbort.bind(_this);
+    _this._boundOnError = _this._onError.bind(_this);
+    _this._boundOnTimeout = _this._onTimeout.bind(_this);
+    _this._boundOnProgress = _this._onProgress.bind(_this);
+    _this._xhr = _this._createRequest();
+    _this._xhrType = XhrResponseType.Default;
+    return _this;
+  }
+
+  XhrLoadStrategy.prototype.load = function () {
+    var config = this.config;
+    var ext = getExtension(config.url);
+
+    if (typeof config.xhrType !== 'string') {
+      config.xhrType = this._determineXhrType(ext);
+    }
+
+    var xhr = this._xhr;
+    this._xhrType = config.xhrType || XhrResponseType.Default;
+
+    if (useXdr) {
+      xhr.timeout = config.timeout || 5000;
+      xhr.onload = this._boundOnLoad;
+      xhr.onerror = this._boundOnError;
+      xhr.ontimeout = this._boundOnTimeout;
+      xhr.onprogress = this._boundOnProgress;
+      xhr.open('GET', config.url, true);
+      setTimeout(function () {
+        xhr.send();
+      }, 0);
+    } else {
+      xhr.open('GET', config.url, true);
+      if (config.timeout) xhr.timeout = config.timeout;
+      if (config.xhrType === XhrResponseType.Json || config.xhrType === XhrResponseType.Document) xhr.responseType = XhrResponseType.Text;else xhr.responseType = config.xhrType;
+      xhr.addEventListener('load', this._boundOnLoad, false);
+      xhr.addEventListener('abort', this._boundOnAbort, false);
+      xhr.addEventListener('error', this._boundOnError, false);
+      xhr.addEventListener('timeout', this._boundOnTimeout, false);
+      xhr.addEventListener('progress', this._boundOnProgress, false);
+      xhr.send();
+    }
+  };
+
+  XhrLoadStrategy.prototype.abort = function () {
+    if (useXdr) {
+      this._clearEvents();
+
+      this._xhr.abort();
+
+      this._onAbort();
+    } else {
+      this._xhr.abort();
+    }
+  };
+
+  XhrLoadStrategy.prototype._createRequest = function () {
+    if (useXdr) return new windowAlias.XDomainRequest();else return new XMLHttpRequestAlias();
+  };
+
+  XhrLoadStrategy.prototype._determineXhrType = function (ext) {
+    return XhrLoadStrategy._xhrTypeMap[ext] || XhrResponseType.Default;
+  };
+
+  XhrLoadStrategy.prototype._clearEvents = function () {
+    if (useXdr) {
+      this._xhr.onload = null;
+      this._xhr.onerror = null;
+      this._xhr.ontimeout = null;
+      this._xhr.onprogress = null;
+    } else {
+      this._xhr.removeEventListener('load', this._boundOnLoad, false);
+
+      this._xhr.removeEventListener('abort', this._boundOnAbort, false);
+
+      this._xhr.removeEventListener('error', this._boundOnError, false);
+
+      this._xhr.removeEventListener('timeout', this._boundOnTimeout, false);
+
+      this._xhr.removeEventListener('progress', this._boundOnProgress, false);
+    }
+  };
+
+  XhrLoadStrategy.prototype._error = function (errMessage) {
+    this._clearEvents();
+
+    this.onError.dispatch(errMessage);
+  };
+
+  XhrLoadStrategy.prototype._complete = function (type, data) {
+    this._clearEvents();
+
+    this.onComplete.dispatch(type, data);
+  };
+
+  XhrLoadStrategy.prototype._onLoad = function () {
+    var xhr = this._xhr;
+    var text = '';
+    var status = typeof xhr.status === 'undefined' ? 200 : xhr.status;
+
+    if (typeof xhr.responseType === 'undefined' || xhr.responseType === '' || xhr.responseType === 'text') {
+      text = xhr.responseText;
+    }
+
+    if (status === 0 && (text.length > 0 || xhr.responseType === XhrResponseType.Buffer)) {
+      status = 200;
+    } else if (status === 1223) {
+      status = 204;
+    }
+
+    var flattenedStatus = Math.floor(status / 100) * 100;
+
+    if (flattenedStatus !== 200) {
+      this._error("[" + xhr.status + "] " + xhr.statusText + ": " + xhr.responseURL);
+
+      return;
+    }
+
+    switch (this._xhrType) {
+      case XhrResponseType.Buffer:
+        this._complete(ResourceType.Buffer, xhr.response);
+
+        break;
+
+      case XhrResponseType.Blob:
+        this._complete(ResourceType.Blob, xhr.response);
+
+        break;
+
+      case XhrResponseType.Document:
+        this._parseDocument(text);
+
+        break;
+
+      case XhrResponseType.Json:
+        this._parseJson(text);
+
+        break;
+
+      case XhrResponseType.Default:
+      case XhrResponseType.Text:
+        this._complete(ResourceType.Text, text);
+
+        break;
+
+      default:
+        assertNever(this._xhrType);
+    }
+  };
+
+  XhrLoadStrategy.prototype._parseDocument = function (text) {
+    try {
+      if (windowAlias.DOMParser) {
+        var parser = new DOMParser();
+        var data = parser.parseFromString(text, 'text/xml');
+
+        this._complete(ResourceType.Xml, data);
+      } else {
+        var div = documentAlias.createElement('div');
+        div.innerHTML = text;
+
+        this._complete(ResourceType.Xml, div);
+      }
+    } catch (e) {
+      this._error("Error trying to parse loaded xml: " + e);
+    }
+  };
+
+  XhrLoadStrategy.prototype._parseJson = function (text) {
+    try {
+      var data = JSON.parse(text);
+
+      this._complete(ResourceType.Json, data);
+    } catch (e) {
+      this._error("Error trying to parse loaded json: " + e);
+    }
+  };
+
+  XhrLoadStrategy.prototype._onAbort = function () {
+    var xhr = this._xhr;
+
+    this._error(reqType(xhr) + " Request was aborted by the user.");
+  };
+
+  XhrLoadStrategy.prototype._onError = function () {
+    var xhr = this._xhr;
+
+    this._error(reqType(xhr) + " Request failed. Status: " + xhr.status + ", text: \"" + xhr.statusText + "\"");
+  };
+
+  XhrLoadStrategy.prototype._onTimeout = function () {
+    var xhr = this._xhr;
+
+    this._error(reqType(xhr) + " Request timed out.");
+  };
+
+  XhrLoadStrategy.prototype._onProgress = function (event) {
+    if (event && event.lengthComputable) {
+      this.onProgress.dispatch(event.loaded / event.total);
+    }
+  };
+
+  XhrLoadStrategy.setExtensionXhrType = function (extname, xhrType) {
+    if (extname && extname.indexOf('.') === 0) extname = extname.substring(1);
+    if (!extname) return;
+    XhrLoadStrategy._xhrTypeMap[extname] = xhrType;
+  };
+
+  XhrLoadStrategy.ResponseType = XhrResponseType;
+  XhrLoadStrategy._xhrTypeMap = {
+    xhtml: XhrResponseType.Document,
+    html: XhrResponseType.Document,
+    htm: XhrResponseType.Document,
+    xml: XhrResponseType.Document,
+    tmx: XhrResponseType.Document,
+    svg: XhrResponseType.Document,
+    tsx: XhrResponseType.Document,
+    gif: XhrResponseType.Blob,
+    png: XhrResponseType.Blob,
+    bmp: XhrResponseType.Blob,
+    jpg: XhrResponseType.Blob,
+    jpeg: XhrResponseType.Blob,
+    tif: XhrResponseType.Blob,
+    tiff: XhrResponseType.Blob,
+    webp: XhrResponseType.Blob,
+    tga: XhrResponseType.Blob,
+    json: XhrResponseType.Json,
+    text: XhrResponseType.Text,
+    txt: XhrResponseType.Text,
+    ttf: XhrResponseType.Buffer,
+    otf: XhrResponseType.Buffer
+  };
+  return XhrLoadStrategy;
+}(AbstractLoadStrategy);
+
+function onlyOnce(func) {
+  var fn = func;
+  return function onceWrapper() {
+    var args = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+
+    if (fn === null) throw new Error('Callback was already called.');
+    var callFn = fn;
+    fn = null;
+    return callFn.apply(this, args);
+  };
+}
+
+var AsyncQueue = function () {
+  function AsyncQueue(worker, concurrency) {
+    if (concurrency === void 0) {
+      concurrency = 1;
+    }
+
+    this.worker = worker;
+    this.concurrency = concurrency;
+    this.workers = 0;
+    this.buffer = 0;
+    this.paused = false;
+    this._started = false;
+    this._tasks = [];
+    this.onSaturated = new Signal();
+    this.onUnsaturated = new Signal();
+    this.onEmpty = new Signal();
+    this.onDrain = new Signal();
+    this.onError = new Signal();
+    if (concurrency === 0) throw new Error('Concurrency must not be zero');
+    this.buffer = concurrency / 4;
+  }
+
+  Object.defineProperty(AsyncQueue.prototype, "started", {
+    get: function get() {
+      return this._started;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  AsyncQueue.prototype.reset = function () {
+    this.onDrain.detachAll();
+    this.workers = 0;
+    this._started = false;
+    this._tasks = [];
+  };
+
+  AsyncQueue.prototype.push = function (data, callback) {
+    this._insert(data, false, callback);
+  };
+
+  AsyncQueue.prototype.unshift = function (data, callback) {
+    this._insert(data, true, callback);
+  };
+
+  AsyncQueue.prototype.process = function () {
+    while (!this.paused && this.workers < this.concurrency && this._tasks.length) {
+      var task = this._tasks.shift();
+
+      if (this._tasks.length === 0) this.onEmpty.dispatch();
+      this.workers += 1;
+      if (this.workers === this.concurrency) this.onSaturated.dispatch();
+      this.worker(task.data, onlyOnce(this._next(task)));
+    }
+  };
+
+  AsyncQueue.prototype.length = function () {
+    return this._tasks.length;
+  };
+
+  AsyncQueue.prototype.running = function () {
+    return this.workers;
+  };
+
+  AsyncQueue.prototype.idle = function () {
+    return this._tasks.length + this.workers === 0;
+  };
+
+  AsyncQueue.prototype.pause = function () {
+    if (this.paused === true) return;
+    this.paused = true;
+  };
+
+  AsyncQueue.prototype.resume = function () {
+    if (this.paused === false) return;
+    this.paused = false;
+
+    for (var w = 1; w <= this.concurrency; w++) {
+      this.process();
+    }
+  };
+
+  AsyncQueue.prototype.getTask = function (index) {
+    return this._tasks[index];
+  };
+
+  AsyncQueue.prototype._insert = function (data, insertAtFront, callback) {
+    var _this = this;
+
+    if (callback != null && typeof callback !== 'function') {
+      throw new Error('task callback must be a function');
+    }
+
+    this._started = true;
+
+    if (data == null && this.idle()) {
+      setTimeout(function () {
+        return _this.onDrain.dispatch();
+      }, 1);
+      return;
+    }
+
+    var task = {
+      data: data,
+      callback: callback
+    };
+    if (insertAtFront) this._tasks.unshift(task);else this._tasks.push(task);
+    setTimeout(function () {
+      return _this.process();
+    }, 1);
+  };
+
+  AsyncQueue.prototype._next = function (task) {
+    var _this = this;
+
+    return function (err) {
+      var args = [];
+
+      for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+      }
+
+      _this.workers -= 1;
+      if (task.callback) task.callback.apply(task, __spreadArrays([err], args));
+      if (err) _this.onError.dispatch(err, task.data);
+      if (_this.workers <= _this.concurrency - _this.buffer) _this.onUnsaturated.dispatch();
+      if (_this.idle()) _this.onDrain.dispatch();
+
+      _this.process();
+    };
+  };
+
+  return AsyncQueue;
+}();
+
+var Resource$1 = function () {
+  function Resource(name, options) {
+    this.children = [];
+    this.onStart = new Signal();
+    this.onProgress = new Signal();
+    this.onComplete = new Signal();
+    this.onAfterMiddleware = new Signal();
+    this.data = null;
+    this.type = ResourceType.Unknown;
+    this.error = '';
+    this.progressChunk = 0;
+
+    this._dequeue = function () {};
+
+    this._onCompleteBinding = null;
+    this._state = ResourceState.NotStarted;
+    this.name = name;
+    this.metadata = options.metadata;
+    if (typeof options.crossOrigin !== 'string') options.crossOrigin = this._determineCrossOrigin(options.url);
+
+    if (options.strategy && typeof options.strategy !== 'function') {
+      this._strategy = options.strategy;
+      this._strategy.config = options;
+    } else {
+      var StrategyCtor = options.strategy;
+      if (!StrategyCtor) StrategyCtor = Resource._loadStrategyMap[getExtension(options.url)];
+      if (!StrategyCtor) StrategyCtor = Resource._defaultLoadStrategy;
+      this._strategy = new StrategyCtor(options);
+    }
+
+    this._strategy.onError.add(this._error, this);
+
+    this._strategy.onComplete.add(this._complete, this);
+
+    this._strategy.onProgress.add(this._progress, this);
+  }
+
+  Resource.setDefaultLoadStrategy = function (strategy) {
+    Resource._defaultLoadStrategy = strategy;
+  };
+
+  Resource.setLoadStrategy = function (extname, strategy) {
+    if (extname && extname.indexOf('.') === 0) extname = extname.substring(1);
+    if (!extname) return;
+    Resource._loadStrategyMap[extname] = strategy;
+  };
+
+  Object.defineProperty(Resource.prototype, "strategy", {
+    get: function get() {
+      return this._strategy;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Resource.prototype, "url", {
+    get: function get() {
+      return this._strategy.config.url;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Resource.prototype, "isLoading", {
+    get: function get() {
+      return this._state === ResourceState.Loading;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(Resource.prototype, "isComplete", {
+    get: function get() {
+      return this._state === ResourceState.Complete;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Resource.prototype.abort = function () {
+    this._strategy.abort();
+  };
+
+  Resource.prototype.load = function () {
+    this._state = ResourceState.Loading;
+    this.onStart.dispatch(this);
+
+    this._strategy.load();
+  };
+
+  Resource.prototype._error = function (errMessage) {
+    this._state = ResourceState.Complete;
+    this.error = errMessage;
+    this.onComplete.dispatch(this);
+  };
+
+  Resource.prototype._complete = function (type, data) {
+    this._state = ResourceState.Complete;
+    this.type = type;
+    this.data = data;
+    this.onComplete.dispatch(this);
+  };
+
+  Resource.prototype._progress = function (percent) {
+    this.onProgress.dispatch(this, percent);
+  };
+
+  Resource.prototype._determineCrossOrigin = function (url, loc) {
+    if (loc === void 0) {
+      loc = windowAlias.location;
+    }
+
+    if (url.indexOf('data:') === 0 || url.indexOf('javascript:') === 0) return '';
+    if (windowAlias.origin !== windowAlias.location.origin) return 'anonymous';
+    if (!Resource._tempAnchor) Resource._tempAnchor = documentAlias.createElement('a');
+    Resource._tempAnchor.href = url;
+    var parsed = parseUri(Resource._tempAnchor.href, {
+      strictMode: true
+    });
+    var samePort = !parsed.port && loc.port === '' || parsed.port === loc.port;
+    var protocol = parsed.protocol ? parsed.protocol + ":" : '';
+    if (parsed.host !== loc.hostname || !samePort || protocol !== loc.protocol) return 'anonymous';
+    return '';
+  };
+
+  Resource._tempAnchor = null;
+  Resource._defaultLoadStrategy = XhrLoadStrategy;
+  Resource._loadStrategyMap = {
+    gif: ImageLoadStrategy,
+    png: ImageLoadStrategy,
+    bmp: ImageLoadStrategy,
+    jpg: ImageLoadStrategy,
+    jpeg: ImageLoadStrategy,
+    tif: ImageLoadStrategy,
+    tiff: ImageLoadStrategy,
+    webp: ImageLoadStrategy,
+    tga: ImageLoadStrategy,
+    svg: ImageLoadStrategy,
+    'svg+xml': ImageLoadStrategy,
+    mp3: AudioLoadStrategy,
+    ogg: AudioLoadStrategy,
+    wav: AudioLoadStrategy,
+    mp4: VideoLoadStrategy,
+    webm: VideoLoadStrategy,
+    mov: VideoLoadStrategy
+  };
+  return Resource;
+}();
+
+function eachSeries(array, iterator, callback, deferNext) {
+  if (deferNext === void 0) {
+    deferNext = false;
+  }
+
+  var i = 0;
+  var len = array.length;
+
+  (function next(err) {
+    if (err || i === len) {
+      if (callback) callback(err);
+      return;
+    }
+
+    if (deferNext) setTimeout(function () {
+      return iterator(array[i++], next);
+    }, 1);else iterator(array[i++], next);
+  })();
+}
+
+var MAX_PROGRESS = 100;
+var rgxExtractUrlHash = /(#[\w-]+)?$/;
+
+var Loader = function () {
+  function Loader(baseUrl, concurrency) {
+    if (baseUrl === void 0) {
+      baseUrl = '';
+    }
+
+    if (concurrency === void 0) {
+      concurrency = 10;
+    }
+
+    this.progress = 0;
+    this.loading = false;
+    this.defaultQueryString = '';
+    this.resources = {};
+    this.onError = new Signal();
+    this.onLoad = new Signal();
+    this.onStart = new Signal();
+    this.onComplete = new Signal();
+    this.onProgress = new Signal();
+    this._baseUrl = '';
+    this._urlResolvers = [];
+    this._middleware = [];
+    this._resourcesParsing = [];
+    this._boundLoadResource = this._loadResource.bind(this);
+    this.baseUrl = baseUrl;
+    this._queue = new AsyncQueue(this._boundLoadResource, concurrency);
+
+    this._queue.pause();
+
+    this._middleware = Loader._defaultMiddleware.slice();
+  }
+
+  Object.defineProperty(Loader.prototype, "baseUrl", {
+    get: function get() {
+      return this._baseUrl;
+    },
+    set: function set(url) {
+      while (url.length && url.charAt(url.length - 1) === '/') {
+        url = url.slice(0, -1);
+      }
+
+      this._baseUrl = url;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Loader.prototype.add = function (options, url_) {
+    if (Array.isArray(options)) {
+      for (var i = 0; i < options.length; ++i) {
+        this.add(options[i]);
+      }
+
+      return this;
+    }
+
+    var url = '';
+    var name = '';
+    var baseUrl = this._baseUrl;
+    var resOptions = {
+      url: ''
+    };
+
+    if (typeof options === 'object') {
+      url = options.url;
+      name = options.name || options.url;
+      baseUrl = options.baseUrl || baseUrl;
+      resOptions = options;
+    } else {
+      name = options;
+      if (typeof url_ === 'string') url = url_;else url = name;
+    }
+
+    if (!url) throw new Error('You must specify the `url` property.');
+
+    if (this.loading && !resOptions.parentResource) {
+      throw new Error('Cannot add root resources while the loader is running.');
+    }
+
+    if (this.resources[name]) {
+      throw new Error("Resource named \"" + name + "\" already exists.");
+    }
+
+    url = this._prepareUrl(url, baseUrl);
+    resOptions.url = url;
+    var resource = new Resource$1(name, resOptions);
+    this.resources[name] = resource;
+
+    if (typeof resOptions.onComplete === 'function') {
+      resource.onAfterMiddleware.once(resOptions.onComplete);
+    }
+
+    if (this.loading) {
+      var parent_1 = resOptions.parentResource;
+      var incompleteChildren = [];
+
+      for (var i = 0; i < parent_1.children.length; ++i) {
+        if (!parent_1.children[i].isComplete) {
+          incompleteChildren.push(parent_1.children[i]);
+        }
+      }
+
+      var fullChunk = parent_1.progressChunk * (incompleteChildren.length + 1);
+      var eachChunk = fullChunk / (incompleteChildren.length + 2);
+      parent_1.children.push(resource);
+      parent_1.progressChunk = eachChunk;
+
+      for (var i = 0; i < incompleteChildren.length; ++i) {
+        incompleteChildren[i].progressChunk = eachChunk;
+      }
+
+      resource.progressChunk = eachChunk;
+    }
+
+    this._queue.push(resource);
+
+    return this;
+  };
+
+  Loader.prototype.use = function (fn, priority) {
+    if (priority === void 0) {
+      priority = Loader.DefaultMiddlewarePriority;
+    }
+
+    this._middleware.push({
+      fn: fn,
+      priority: priority
+    });
+
+    this._middleware.sort(function (a, b) {
+      return a.priority - b.priority;
+    });
+
+    return this;
+  };
+
+  Loader.prototype.reset = function () {
+    this.progress = 0;
+    this.loading = false;
+
+    this._queue.reset();
+
+    this._queue.pause();
+
+    for (var k in this.resources) {
+      var res = this.resources[k];
+      if (!res) continue;
+      if (res._onCompleteBinding) res._onCompleteBinding.detach();
+      if (res.isLoading) res.abort();
+    }
+
+    this.resources = {};
+    return this;
+  };
+
+  Loader.prototype.load = function (cb) {
+    if (typeof cb === 'function') this.onComplete.once(cb);
+    if (this.loading) return this;
+
+    if (this._queue.idle()) {
+      this._onStart();
+
+      this._onComplete();
+    } else {
+      var numTasks = this._queue.length();
+
+      var chunk = MAX_PROGRESS / numTasks;
+
+      for (var i = 0; i < this._queue.length(); ++i) {
+        this._queue.getTask(i).data.progressChunk = chunk;
+      }
+
+      this._onStart();
+
+      this._queue.resume();
+    }
+
+    return this;
+  };
+
+  Object.defineProperty(Loader.prototype, "concurrency", {
+    get: function get() {
+      return this._queue.concurrency;
+    },
+    set: function set(concurrency) {
+      this._queue.concurrency = concurrency;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  Loader.prototype.addUrlResolver = function (func) {
+    this._urlResolvers.push(func);
+
+    return this;
+  };
+
+  Loader.prototype._prepareUrl = function (url, baseUrl) {
+    var parsed = parseUri(url, {
+      strictMode: true
+    });
+
+    this._urlResolvers.forEach(function (resolver) {
+      url = resolver(url, parsed);
+      parsed = parseUri(url, {
+        strictMode: true
+      });
+    });
+
+    if (!parsed.protocol && url.indexOf('//') !== 0) {
+      if (baseUrl.length && url.charAt(0) !== '/') url = baseUrl + "/" + url;else url = baseUrl + url;
+    }
+
+    if (this.defaultQueryString) {
+      var match = rgxExtractUrlHash.exec(url);
+
+      if (match) {
+        var hash = match[0];
+        url = url.substr(0, url.length - hash.length);
+        if (url.indexOf('?') !== -1) url += "&" + this.defaultQueryString;else url += "?" + this.defaultQueryString;
+        url += hash;
+      }
+    }
+
+    return url;
+  };
+
+  Loader.prototype._loadResource = function (resource, dequeue) {
+    resource._dequeue = dequeue;
+    resource._onCompleteBinding = resource.onComplete.once(this._onLoad, this);
+    resource.load();
+  };
+
+  Loader.prototype._onStart = function () {
+    this.progress = 0;
+    this.loading = true;
+    this.onStart.dispatch(this);
+  };
+
+  Loader.prototype._onComplete = function () {
+    this.progress = MAX_PROGRESS;
+    this.loading = false;
+    this.onComplete.dispatch(this, this.resources);
+  };
+
+  Loader.prototype._onLoad = function (resource) {
+    var _this = this;
+
+    resource._onCompleteBinding = null;
+
+    this._resourcesParsing.push(resource);
+
+    resource._dequeue();
+
+    eachSeries(this._middleware, function (middleware, next) {
+      middleware.fn.call(_this, resource, next);
+    }, function () {
+      resource.onAfterMiddleware.dispatch(resource);
+      _this.progress = Math.min(MAX_PROGRESS, _this.progress + resource.progressChunk);
+
+      _this.onProgress.dispatch(_this, resource);
+
+      if (resource.error) _this.onError.dispatch(resource.error, _this, resource);else _this.onLoad.dispatch(_this, resource);
+
+      _this._resourcesParsing.splice(_this._resourcesParsing.indexOf(resource), 1);
+
+      if (_this._queue.idle() && _this._resourcesParsing.length === 0) _this._onComplete();
+    }, true);
+  };
+
+  Loader.use = function (fn, priority) {
+    if (priority === void 0) {
+      priority = Loader.DefaultMiddlewarePriority;
+    }
+
+    Loader._defaultMiddleware.push({
+      fn: fn,
+      priority: priority
+    });
+
+    Loader._defaultMiddleware.sort(function (a, b) {
+      return a.priority - b.priority;
+    });
+
+    return Loader;
+  };
+
+  Loader.DefaultMiddlewarePriority = 50;
+  Loader._defaultMiddleware = [];
+  return Loader;
+}();
+
+var Progress = function (_super) {
+  __extends$1(Progress, _super);
+
+  function Progress(_a) {
+    var resource = _a.resource,
+        resourceTotal = _a.resourceTotal;
+
+    var _this = _super.call(this) || this;
+
+    _this.progress = 0;
+    _this.resourceTotal = 0;
+    _this.resourceLoadedCount = 0;
+    _this.resource = resource;
+    _this.resourceTotal = resourceTotal;
+
+    if (resourceTotal === 0) {
+      _this.resource.emit(LOAD_EVENT.COMPLETE, _this);
+    }
+
+    return _this;
+  }
+
+  Progress.prototype.onStart = function () {
+    this.resource.emit(LOAD_EVENT.START, this);
+  };
+
+  Progress.prototype.onProgress = function (param) {
+    this.resourceLoadedCount++;
+    this.progress = Math.floor(this.resourceLoadedCount / this.resourceTotal * 100) / 100;
+
+    if (param.success) {
+      this.resource.emit(LOAD_EVENT.LOADED, this, param);
+    } else {
+      this.resource.emit(LOAD_EVENT.ERROR, this, param);
+    }
+
+    this.resource.emit(LOAD_EVENT.PROGRESS, this, param);
+
+    if (this.resourceLoadedCount === this.resourceTotal) {
+      this.resource.emit(LOAD_EVENT.COMPLETE, this);
+    }
+  };
+
+  return Progress;
+}(EventEmitter);
+
+var Progress$1 = Progress;
+var resourceLoader = {
+  AbstractLoadStrategy: AbstractLoadStrategy,
+  AudioLoadStrategy: AudioLoadStrategy,
+  ImageLoadStrategy: ImageLoadStrategy,
+  XhrResponseType: XhrResponseType,
+  MediaElementLoadStrategy: MediaElementLoadStrategy,
+  VideoLoadStrategy: VideoLoadStrategy,
+  XhrLoadStrategy: XhrLoadStrategy,
+  Loader: Loader,
+  Resource: Resource$1,
+  ResourceType: ResourceType,
+  ResourceState: ResourceState
+};
+var LOAD_EVENT;
+
+(function (LOAD_EVENT) {
+  LOAD_EVENT["START"] = "start";
+  LOAD_EVENT["PROGRESS"] = "progress";
+  LOAD_EVENT["LOADED"] = "loaded";
+  LOAD_EVENT["COMPLETE"] = "complete";
+  LOAD_EVENT["ERROR"] = "error";
+})(LOAD_EVENT || (LOAD_EVENT = {}));
+
+var RESOURCE_TYPE;
+
+(function (RESOURCE_TYPE) {
+  RESOURCE_TYPE["IMAGE"] = "IMAGE";
+  RESOURCE_TYPE["SPRITE"] = "SPRITE";
+  RESOURCE_TYPE["SPRITE_ANIMATION"] = "SPRITE_ANIMATION";
+  RESOURCE_TYPE["AUDIO"] = "AUDIO";
+  RESOURCE_TYPE["VIDEO"] = "VIDEO";
+})(RESOURCE_TYPE || (RESOURCE_TYPE = {}));
+
+XhrLoadStrategy.setExtensionXhrType('json', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('tex', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('ske', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('mp3', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('wav', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('aac', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('ogg', XhrResponseType.Buffer);
+var RESOURCE_TYPE_STRATEGY = {
+  png: ImageLoadStrategy,
+  jpg: ImageLoadStrategy,
+  jpeg: ImageLoadStrategy,
+  webp: ImageLoadStrategy,
+  json: XhrLoadStrategy,
+  tex: XhrLoadStrategy,
+  ske: XhrLoadStrategy,
+  audio: XhrLoadStrategy,
+  video: VideoLoadStrategy
+};
+
+var Resource = function (_super) {
+  __extends$1(Resource, _super);
+
+  function Resource(options) {
+    var _this = _super.call(this) || this;
+
+    _this.timeout = 6000;
+    _this.preProcessResourceHandlers = [];
+    _this.resourcesMap = {};
+    _this.makeInstanceFunctions = {};
+    _this.destroyInstanceFunctions = {};
+    _this.promiseMap = {};
+    _this.loaders = [];
+
+    if (options && typeof options.timeout === 'number') {
+      _this.timeout = options.timeout;
+    }
+
+    return _this;
+  }
+
+  Resource.prototype.loadConfig = function (resources) {
+    this.addResource(resources);
+    this.preload();
+  };
+
+  Resource.prototype.loadSingle = function (resource) {
+    this.addResource([resource]);
+    return this.getResource(resource.name);
+  };
+
+  Resource.prototype.addResource = function (resources) {
+    var e_1, _a;
+
+    if (!resources || resources.length < 1) {
+      console.warn('no resources');
+      return;
+    }
+
+    try {
+      for (var resources_1 = __values(resources), resources_1_1 = resources_1.next(); !resources_1_1.done; resources_1_1 = resources_1.next()) {
+        var res = resources_1_1.value;
+
+        if (this.resourcesMap[res.name]) {
+          console.warn(res.name + ' was already added');
+          continue;
+        }
+
+        this.resourcesMap[res.name] = res;
+        this.resourcesMap[res.name].data = {};
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (resources_1_1 && !resources_1_1.done && (_a = resources_1.return)) _a.call(resources_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+  };
+
+  Resource.prototype.addPreProcessResourceHandler = function (handler) {
+    this.preProcessResourceHandlers.push(handler);
+  };
+
+  Resource.prototype.removePreProcessResourceHandler = function (handler) {
+    this.preProcessResourceHandlers.splice(this.preProcessResourceHandlers.indexOf(handler), 1);
+  };
+
+  Resource.prototype.preload = function () {
+    var names = [];
+
+    for (var key in this.resourcesMap) {
+      var resource_1 = this.resourcesMap[key];
+
+      if (resource_1.preload && !resource_1.complete && !this.promiseMap[key]) {
+        names.push(resource_1.name);
+      }
+    }
+
+    this.progress = new Progress$1({
+      resource: this,
+      resourceTotal: names.length
+    });
+    this.loadResource({
+      names: names,
+      preload: true
+    });
+  };
+
+  Resource.prototype.getResource = function (name) {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        this.loadResource({
+          names: [name]
+        });
+        return [2, this.promiseMap[name] || Promise.resolve({})];
+      });
+    });
+  };
+
+  Resource.prototype.instance = function (name) {
+    return __awaiter(this, void 0, void 0, function () {
+      var res, _a;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            res = this.resourcesMap[name];
+            _a = this.makeInstanceFunctions[res.type];
+            if (!_a) return [3, 2];
+            return [4, this.makeInstanceFunctions[res.type](res)];
+
+          case 1:
+            _a = _b.sent();
+            _b.label = 2;
+
+          case 2:
+            return [2, _a];
+        }
+      });
+    });
+  };
+
+  Resource.prototype.destroy = function (name) {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4, this._destroy(name)];
+
+          case 1:
+            _a.sent();
+
+            return [2];
+        }
+      });
+    });
+  };
+
+  Resource.prototype._destroy = function (name, loadError) {
+    if (loadError === void 0) {
+      loadError = false;
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      var resource, e_2;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            resource = this.resourcesMap[name];
+            if (!resource) return [2];
+            if (!!loadError) return [3, 5];
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 4,, 5]);
+
+            if (!this.destroyInstanceFunctions[resource.type]) return [3, 3];
+            return [4, this.destroyInstanceFunctions[resource.type](resource)];
+
+          case 2:
+            _a.sent();
+
+            _a.label = 3;
+
+          case 3:
+            return [3, 5];
+
+          case 4:
+            e_2 = _a.sent();
+            console.warn("destroy resource " + resource.name + " error with '" + e_2.message + "'");
+            return [3, 5];
+
+          case 5:
+            delete this.promiseMap[name];
+            resource.data = {};
+            resource.complete = false;
+            resource.instance = undefined;
+            return [2];
+        }
+      });
+    });
+  };
+
+  Resource.prototype.registerResourceType = function (type, value) {
+    if (value === void 0) {
+      value = type;
+    }
+
+    if (RESOURCE_TYPE[type]) {
+      throw new Error("The type " + type + " already exists in RESOURCE_TYPE");
+    }
+
+    RESOURCE_TYPE[type] = value;
+  };
+
+  Resource.prototype.registerInstance = function (type, callback) {
+    this.makeInstanceFunctions[type] = callback;
+  };
+
+  Resource.prototype.registerDestroy = function (type, callback) {
+    this.destroyInstanceFunctions[type] = callback;
+  };
+
+  Resource.prototype.loadResource = function (_a) {
+    var _this = this;
+
+    var _b = _a.names,
+        names = _b === void 0 ? [] : _b,
+        _c = _a.preload,
+        preload = _c === void 0 ? false : _c;
+    var unLoadNames = names.filter(function (name) {
+      return !_this.promiseMap[name] && _this.resourcesMap[name];
+    });
+    if (!unLoadNames.length) return;
+    var resolves = {};
+    var loader = this.getLoader(preload);
+    unLoadNames.forEach(function (name) {
+      var e_3, _a;
+
+      _this.promiseMap[name] = new Promise(function (r) {
+        return resolves[name] = r;
+      });
+      var res = _this.resourcesMap[name];
+
+      try {
+        for (var _b = __values(_this.preProcessResourceHandlers), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var handler = _c.value;
+          handler(res);
+        }
+      } catch (e_3_1) {
+        e_3 = {
+          error: e_3_1
+        };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_3) throw e_3.error;
+        }
+      }
+
+      for (var key in res.src) {
+        var resourceType = res.src[key].type;
+
+        if (resourceType === 'data') {
+          res.data[key] = res.src[key].data;
+
+          _this.doComplete(name, resolves[name], preload);
+        } else {
+          loader.add({
+            url: res.src[key].url,
+            name: res.name + "_" + key,
+            strategy: RESOURCE_TYPE_STRATEGY[resourceType],
+            metadata: {
+              key: key,
+              name: res.name,
+              resolves: resolves
+            }
+          });
+        }
+      }
+    });
+    loader.load();
+  };
+
+  Resource.prototype.doComplete = function (name, resolve, preload) {
+    if (preload === void 0) {
+      preload = false;
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      var res, param, _a, err_1;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            res = this.resourcesMap[name];
+            param = {
+              name: name,
+              resource: this.resourcesMap[name],
+              success: true
+            };
+            if (!this.checkAllLoaded(name)) return [3, 4];
+            _b.label = 1;
+
+          case 1:
+            _b.trys.push([1, 3,, 4]);
+
+            _a = res;
+            return [4, this.instance(name)];
+
+          case 2:
+            _a.instance = _b.sent();
+            res.complete = true;
+
+            if (preload) {
+              this.progress.onProgress(param);
+            }
+
+            resolve(res);
+            return [3, 4];
+
+          case 3:
+            err_1 = _b.sent();
+            console.error(err_1);
+            res.complete = false;
+
+            if (preload) {
+              param.errMsg = err_1.message;
+              param.success = false;
+              this.progress.onProgress(param);
+            }
+
+            resolve({});
+            return [3, 4];
+
+          case 4:
+            return [2];
+        }
+      });
+    });
+  };
+
+  Resource.prototype.checkAllLoaded = function (name) {
+    var res = this.resourcesMap[name];
+    return Array.from(Object.keys(res.src)).every(function (resourceKey) {
+      return res.data[resourceKey];
+    });
+  };
+
+  Resource.prototype.getLoader = function (preload) {
+    var _this = this;
+
+    if (preload === void 0) {
+      preload = false;
+    }
+
+    var loader = this.loaders.find(function (_a) {
+      var loading = _a.loading;
+      return !loading;
+    });
+
+    if (!loader) {
+      loader = new Loader();
+      this.loaders.push(loader);
+    }
+
+    if (preload) {
+      loader.onStart.once(function () {
+        _this.progress.onStart();
+      });
+    }
+
+    loader.onLoad.add(function (_, resource) {
+      _this.onLoad({
+        preload: preload,
+        resource: resource
+      });
+    });
+    loader.onError.add(function (errMsg, _, resource) {
+      _this.onError({
+        errMsg: errMsg,
+        resource: resource,
+        preload: preload
+      });
+    });
+    loader.onComplete.once(function () {
+      loader.onLoad.detachAll();
+      loader.onError.detachAll();
+      loader.reset();
+    });
+    return loader;
+  };
+
+  Resource.prototype.onLoad = function (_a) {
+    var _b = _a.preload,
+        preload = _b === void 0 ? false : _b,
+        resource = _a.resource;
+    return __awaiter(this, void 0, void 0, function () {
+      var _c, key, name, resolves, data, res;
+
+      return __generator(this, function (_d) {
+        _c = resource.metadata, key = _c.key, name = _c.name, resolves = _c.resolves, data = resource.data;
+        res = this.resourcesMap[name];
+        res.data[key] = data;
+        this.doComplete(name, resolves[name], preload);
+        return [2];
+      });
+    });
+  };
+
+  Resource.prototype.onError = function (_a) {
+    var errMsg = _a.errMsg,
+        _b = _a.preload,
+        preload = _b === void 0 ? false : _b,
+        resource = _a.resource;
+    return __awaiter(this, void 0, void 0, function () {
+      var _c, name, resolves, param;
+
+      return __generator(this, function (_d) {
+        _c = resource.metadata, name = _c.name, resolves = _c.resolves;
+
+        this._destroy(name, true);
+
+        resolves[name]({});
+
+        if (preload) {
+          param = {
+            name: name,
+            resource: this.resourcesMap[name],
+            success: false,
+            errMsg: errMsg
+          };
+          this.progress.onProgress(param);
+        }
+
+        return [2];
+      });
+    });
+  };
+
+  return Resource;
+}(EventEmitter);
+
+var resource = new Resource();
+var decorators = {
+  IDEProp: IDEProp,
+  componentObserver: componentObserver
+};
+var version = '1.2.8-alpha.0';
+console.log("Eva.js version: " + version);
+export { Component$1 as Component, Game$1 as Game, GameObject$1 as GameObject, IDEProp, LOAD_EVENT, LOAD_SCENE_MODE, ObserverType as OBSERVER_TYPE, RESOURCE_TYPE, RESOURCE_TYPE_STRATEGY, Scene$1 as Scene, System$1 as System, Transform$1 as Transform, componentObserver, decorators, resource, resourceLoader, version };