@eva/eva.js 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/eva.js.cjs.js

@@ -12,113 +12,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(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 __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __values(o) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
-    if (m) return m.call(o);
-    return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
-}
-
 function getComponentName(component) {
     if (component instanceof Component) {
         return component.name;
@@ -127,17 +20,14 @@ function getComponentName(component) {
         return component.componentName;
     }
 }
-var Component = (function (_super) {
-    __extends(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__default));
+class Component extends EventEmitter__default {
+    constructor(params) {
+        super();
+        this.started = false;
+        this.name = this.constructor.componentName;
+        this.__componentDefaultParams = params;
+    }
+}
 var Component$1 = Component;
 
 exports.OBSERVER_TYPE = void 0;
@@ -146,25 +36,25 @@ exports.OBSERVER_TYPE = void 0;
     ObserverType["REMOVE"] = "REMOVE";
     ObserverType["CHANGE"] = "CHANGE";
 })(exports.OBSERVER_TYPE || (exports.OBSERVER_TYPE = {}));
-var objectCache = {};
-var systemInstance = {};
-var observerInfos = {};
-var componentProps = {};
+const objectCache = {};
+const systemInstance = {};
+const observerInfos = {};
+const 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(',');
+    const cache = objectCache[component.gameObject.id];
+    const 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++) {
+    const keyIndex = keys.length - 1;
+    let property = component;
+    for (let i = 0; i < keyIndex; i++) {
         property = property[keys[i]];
     }
-    cache[key] = { property: property, key: keys[keyIndex] };
+    cache[key] = { property, key: keys[keyIndex] };
     return cache[key];
 }
 function removeObjectCache(component) {
@@ -172,83 +62,69 @@ function removeObjectCache(component) {
         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 addObserver({ systemName, componentName, component, prop, type }) {
+    var _a, _b;
+    (_b = (_a = systemInstance[systemName]) === null || _a === void 0 ? void 0 : _a.componentObserver) === null || _b === void 0 ? void 0 : _b.add({
+        component,
+        prop,
+        type,
+        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];
+function pushToQueue({ prop, component, componentName, }) {
+    for (const systemName in observerInfos) {
+        const observerInfo = observerInfos[systemName] || {};
+        const info = observerInfo[componentName];
         if (!info)
             continue;
-        var index = info.findIndex(function (p) {
+        const index = info.findIndex(p => {
             return lodashEs.isEqual(p, prop);
         });
         if (index > -1) {
             addObserver({
-                systemName: systemName,
-                componentName: componentName,
-                component: component,
-                prop: prop,
+                systemName,
+                componentName,
+                component,
+                prop,
                 type: exports.OBSERVER_TYPE.CHANGE,
             });
         }
     }
 }
-function defineProperty(_a) {
-    var e_1, _b;
-    var obj = _a.obj, key = _a.key, prop = _a.prop, component = _a.component, componentName = _a.componentName;
+function defineProperty({ obj, key, prop, component, componentName, }) {
     if (obj === undefined) {
         return;
     }
     if (!(key in obj)) {
-        console.error("prop " + key + " not in component: " + componentName + ", Can not observer");
+        console.error(`prop ${key} not in component: ${componentName}, Can not observer`);
         return;
     }
-    Object.defineProperty(obj, "_" + key, {
+    Object.defineProperty(obj, `_${key}`, {
         enumerable: false,
         writable: true,
         value: obj[key],
     });
     if (prop.deep && lodashEs.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; }
+        for (const childKey of Object.keys(obj[key])) {
+            defineProperty({
+                obj: obj[key],
+                key: childKey,
+                prop,
+                component,
+                componentName,
+            });
         }
     }
     Object.defineProperty(obj, key, {
         enumerable: true,
-        set: function (val) {
-            if (obj["_" + key] === val)
+        set(val) {
+            if (obj[`_${key}`] === val)
                 return;
-            obj["_" + key] = val;
-            pushToQueue({ prop: prop, component: component, componentName: componentName });
+            obj[`_${key}`] = val;
+            pushToQueue({ prop, component, componentName });
         },
-        get: function () {
-            return obj["_" + key];
+        get() {
+            return obj[`_${key}`];
         },
     });
 }
@@ -256,55 +132,29 @@ function isComponent(comp) {
     return comp && comp.constructor && 'componentName' in comp.constructor;
 }
 function initObserver(Systems) {
-    var e_2, _a, e_3, _b;
-    var Ss = [];
+    const Ss = [];
     if (Systems instanceof Array) {
-        Ss.push.apply(Ss, __spread(Systems));
+        Ss.push(...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 (prop) {
-                    var index = props.findIndex(function (p) {
-                        return lodashEs.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; }
+    for (const S of Ss) {
+        for (const componentName in S.observerInfo) {
+            componentProps[componentName] = componentProps[componentName] || [];
+            const props = componentProps[componentName];
+            for (const prop of S.observerInfo[componentName]) {
+                const index = props.findIndex(p => {
+                    return lodashEs.isEqual(p, prop);
+                });
+                if (index === -1) {
+                    componentProps[componentName].push(prop);
                 }
             }
         }
     }
-    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; }
+function observer(component, componentName = component.name) {
     if (!componentName || !componentProps[componentName]) {
         return;
     }
@@ -314,53 +164,41 @@ function observer(component, componentName) {
     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; }
+    for (const item of componentProps[componentName]) {
+        const { property, key } = getObjectCache(component, item.prop);
+        defineProperty({
+            obj: property,
+            key,
+            prop: item,
+            component,
+            componentName,
+        });
     }
 }
-function observerAdded(component, componentName) {
+function observerAdded(component, componentName = component.name) {
     var _a, _b;
-    if (componentName === void 0) { componentName = component.name; }
-    for (var systemName in observerInfos) {
-        var observerInfo = observerInfos[systemName] || {};
-        var info = observerInfo[componentName];
+    for (const systemName in observerInfos) {
+        const observerInfo = observerInfos[systemName] || {};
+        const 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,
+                component,
                 type: exports.OBSERVER_TYPE.ADD,
-                componentName: componentName,
+                componentName,
             });
         }
     }
 }
-function observerRemoved(component, componentName) {
+function observerRemoved(component, componentName = component.name) {
     var _a, _b;
-    if (componentName === void 0) { componentName = component.name; }
-    for (var systemName in observerInfos) {
-        var observerInfo = observerInfos[systemName] || {};
-        var info = observerInfo[componentName];
+    for (const systemName in observerInfos) {
+        const observerInfo = observerInfos[systemName] || {};
+        const 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,
+                component,
                 type: exports.OBSERVER_TYPE.REMOVE,
-                componentName: componentName,
+                componentName,
             });
         }
     }
@@ -371,60 +209,73 @@ function setSystemObserver(system, S) {
     systemInstance[S.systemName] = system;
 }
 
-var Transform = (function (_super) {
-    __extends(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;
-                Object.assign(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; }
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class Transform extends Component$1 {
+    constructor() {
+        super(...arguments);
+        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;
+    }
+    init(params = {}) {
+        const props = ['position', 'size', 'origin', 'anchor', 'scale', 'skew'];
+        for (const key of props) {
+            Object.assign(this[key], params[key]);
         }
         this.rotation = params.rotation || this.rotation;
-    };
-    Object.defineProperty(Transform.prototype, "parent", {
-        get: function () {
-            return this._parent;
-        },
-        set: function (val) {
-            if (val) {
-                val.addChild(this);
-            }
-            else if (this.parent) {
-                this.parent.removeChild(this);
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Transform.prototype.addChild = function (child) {
+    }
+    set parent(val) {
+        if (val) {
+            val.addChild(this);
+        }
+        else if (this.parent) {
+            this.parent.removeChild(this);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    addChild(child) {
         if (child.parent === this) {
-            var index = this.children.findIndex(function (item) { return item === child; });
+            const index = this.children.findIndex(item => item === child);
             this.children.splice(index, 1);
         }
         else if (child.parent) {
@@ -432,56 +283,55 @@ var Transform = (function (_super) {
         }
         child._parent = this;
         this.children.push(child);
-    };
-    Transform.prototype.removeChild = function (child) {
-        var index = this.children.findIndex(function (item) { return item === child; });
+    }
+    removeChild(child) {
+        const index = this.children.findIndex(item => item === child);
         if (index > -1) {
             this.children.splice(index, 1);
             child._parent = null;
         }
-    };
-    Transform.prototype.clearChildren = function () {
+    }
+    clearChildren() {
         this.children.length = 0;
-    };
-    Transform.componentName = 'Transform';
-    __decorate([
-        inspectorDecorator.type('vector2'),
-        inspectorDecorator.step(1)
-    ], Transform.prototype, "position", void 0);
-    __decorate([
-        inspectorDecorator.type('size'),
-        inspectorDecorator.step(1)
-    ], Transform.prototype, "size", void 0);
-    __decorate([
-        inspectorDecorator.type('vector2'),
-        inspectorDecorator.step(0.1)
-    ], Transform.prototype, "origin", void 0);
-    __decorate([
-        inspectorDecorator.type('vector2'),
-        inspectorDecorator.step(0.1)
-    ], Transform.prototype, "anchor", void 0);
-    __decorate([
-        inspectorDecorator.type('vector2'),
-        inspectorDecorator.step(0.1)
-    ], Transform.prototype, "scale", void 0);
-    __decorate([
-        inspectorDecorator.type('vector2'),
-        inspectorDecorator.step(0.1)
-    ], Transform.prototype, "skew", void 0);
-    __decorate([
-        inspectorDecorator.type('number'),
-        inspectorDecorator.step(0.1)
-    ], Transform.prototype, "rotation", void 0);
-    return Transform;
-}(Component$1));
+    }
+}
+Transform.componentName = 'Transform';
+__decorate([
+    inspectorDecorator.type('vector2'),
+    inspectorDecorator.step(1)
+], Transform.prototype, "position", void 0);
+__decorate([
+    inspectorDecorator.type('size'),
+    inspectorDecorator.step(1)
+], Transform.prototype, "size", void 0);
+__decorate([
+    inspectorDecorator.type('vector2'),
+    inspectorDecorator.step(0.1)
+], Transform.prototype, "origin", void 0);
+__decorate([
+    inspectorDecorator.type('vector2'),
+    inspectorDecorator.step(0.1)
+], Transform.prototype, "anchor", void 0);
+__decorate([
+    inspectorDecorator.type('vector2'),
+    inspectorDecorator.step(0.1)
+], Transform.prototype, "scale", void 0);
+__decorate([
+    inspectorDecorator.type('vector2'),
+    inspectorDecorator.step(0.1)
+], Transform.prototype, "skew", void 0);
+__decorate([
+    inspectorDecorator.type('number'),
+    inspectorDecorator.step(0.1)
+], Transform.prototype, "rotation", void 0);
 var Transform$1 = Transform;
 
-var _id = 0;
+let _id = 0;
 function getId() {
     return ++_id;
 }
-var GameObject = (function () {
-    function GameObject(name, obj) {
+class GameObject {
+    constructor(name, obj) {
         this._componentCache = {};
         this.components = [];
         this.destroyed = false;
@@ -489,89 +339,62 @@ var GameObject = (function () {
         this.id = getId();
         this.addComponent(Transform$1, obj);
     }
-    Object.defineProperty(GameObject.prototype, "transform", {
-        get: function () {
-            return this.getComponent(Transform$1);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GameObject.prototype, "parent", {
-        get: function () {
-            return this.transform && this.transform.parent && this.transform.parent.gameObject;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GameObject.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GameObject.prototype, "scene", {
-        get: function () {
-            return this._scene;
-        },
-        set: function (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);
+    get transform() {
+        return this.getComponent(Transform$1);
+    }
+    get parent() {
+        return this.transform && this.transform.parent && this.transform.parent.gameObject;
+    }
+    get name() {
+        return this._name;
+    }
+    set scene(val) {
+        if (this._scene === val)
+            return;
+        const scene = this._scene;
+        this._scene = val;
+        if (this.transform && this.transform.children) {
+            for (const child of this.transform.children) {
+                child.gameObject.scene = val;
             }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    GameObject.prototype.addChild = function (gameObject) {
+        }
+        if (val) {
+            val.addGameObject(this);
+        }
+        else {
+            scene && scene.removeGameObject(this);
+        }
+    }
+    get scene() {
+        return this._scene;
+    }
+    addChild(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");
+            throw new Error(`gameObject '${this.name}' has been destroy`);
         }
         gameObject.transform.parent = this.transform;
         gameObject.scene = this.scene;
-    };
-    GameObject.prototype.removeChild = function (gameObject) {
+    }
+    removeChild(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) {
+    }
+    addComponent(C, obj) {
         if (this.destroyed)
             return;
-        var componentName = getComponentName(C);
+        const componentName = getComponentName(C);
         if (this._componentCache[componentName])
             return;
-        var component;
+        let component;
         if (C instanceof Function) {
             component = new C(obj);
         }
@@ -582,7 +405,7 @@ var GameObject = (function () {
             throw new Error('addComponent recieve Component and Component Constructor');
         }
         if (component.gameObject) {
-            throw new Error("component has been added on gameObject " + component.gameObject.name);
+            throw new Error(`component has been added on gameObject ${component.gameObject.name}`);
         }
         component.gameObject = this;
         component.init && component.init(component.__componentDefaultParams);
@@ -592,9 +415,9 @@ var GameObject = (function () {
         this._componentCache[componentName] = component;
         component.awake && component.awake();
         return component;
-    };
-    GameObject.prototype.removeComponent = function (c) {
-        var componentName;
+    }
+    removeComponent(c) {
+        let componentName;
         if (typeof c === 'string') {
             componentName = c;
         }
@@ -608,24 +431,21 @@ var GameObject = (function () {
             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;
-        });
+    }
+    _removeComponent(componentName) {
+        const index = this.components.findIndex(({ name }) => name === componentName);
         if (index === -1)
             return;
-        var component = this.components.splice(index, 1)[0];
+        const 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;
+    }
+    getComponent(c) {
+        let componentName;
         if (typeof c === 'string') {
             componentName = c;
         }
@@ -641,111 +461,102 @@ var GameObject = (function () {
         else {
             return;
         }
-    };
-    GameObject.prototype.remove = function () {
+    }
+    remove() {
         if (this.parent)
             return this.parent.removeChild(this);
-    };
-    GameObject.prototype.destroy = function () {
+    }
+    destroy() {
         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;
+        Array.from(this.transform.children).forEach(({ gameObject }) => {
             gameObject.destroy();
         });
         this.remove();
         this.transform.clearChildren();
-        for (var key in this._componentCache) {
+        for (const 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() {
+class ComponentObserver {
+    constructor() {
         this.events = [];
     }
-    ComponentObserver.prototype.add = function (_a) {
-        var component = _a.component, prop = _a.prop, type = _a.type, componentName = _a.componentName;
+    add({ component, prop, type, componentName }) {
         if (type === exports.OBSERVER_TYPE.REMOVE) {
-            if (this.events.find(function (changed) { return changed.component === component && changed.type === exports.OBSERVER_TYPE.ADD; })) {
-                this.events = this.events.filter(function (changed) { return changed.component !== component; });
+            if (this.events.find((changed) => changed.component === component && changed.type === exports.OBSERVER_TYPE.ADD)) {
+                this.events = this.events.filter(changed => changed.component !== component);
                 return;
             }
-            this.events = this.events.filter(function (changed) { return changed.component !== component; });
+            this.events = this.events.filter(changed => changed.component !== component);
         }
-        var index = this.events.findIndex(function (changed) { return changed.component === component && lodashEs.isEqual(changed.prop, prop) && changed.type === type; });
+        const index = this.events.findIndex(changed => changed.component === component && lodashEs.isEqual(changed.prop, prop) && changed.type === type);
         if (index > -1) {
             this.events.splice(index, 1);
         }
         this.events.push({
             gameObject: component.gameObject,
-            component: component,
+            component,
             prop: prop,
-            type: type,
-            componentName: componentName,
+            type,
+            componentName,
         });
-    };
-    ComponentObserver.prototype.getChanged = function () {
+    }
+    getChanged() {
         return this.events;
-    };
-    Object.defineProperty(ComponentObserver.prototype, "changed", {
-        get: function () {
-            return this.events;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ComponentObserver.prototype.clear = function () {
-        var events = this.events;
+    }
+    get changed() {
+        return this.events;
+    }
+    clear() {
+        const events = this.events;
         this.events = [];
         return events;
-    };
-    return ComponentObserver;
-}());
+    }
+}
 var ComponentObserver$1 = ComponentObserver;
 
-var System = (function () {
-    function System(params) {
+class System {
+    constructor(params) {
         this.started = false;
         this.componentObserver = new ComponentObserver$1();
         this.__systemDefaultParams = params;
         this.name = this.constructor.systemName;
     }
-    System.prototype.destroy = function () {
+    destroy() {
         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;
+    let nowtime = null;
     if (Date.now) {
         nowtime = Date.now;
     }
     else {
-        nowtime = function () { return new Date().getTime(); };
+        nowtime = () => new Date().getTime();
     }
     return nowtime;
 }
 
-var _nowtime = createNowTime();
-var defaultOptions$1 = {
+const _nowtime = createNowTime();
+const defaultOptions$1 = {
     originTime: 0,
     playbackRate: 1.0,
 };
-var Timeline = (function () {
-    function Timeline(options, parent) {
+class Timeline {
+    constructor(options, parent) {
         if (options instanceof Timeline) {
             parent = options;
             options = {};
@@ -769,97 +580,72 @@ var Timeline = (function () {
         }
         this._playbackRate = options.playbackRate;
     }
-    Object.defineProperty(Timeline.prototype, "globalTime", {
-        get: function () {
-            return this.parent ? this.parent.currentTime : _nowtime() - this._createTime;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Timeline.prototype, "parent", {
-        get: function () {
-            return this._parent;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Timeline.prototype, "lastTimeMark", {
-        get: function () {
-            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 = {
+    get globalTime() {
+        return this.parent ? this.parent.currentTime : _nowtime() - this._createTime;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get lastTimeMark() {
+        return this._timeMark[this._timeMark.length - 1];
+    }
+    markTime({ time = this.currentTime, entropy = this.entropy, playbackRate = this.playbackRate } = {}) {
+        const timeMark = {
             globalTime: this.globalTime,
             localTime: time,
-            entropy: entropy,
-            playbackRate: playbackRate,
+            entropy,
+            playbackRate,
             globalEntropy: this.globalEntropy,
         };
         this._timeMark.push(timeMark);
-    };
-    Object.defineProperty(Timeline.prototype, "currentTime", {
-        get: function () {
-            var _a = this.lastTimeMark, localTime = _a.localTime, globalTime = _a.globalTime;
-            return localTime + (this.globalTime - globalTime) * this.playbackRate;
-        },
-        set: function (time) {
-            this.markTime({ time: time });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Timeline.prototype, "globalEntropy", {
-        get: function () {
-            return this._parent ? this._parent.entropy : this.globalTime;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Timeline.prototype, "entropy", {
-        get: function () {
-            var _a = this.lastTimeMark, entropy = _a.entropy, globalEntropy = _a.globalEntropy;
-            return entropy + Math.abs((this.globalEntropy - globalEntropy) * this.playbackRate);
-        },
-        set: function (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) {
+    }
+    get currentTime() {
+        const { localTime, globalTime } = this.lastTimeMark;
+        return localTime + (this.globalTime - globalTime) * this.playbackRate;
+    }
+    set currentTime(time) {
+        this.markTime({ time });
+    }
+    get globalEntropy() {
+        return this._parent ? this._parent.entropy : this.globalTime;
+    }
+    get entropy() {
+        const { entropy, globalEntropy } = this.lastTimeMark;
+        return entropy + Math.abs((this.globalEntropy - globalEntropy) * this.playbackRate);
+    }
+    set entropy(entropy) {
+        if (this.entropy > entropy) {
+            const idx = this.seekTimeMark(entropy);
+            this._timeMark.length = idx + 1;
+        }
+        this.markTime({ entropy });
+    }
+    fork(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;
+    }
+    seekGlobalTime(seekEntropy) {
+        const idx = this.seekTimeMark(seekEntropy), timeMark = this._timeMark[idx];
+        const { entropy, playbackRate, globalTime } = timeMark;
         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;
+    }
+    seekLocalTime(seekEntropy) {
+        const idx = this.seekTimeMark(seekEntropy), timeMark = this._timeMark[idx];
+        const { localTime, entropy, playbackRate } = timeMark;
         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;
+    }
+    seekTimeMark(entropy) {
+        const timeMark = this._timeMark;
+        let 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);
+        let m = Math.floor((l + r) / 2);
         while (m > l && m < r) {
             if (entropy === timeMark[m].entropy) {
                 return m;
@@ -873,46 +659,36 @@ var Timeline = (function () {
             m = Math.floor((l + r) / 2);
         }
         return l;
-    };
-    Object.defineProperty(Timeline.prototype, "playbackRate", {
-        get: function () {
-            return this._playbackRate;
-        },
-        set: function (rate) {
-            if (rate !== this.playbackRate) {
-                this.markTime({ playbackRate: rate });
-                this._playbackRate = rate;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Timeline.prototype, "paused", {
-        get: function () {
-            if (this.playbackRate === 0)
+    }
+    get playbackRate() {
+        return this._playbackRate;
+    }
+    set playbackRate(rate) {
+        if (rate !== this.playbackRate) {
+            this.markTime({ playbackRate: rate });
+            this._playbackRate = rate;
+        }
+    }
+    get paused() {
+        if (this.playbackRate === 0)
+            return true;
+        let parent = this.parent;
+        while (parent) {
+            if (parent.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;
-}());
+            parent = parent.parent;
+        }
+        return false;
+    }
+}
 var Timeline$1 = Timeline;
 
-var defaultOptions = {
+const defaultOptions = {
     autoStart: true,
     frameRate: 60,
 };
-var Ticker = (function () {
-    function Ticker(options) {
-        var _this = this;
+class Ticker {
+    constructor(options) {
         options = Object.assign({}, defaultOptions, options);
         this._frameCount = 0;
         this._frameDuration = 1000 / options.frameRate;
@@ -922,103 +698,88 @@ var Ticker = (function () {
         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();
+        this._ticker = () => {
+            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;
+    update() {
+        const currentTime = this.timeline.currentTime;
+        const durationTime = currentTime - this._lastFrameTime;
         if (durationTime >= this._frameDuration) {
-            var frameTime = currentTime - (durationTime % this._frameDuration);
-            var deltaTime = frameTime - this._lastFrameTime;
+            const frameTime = currentTime - (durationTime % this._frameDuration);
+            const deltaTime = frameTime - this._lastFrameTime;
             this._lastFrameTime = frameTime;
-            var options = {
-                deltaTime: deltaTime,
+            const options = {
+                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);
-                    }
+            for (const func of this._tickers) {
+                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) {
+    }
+    add(fn) {
         this._tickers.add(fn);
-    };
-    Ticker.prototype.remove = function (fn) {
+    }
+    remove(fn) {
         this._tickers.delete(fn);
-    };
-    Ticker.prototype.start = function () {
+    }
+    start() {
         if (this._started)
             return;
         this._started = true;
         this.timeline.playbackRate = 1.0;
         this._requestId = requestAnimationFrame(this._ticker);
-    };
-    Ticker.prototype.pause = function () {
+    }
+    pause() {
         this._started = false;
         this.timeline.playbackRate = 0;
-    };
-    Ticker.prototype.setPlaybackRate = function (rate) {
+    }
+    setPlaybackRate(rate) {
         this.timeline.playbackRate = rate;
-    };
-    return Ticker;
-}());
+    }
+}
 var Ticker$1 = Ticker;
 
-var Scene = (function (_super) {
-    __extends(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) {
+class Scene extends GameObject$1 {
+    constructor(name, obj) {
+        super(name, obj);
+        this.gameObjects = [];
+        this.scene = this;
+    }
+    addGameObject(gameObject) {
         this.gameObjects.push(gameObject);
         if (gameObject.transform) {
             gameObject.transform.inScene = true;
         }
-    };
-    Scene.prototype.removeGameObject = function (gameObject) {
-        var index = this.gameObjects.indexOf(gameObject);
+    }
+    removeGameObject(gameObject) {
+        const 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 () {
+    }
+    destroy() {
         this.scene = null;
-        _super.prototype.destroy.call(this);
+        super.destroy();
         this.gameObjects = null;
         this.canvas = null;
-    };
-    return Scene;
-}(GameObject$1));
+    }
+}
 var Scene$1 = Scene;
 
 exports.LOAD_SCENE_MODE = void 0;
@@ -1026,7 +787,7 @@ exports.LOAD_SCENE_MODE = void 0;
     LOAD_SCENE_MODE["SINGLE"] = "SINGLE";
     LOAD_SCENE_MODE["MULTI_CANVAS"] = "MULTI_CANVAS";
 })(exports.LOAD_SCENE_MODE || (exports.LOAD_SCENE_MODE = {}));
-var triggerStart = function (obj) {
+const triggerStart = (obj) => {
     if (!(obj instanceof System$1) && !(obj instanceof Component$1))
         return;
     if (obj.started)
@@ -1037,312 +798,161 @@ var triggerStart = function (obj) {
     }
     catch (e) {
         if (obj instanceof Component$1) {
-            console.error(obj.constructor.componentName + " start error", e);
+            console.error(`${obj.constructor.componentName} start error`, e);
         }
         else {
-            console.error(obj.constructor.systemName + " start error", e);
+            console.error(`${obj.constructor.systemName} start error`, e);
         }
     }
 };
-var getAllGameObjects = function (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);
-        }
+const getAllGameObjects = game => {
+    var _a;
+    const mainSceneGameObjects = ((_a = game === null || game === void 0 ? void 0 : game.scene) === null || _a === void 0 ? void 0 : _a.gameObjects) || [];
+    const gameObjectsArray = game === null || game === void 0 ? void 0 : game.multiScenes.map(({ gameObjects }) => gameObjects);
+    let otherSceneGameObjects = [];
+    for (const gameObjects of gameObjectsArray) {
+        otherSceneGameObjects = [...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);
+    return [...mainSceneGameObjects, ...otherSceneGameObjects];
 };
-var gameObjectLoop = function (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;
+const gameObjectLoop = (e, gameObjects = []) => {
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
             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);
-                    }
-                }
+                triggerStart(component);
+                component.update && component.update(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) {
+                console.error(`gameObject: ${gameObject.name} ${component.name} update error`, e);
             }
         }
     }
-    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;
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
             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);
-                    }
-                }
+                component.lateUpdate && component.lateUpdate(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) {
+                console.error(`gameObject: ${gameObject.name} ${component.name} lateUpdate error`, e);
             }
         }
     }
-    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 (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;
+const gameObjectResume = gameObjects => {
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
             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);
-                    }
-                }
+                component.onResume && component.onResume();
             }
-            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) {
+                console.error(`gameObject: ${gameObject.name}, ${component.name}, onResume error`, e);
             }
         }
     }
-    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 (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;
+const gameObjectPause = gameObjects => {
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
             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);
-                    }
-                }
+                component.onPause && component.onPause();
             }
-            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) {
+                console.error(`gameObject: ${gameObject.name}, ${component.name}, onResume error`, e);
             }
         }
     }
-    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(Game, _super);
-    function Game() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.playing = false;
-        _this.started = false;
-        _this.multiScenes = [];
-        _this.systems = [];
-        return _this;
-    }
-    Game.prototype.init = function (_a) {
-        var _b = _a === void 0 ? {} : _a, systems = _b.systems, _c = _b.frameRate, frameRate = _c === void 0 ? 60 : _c, _d = _b.autoStart, autoStart = _d === void 0 ? true : _d, _e = _b.needScene, needScene = _e === void 0 ? true : _e;
-        return __awaiter(this, void 0, void 0, function () {
-            var systems_1, systems_1_1, system, e_10_1;
-            var e_10, _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        if (window.__EVA_INSPECTOR_ENV__) {
-                            window.__EVA_GAME_INSTANCE__ = this;
-                        }
-                        this.ticker = new Ticker$1({ autoStart: false, frameRate: frameRate });
-                        this.initTicker();
-                        if (!(systems && systems.length)) return [3, 8];
-                        _g.label = 1;
-                    case 1:
-                        _g.trys.push([1, 6, 7, 8]);
-                        systems_1 = __values(systems), systems_1_1 = systems_1.next();
-                        _g.label = 2;
-                    case 2:
-                        if (!!systems_1_1.done) return [3, 5];
-                        system = systems_1_1.value;
-                        return [4, this.addSystem(system)];
-                    case 3:
-                        _g.sent();
-                        _g.label = 4;
-                    case 4:
-                        systems_1_1 = systems_1.next();
-                        return [3, 2];
-                    case 5: return [3, 8];
-                    case 6:
-                        e_10_1 = _g.sent();
-                        e_10 = { error: e_10_1 };
-                        return [3, 8];
-                    case 7:
-                        try {
-                            if (systems_1_1 && !systems_1_1.done && (_f = systems_1.return)) _f.call(systems_1);
-                        }
-                        finally { if (e_10) throw e_10.error; }
-                        return [7];
-                    case 8:
-                        if (needScene) {
-                            this.loadScene(new Scene$1('scene'));
-                        }
-                        if (autoStart) {
-                            this.start();
-                        }
-                        return [2];
+class Game extends EventEmitter__default {
+    constructor() {
+        super(...arguments);
+        this.playing = false;
+        this.started = false;
+        this.multiScenes = [];
+        this.systems = [];
+    }
+    init({ systems, frameRate = 60, autoStart = true, needScene = true } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (window.__EVA_INSPECTOR_ENV__) {
+                window.__EVA_GAME_INSTANCE__ = this;
+            }
+            this.ticker = new Ticker$1({ autoStart: false, frameRate });
+            this.initTicker();
+            if (systems && systems.length) {
+                for (const system of systems) {
+                    yield this.addSystem(system);
                 }
-            });
+            }
+            if (needScene) {
+                this.loadScene(new Scene$1('scene'));
+            }
+            if (autoStart) {
+                this.start();
+            }
         });
-    };
-    Object.defineProperty(Game.prototype, "scene", {
-        get: function () {
-            return this._scene;
-        },
-        set: function (scene) {
-            this._scene = scene;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Game.prototype, "gameObjects", {
-        get: function () {
-            return getAllGameObjects(this);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Game.prototype.addSystem = function (S, obj) {
-        return __awaiter(this, void 0, void 0, function () {
-            var system, hasTheSystem, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (S instanceof Function) {
-                            system = new S(obj);
-                        }
-                        else if (S instanceof System$1) {
-                            system = S;
-                        }
-                        else {
-                            console.warn('can only add System');
-                            return [2];
-                        }
-                        hasTheSystem = this.systems.find(function (item) {
-                            return item.constructor === system.constructor;
-                        });
-                        if (hasTheSystem) {
-                            console.warn(system.constructor.systemName + " System has been added");
-                            return [2];
-                        }
-                        system.game = this;
-                        _a = system.init;
-                        if (!_a) return [3, 2];
-                        return [4, system.init(system.__systemDefaultParams)];
-                    case 1:
-                        _a = (_b.sent());
-                        _b.label = 2;
-                    case 2:
-                        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 [2, system];
-                }
+    }
+    get scene() {
+        return this._scene;
+    }
+    set scene(scene) {
+        this._scene = scene;
+    }
+    get gameObjects() {
+        return getAllGameObjects(this);
+    }
+    addSystem(S, obj) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let 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;
+            }
+            const hasTheSystem = this.systems.find(item => {
+                return item.constructor === system.constructor;
             });
+            if (hasTheSystem) {
+                console.warn(`${system.constructor.systemName} System has been added`);
+                return;
+            }
+            system.game = this;
+            system.init && (yield 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) {
+    }
+    removeSystem(system) {
         if (!system)
             return;
-        var index = -1;
+        let index = -1;
         if (typeof system === 'string') {
-            index = this.systems.findIndex(function (s) { return s.name === system; });
+            index = this.systems.findIndex(s => s.name === system);
         }
         else if (system instanceof Function) {
-            index = this.systems.findIndex(function (s) { return s.constructor === system; });
+            index = this.systems.findIndex(s => s.constructor === system);
         }
         else if (system instanceof System$1) {
-            index = this.systems.findIndex(function (s) { return s === system; });
+            index = this.systems.findIndex(s => 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) {
+    }
+    getSystem(S) {
+        return this.systems.find(system => {
             if (typeof S === 'string') {
                 return system.name === S;
             }
@@ -1350,134 +960,79 @@ var Game = (function (_super) {
                 return system instanceof S;
             }
         });
-    };
-    Game.prototype.pause = function () {
+    }
+    pause() {
         if (!this.playing)
             return;
         this.playing = false;
         this.ticker.pause();
         this.triggerPause();
-    };
-    Game.prototype.start = function () {
+    }
+    start() {
         if (this.playing)
             return;
         this.playing = true;
         this.started = true;
         this.ticker.start();
-    };
-    Game.prototype.resume = function () {
+    }
+    resume() {
         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 {
+    }
+    initTicker() {
+        this.ticker.add(e => {
+            this.scene && gameObjectLoop(e, this.gameObjects);
+            for (const system of this.systems) {
                 try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    triggerStart(system);
+                    system.update && system.update(e);
                 }
-                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);
+                catch (e) {
+                    console.error(`${system.constructor.systemName} update error`, 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;
+            for (const system of this.systems) {
                 try {
-                    system.onResume && system.onResume();
+                    system.lateUpdate && system.lateUpdate(e);
                 }
                 catch (e) {
-                    console.error(system.constructor.systemName + ", onResume error", e);
+                    console.error(`${system.constructor.systemName} lateUpdate error`, e);
                 }
             }
-        }
-        catch (e_13_1) { e_13 = { error: e_13_1 }; }
-        finally {
+        });
+    }
+    triggerResume() {
+        gameObjectResume(this.gameObjects);
+        for (const system of this.systems) {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                system.onResume && system.onResume();
             }
-            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) {
+                console.error(`${system.constructor.systemName}, onResume error`, e);
             }
         }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
-        finally {
+    }
+    triggerPause() {
+        gameObjectPause(this.gameObjects);
+        for (const system of this.systems) {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                system.onPause && system.onPause();
             }
-            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) {
+                console.error(`${system.constructor.systemName}, onPause error`, e);
             }
         }
-        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; }
+    }
+    destroySystems() {
+        for (const system of [...this.systems]) {
+            this.removeSystem(system);
         }
         this.systems.length = 0;
-    };
-    Game.prototype.destroy = function () {
+    }
+    destroy() {
         this.removeAllListeners();
         this.pause();
         this.scene.destroy();
@@ -1486,9 +1041,8 @@ var Game = (function (_super) {
         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 ? exports.LOAD_SCENE_MODE.SINGLE : _b, _c = _a.params, params = _c === void 0 ? {} : _c;
+    }
+    loadScene({ scene, mode = exports.LOAD_SCENE_MODE.SINGLE, params = {} }) {
         if (!scene) {
             return;
         }
@@ -1500,10 +1054,9 @@ var Game = (function (_super) {
                 this.multiScenes.push(scene);
                 break;
         }
-        this.emit('sceneChanged', { scene: scene, mode: mode, params: params });
-    };
-    return Game;
-}(EventEmitter__default));
+        this.emit('sceneChanged', { scene, mode, params });
+    }
+}
 var Game$1 = Game;
 
 function IDEProp(target, propertyKey) {
@@ -1513,16 +1066,15 @@ function IDEProp(target, propertyKey) {
     target.constructor.IDEProps.push(propertyKey);
 }
 
-function componentObserver(observerInfo) {
-    if (observerInfo === void 0) { observerInfo = {}; }
+function componentObserver(observerInfo = {}) {
     return function (constructor) {
         if (!constructor.observerInfo) {
-            for (var key in observerInfo) {
-                for (var index in observerInfo[key]) {
+            for (const key in observerInfo) {
+                for (const index in observerInfo[key]) {
                     if (typeof observerInfo[key][index] === 'string') {
                         observerInfo[key][index] = [observerInfo[key][index]];
                     }
-                    var observerProp = void 0;
+                    let observerProp;
                     if (Array.isArray(observerInfo[key][index])) {
                         observerProp = {
                             prop: observerInfo[key][index],
@@ -1541,25 +1093,22 @@ function componentObserver(observerInfo) {
     };
 }
 
-var Progress = (function (_super) {
-    __extends(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;
+class Progress extends EventEmitter__default {
+    constructor({ resource, resourceTotal }) {
+        super();
+        this.progress = 0;
+        this.resourceTotal = 0;
+        this.resourceLoadedCount = 0;
+        this.resource = resource;
+        this.resourceTotal = resourceTotal;
         if (resourceTotal === 0) {
-            _this.resource.emit(exports.LOAD_EVENT.COMPLETE, _this);
+            this.resource.emit(exports.LOAD_EVENT.COMPLETE, this);
         }
-        return _this;
     }
-    Progress.prototype.onStart = function () {
+    onStart() {
         this.resource.emit(exports.LOAD_EVENT.START, this);
-    };
-    Progress.prototype.onProgress = function (param) {
+    }
+    onProgress(param) {
         this.resourceLoadedCount++;
         this.progress = Math.floor((this.resourceLoadedCount / this.resourceTotal) * 100) / 100;
         if (param.success) {
@@ -1572,12 +1121,10 @@ var Progress = (function (_super) {
         if (this.resourceLoadedCount === this.resourceTotal) {
             this.resource.emit(exports.LOAD_EVENT.COMPLETE, this);
         }
-    };
-    return Progress;
-}(EventEmitter__default));
-var Progress$1 = Progress;
+    }
+}
 
-var resourceLoader = {
+const resourceLoader = {
     AbstractLoadStrategy: resourceLoader$1.AbstractLoadStrategy,
     AudioLoadStrategy: resourceLoader$1.AudioLoadStrategy,
     ImageLoadStrategy: resourceLoader$1.ImageLoadStrategy,
@@ -1606,201 +1153,140 @@ exports.RESOURCE_TYPE = void 0;
     RESOURCE_TYPE["AUDIO"] = "AUDIO";
     RESOURCE_TYPE["VIDEO"] = "VIDEO";
 })(exports.RESOURCE_TYPE || (exports.RESOURCE_TYPE = {}));
-var Resource = (function (_super) {
-    __extends(Resource, _super);
-    function Resource(options) {
-        var _this = _super.call(this) || this;
-        _this.timeout = 6000;
-        _this.preProcessResourceHandlers = [];
-        _this.resourcesMap = {};
-        _this.makeInstanceFunctions = {};
-        _this.destroyInstanceFunctions = {};
-        _this.promiseMap = {};
+class Resource extends EventEmitter__default {
+    constructor(options) {
+        super();
+        this.timeout = 6000;
+        this.preProcessResourceHandlers = [];
+        this.resourcesMap = {};
+        this.makeInstanceFunctions = {};
+        this.destroyInstanceFunctions = {};
+        this.promiseMap = {};
         if (options && typeof options.timeout === 'number') {
-            _this.timeout = options.timeout;
+            this.timeout = options.timeout;
         }
-        return _this;
     }
-    Resource.prototype.loadConfig = function (resources) {
+    loadConfig(resources) {
         this.addResource(resources);
         this.preload();
-    };
-    Resource.prototype.loadSingle = function (resource) {
+    }
+    loadSingle(resource) {
         this.addResource([resource]);
         return this.getResource(resource.name);
-    };
-    Resource.prototype.addResource = function (resources) {
-        var e_1, _a;
+    }
+    addResource(resources) {
         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 = {};
+        for (const res of resources) {
+            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) {
+    }
+    addPreProcessResourceHandler(handler) {
         this.preProcessResourceHandlers.push(handler);
-    };
-    Resource.prototype.removePreProcessResourceHandler = function (handler) {
+    }
+    removePreProcessResourceHandler(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);
+    }
+    preload() {
+        const names = [];
+        for (const key in this.resourcesMap) {
+            const resource = this.resourcesMap[key];
+            if (resource.preload && !resource.complete && !this.promiseMap[key]) {
+                names.push(resource.name);
             }
         }
-        this.progress = new Progress$1({
+        this.progress = new Progress({
             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({})];
-            });
+        this.loadResource({ names, preload: true });
+    }
+    getResource(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.loadResource({ names: [name] });
+            return 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];
-                }
-            });
+    }
+    instance(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = this.resourcesMap[name];
+            return this.makeInstanceFunctions[res.type] && (yield this.makeInstanceFunctions[res.type](res));
         });
-    };
-    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];
-                }
-            });
+    }
+    destroy(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._destroy(name);
         });
-    };
-    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];
+    }
+    _destroy(name, loadError = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resource = this.resourcesMap[name];
+            if (!resource)
+                return;
+            if (!loadError) {
+                try {
+                    if (this.destroyInstanceFunctions[resource.type]) {
+                        yield this.destroyInstanceFunctions[resource.type](resource);
+                    }
                 }
-            });
+                catch (e) {
+                    console.warn(`destroy resource ${resource.name} error with '${e.message}'`);
+                }
+            }
+            delete this.promiseMap[name];
+            resource.data = {};
+            resource.complete = false;
+            resource.instance = undefined;
         });
-    };
-    Resource.prototype.registerResourceType = function (type, value) {
-        if (value === void 0) { value = type; }
+    }
+    registerResourceType(type, value = type) {
         if (exports.RESOURCE_TYPE[type]) {
-            throw new Error("The type " + type + " already exists in RESOURCE_TYPE");
+            throw new Error(`The type ${type} already exists in RESOURCE_TYPE`);
         }
         exports.RESOURCE_TYPE[type] = value;
-    };
-    Resource.prototype.registerInstance = function (type, callback) {
+    }
+    registerInstance(type, callback) {
         this.makeInstanceFunctions[type] = callback;
-    };
-    Resource.prototype.registerDestroy = function (type, callback) {
+    }
+    registerDestroy(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]; });
+    }
+    loadResource({ names = [], preload = false }) {
+        const unLoadNames = names.filter(name => !this.promiseMap[name] && this.resourcesMap[name]);
         if (!unLoadNames.length)
             return;
-        var resolves = {};
-        unLoadNames.forEach(function (name) {
-            var e_3, _a;
-            var _b;
-            _this.promiseMap[name] = new Promise(function (r) { return (resolves[name] = r); });
-            var res = _this.resourcesMap[name];
-            try {
-                for (var _c = __values(_this.preProcessResourceHandlers), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var handler = _d.value;
-                    handler(res);
-                }
+        const resolves = {};
+        unLoadNames.forEach(name => {
+            var _a;
+            this.promiseMap[name] = new Promise(r => (resolves[name] = r));
+            const res = this.resourcesMap[name];
+            for (const handler of this.preProcessResourceHandlers) {
+                handler(res);
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            var _loop_1 = function (key) {
-                var resourceType = res.src[key].type;
+            for (const key in res.src) {
+                const resourceType = res.src[key].type;
                 if (resourceType === 'data') {
                     res.data[key] = res.src[key].data;
-                    _this.doComplete(name, resolves[name], preload);
+                    this.doComplete(name, resolves[name], preload);
                 }
                 else {
-                    var url = (_b = res.src[key]) === null || _b === void 0 ? void 0 : _b.url;
+                    let url = (_a = res.src[key]) === null || _a === void 0 ? void 0 : _a.url;
                     if (typeof url === 'string' && url.startsWith('//')) {
-                        url = "" + window.location.protocol + res.src[key].url;
+                        url = `${window.location.protocol}${res.src[key].url}`;
                     }
                     if (key === 'atlas') {
                         pixi_js.Assets.add({
                             alias: url,
                             src: url,
                             data: {
-                                resolve: function () { return pixi_js.Assets.load(res.src['image'].url); },
+                                resolve: () => pixi_js.Assets.load(res.src['image'].url),
                             },
                         });
                     }
@@ -1811,126 +1297,99 @@ var Resource = (function (_super) {
                         });
                     }
                     pixi_js.Assets.load(url)
-                        .then(function (data) {
-                        _this.onLoad({
-                            preload: preload,
+                        .then(data => {
+                        this.onLoad({
+                            preload,
                             resource: {
-                                metadata: { key: key, name: name, resolves: resolves },
+                                metadata: { key, name, resolves },
                                 data: data,
                             },
                         });
                     })
-                        .catch(function (e) {
+                        .catch(e => {
                         console.log('>>>E', e);
-                        _this.onError({
-                            preload: preload,
+                        this.onError({
+                            preload,
                             errMsg: e.message,
                             resource: {
-                                metadata: { key: key, name: name, resolves: resolves },
+                                metadata: { key, name, resolves },
                             },
                         });
                     });
                 }
-            };
-            for (var key in res.src) {
-                _loop_1(key);
             }
         });
-    };
-    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];
+    }
+    doComplete(name, resolve, preload = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = this.resourcesMap[name];
+            const param = {
+                name,
+                resource: this.resourcesMap[name],
+                success: true,
+            };
+            if (this.checkAllLoaded(name)) {
+                try {
+                    res.instance = yield this.instance(name);
+                    res.complete = true;
+                    if (preload) {
+                        this.progress.onProgress(param);
+                    }
+                    resolve(res);
                 }
-            });
+                catch (err) {
+                    console.error(err);
+                    res.complete = false;
+                    if (preload) {
+                        param.errMsg = err.message;
+                        param.success = false;
+                        this.progress.onProgress(param);
+                    }
+                    resolve({});
+                }
+            }
         });
-    };
-    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) {
-    };
-    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];
-            });
+    }
+    checkAllLoaded(name) {
+        const res = this.resourcesMap[name];
+        return Array.from(Object.keys(res.src)).every(resourceKey => res.data[resourceKey]);
+    }
+    getLoader(_preload = false) {
+    }
+    onLoad({ preload = false, resource }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { metadata: { key, name, resolves }, data, } = resource;
+            const res = this.resourcesMap[name];
+            res.data[key] = data;
+            this.doComplete(name, resolves[name], preload);
         });
-    };
-    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];
-            });
+    }
+    onError({ errMsg, preload = false, resource }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { metadata: { name, resolves }, } = resource;
+            this._destroy(name, true);
+            resolves[name]({});
+            if (preload) {
+                const param = {
+                    name,
+                    resource: this.resourcesMap[name],
+                    success: false,
+                    errMsg,
+                };
+                this.progress.onProgress(param);
+            }
         });
-    };
-    return Resource;
-}(EventEmitter__default));
-var resource = new Resource();
+    }
+}
+const resource = new Resource();
 
-var decorators = {
-    IDEProp: IDEProp,
-    componentObserver: componentObserver,
+const decorators = {
+    IDEProp,
+    componentObserver,
 };
-var version = '2.0.0-beta.1';
-console.log("Eva.js version: " + version);
-var RESOURCE_TYPE_STRATEGY = {};
+const version = '2.0.0-beta.2';
+console.log(`Eva.js version: ${version}`);
+const RESOURCE_TYPE_STRATEGY = {};
 
 exports.Component = Component$1;
 exports.Game = Game$1;