@eva/eva.js 1.2.2-alpha.1 → 1.2.2-alpha.5

package/dist/eva.js.esm.js

@@ -0,0 +1,1899 @@
+import EventEmitter from 'eventemitter3';
+import { isEqual, isObject } from 'lodash-es';
+import { type, step } from '@eva/inspector-decorator';
+import { AbstractLoadStrategy, AudioLoadStrategy, ImageLoadStrategy, XhrResponseType, MediaElementLoadStrategy, VideoLoadStrategy, XhrLoadStrategy, Loader, Resource as Resource$1, ResourceType, ResourceState } from 'resource-loader';
+
+/*! *****************************************************************************
+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;
+    }
+    else if (component instanceof Function) {
+        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));
+var Component$1 = Component;
+
+var ObserverType;
+(function (ObserverType) {
+    ObserverType["ADD"] = "ADD";
+    ObserverType["REMOVE"] = "REMOVE";
+    ObserverType["CHANGE"] = "CHANGE";
+})(ObserverType || (ObserverType = {}));
+var objectCache = {};
+var systemInstance = {};
+var observerInfos = {};
+var componentProps = {};
+function getObjectCache(component, keys) {
+    if (!objectCache[component.gameObject.id]) {
+        objectCache[component.gameObject.id] = {};
+    }
+    var cache = objectCache[component.gameObject.id];
+    var key = component.name + '_' + keys.join(',');
+    if (cache[key]) {
+        return cache[key];
+    }
+    var keyIndex = keys.length - 1;
+    var property = component;
+    for (var i = 0; i < keyIndex; i++) {
+        property = property[keys[i]];
+    }
+    cache[key] = { property: property, key: keys[keyIndex] };
+    return cache[key];
+}
+function removeObjectCache(component) {
+    if (component.gameObject) {
+        delete objectCache[component.gameObject.id];
+    }
+}
+function addObserver(_a) {
+    var _b, _c;
+    var systemName = _a.systemName, componentName = _a.componentName, component = _a.component, prop = _a.prop, type = _a.type;
+    (_c = (_b = systemInstance[systemName]) === null || _b === void 0 ? void 0 : _b.componentObserver) === null || _c === void 0 ? void 0 : _c.add({
+        component: component,
+        prop: prop,
+        type: type,
+        componentName: componentName,
+    });
+}
+function pushToQueue(_a) {
+    var prop = _a.prop, component = _a.component, componentName = _a.componentName;
+    for (var systemName in observerInfos) {
+        var observerInfo = observerInfos[systemName] || {};
+        var info = observerInfo[componentName];
+        if (!info)
+            continue;
+        var index = info.findIndex(function (p) {
+            return isEqual(p, prop);
+        });
+        if (index > -1) {
+            addObserver({
+                systemName: systemName,
+                componentName: componentName,
+                component: component,
+                prop: prop,
+                type: ObserverType.CHANGE,
+            });
+        }
+    }
+}
+function defineProperty(_a) {
+    var e_1, _b;
+    var obj = _a.obj, key = _a.key, prop = _a.prop, component = _a.component, componentName = _a.componentName;
+    if (obj === undefined) {
+        return;
+    }
+    if (!(key in obj)) {
+        console.error("prop " + key + " not in component: " + componentName + ", Can not observer");
+        return;
+    }
+    Object.defineProperty(obj, "_" + key, {
+        enumerable: false,
+        writable: true,
+        value: obj[key],
+    });
+    if (prop.deep && isObject(obj[key])) {
+        try {
+            for (var _c = __values(Object.keys(obj[key])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var childKey = _d.value;
+                defineProperty({
+                    obj: obj[key],
+                    key: childKey,
+                    prop: prop,
+                    component: component,
+                    componentName: componentName,
+                });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        set: function (val) {
+            if (obj["_" + key] === val)
+                return;
+            obj["_" + key] = val;
+            pushToQueue({ prop: prop, component: component, componentName: componentName });
+        },
+        get: function () {
+            return obj["_" + key];
+        },
+    });
+}
+function isComponent(comp) {
+    return comp && comp.constructor && 'componentName' in comp.constructor;
+}
+function initObserver(Systems) {
+    var e_2, _a, e_3, _b;
+    var Ss = [];
+    if (Systems instanceof Array) {
+        Ss.push.apply(Ss, __spread(Systems));
+    }
+    else {
+        Ss.push(Systems);
+    }
+    try {
+        for (var Ss_1 = __values(Ss), Ss_1_1 = Ss_1.next(); !Ss_1_1.done; Ss_1_1 = Ss_1.next()) {
+            var S = Ss_1_1.value;
+            for (var componentName in S.observerInfo) {
+                componentProps[componentName] = componentProps[componentName] || [];
+                var props = componentProps[componentName];
+                var _loop_1 = function (prop) {
+                    var index = props.findIndex(function (p) {
+                        return isEqual(p, prop);
+                    });
+                    if (index === -1) {
+                        componentProps[componentName].push(prop);
+                    }
+                };
+                try {
+                    for (var _c = (e_3 = void 0, __values(S.observerInfo[componentName])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var prop = _d.value;
+                        _loop_1(prop);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (Ss_1_1 && !Ss_1_1.done && (_a = Ss_1.return)) _a.call(Ss_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
+function observer(component, componentName) {
+    var e_4, _a;
+    if (componentName === void 0) { componentName = component.name; }
+    if (!componentName || !componentProps[componentName]) {
+        return;
+    }
+    if (!component || !isComponent(component)) {
+        throw new Error('component param must be an instance of Component');
+    }
+    if (!component.gameObject || !component.gameObject.id) {
+        throw new Error('component should be add to a gameObject');
+    }
+    try {
+        for (var _b = __values(componentProps[componentName]), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var item = _c.value;
+            var _d = getObjectCache(component, item.prop), property = _d.property, key = _d.key;
+            defineProperty({
+                obj: property,
+                key: key,
+                prop: item,
+                component: component,
+                componentName: componentName,
+            });
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+}
+function observerAdded(component, componentName) {
+    var _a, _b;
+    if (componentName === void 0) { componentName = component.name; }
+    for (var systemName in observerInfos) {
+        var observerInfo = observerInfos[systemName] || {};
+        var info = observerInfo[componentName];
+        if (info) {
+            (_b = (_a = systemInstance[systemName]) === null || _a === void 0 ? void 0 : _a.componentObserver) === null || _b === void 0 ? void 0 : _b.add({
+                component: component,
+                type: ObserverType.ADD,
+                componentName: componentName,
+            });
+        }
+    }
+}
+function observerRemoved(component, componentName) {
+    var _a, _b;
+    if (componentName === void 0) { componentName = component.name; }
+    for (var systemName in observerInfos) {
+        var observerInfo = observerInfos[systemName] || {};
+        var info = observerInfo[componentName];
+        if (info) {
+            (_b = (_a = systemInstance[systemName]) === null || _a === void 0 ? void 0 : _a.componentObserver) === null || _b === void 0 ? void 0 : _b.add({
+                component: component,
+                type: ObserverType.REMOVE,
+                componentName: componentName,
+            });
+        }
+    }
+    removeObjectCache(component);
+}
+function setSystemObserver(system, S) {
+    observerInfos[S.systemName] = S.observerInfo;
+    systemInstance[S.systemName] = system;
+}
+
+var Transform = (function (_super) {
+    __extends(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; }
+        }
+        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) {
+        if (child.parent === this) {
+            var index = this.children.findIndex(function (item) { return item === child; });
+            this.children.splice(index, 1);
+        }
+        else if (child.parent) {
+            child.parent.removeChild(child);
+        }
+        child._parent = this;
+        this.children.push(child);
+    };
+    Transform.prototype.removeChild = function (child) {
+        var index = this.children.findIndex(function (item) { return item === child; });
+        if (index > -1) {
+            this.children.splice(index, 1);
+            child._parent = null;
+        }
+    };
+    Transform.prototype.clearChildren = function () {
+        this.children.length = 0;
+    };
+    Transform.componentName = 'Transform';
+    __decorate([
+        type('vector2'),
+        step(1)
+    ], Transform.prototype, "position", void 0);
+    __decorate([
+        type('size'),
+        step(1)
+    ], Transform.prototype, "size", void 0);
+    __decorate([
+        type('vector2'),
+        step(0.1)
+    ], Transform.prototype, "origin", void 0);
+    __decorate([
+        type('vector2'),
+        step(0.1)
+    ], Transform.prototype, "anchor", void 0);
+    __decorate([
+        type('vector2'),
+        step(0.1)
+    ], Transform.prototype, "scale", void 0);
+    __decorate([
+        type('vector2'),
+        step(0.1)
+    ], Transform.prototype, "skew", void 0);
+    __decorate([
+        type('number'),
+        step(0.1)
+    ], Transform.prototype, "rotation", void 0);
+    return Transform;
+}(Component$1));
+var Transform$1 = Transform;
+
+var _id = 0;
+function getId() {
+    return ++_id;
+}
+var GameObject = (function () {
+    function GameObject(name, obj) {
+        this._componentCache = {};
+        this.components = [];
+        this._name = name;
+        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);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GameObject.prototype.addChild = function (gameObject) {
+        if (!gameObject || !gameObject.transform || gameObject === this)
+            return;
+        if (!(gameObject instanceof GameObject)) {
+            throw new Error('addChild only receive GameObject');
+        }
+        if (!this.transform) {
+            throw new Error("gameObject '" + this.name + "' has been destroy");
+        }
+        gameObject.transform.parent = this.transform;
+        gameObject.scene = this.scene;
+    };
+    GameObject.prototype.removeChild = function (gameObject) {
+        if (!(gameObject instanceof GameObject) || !gameObject.parent || gameObject.parent !== this) {
+            return gameObject;
+        }
+        gameObject.transform.parent = null;
+        gameObject.scene = null;
+        return gameObject;
+    };
+    GameObject.prototype.addComponent = function (C, obj) {
+        var componentName = getComponentName(C);
+        if (this._componentCache[componentName])
+            return;
+        var component;
+        if (C instanceof Function) {
+            component = new C(obj);
+        }
+        else if (C instanceof Component$1) {
+            component = C;
+        }
+        else {
+            throw new Error('addComponent recieve Component and Component Constructor');
+        }
+        if (component.gameObject) {
+            throw new Error("component has been added on gameObject " + component.gameObject.name);
+        }
+        component.gameObject = this;
+        component.init && component.init(component.__componentDefaultParams);
+        observerAdded(component, component.name);
+        observer(component, component.name);
+        this.components.push(component);
+        this._componentCache[componentName] = component;
+        component.awake && component.awake();
+        return component;
+    };
+    GameObject.prototype.removeComponent = function (c) {
+        var componentName;
+        if (typeof c === 'string') {
+            componentName = c;
+        }
+        else if (c instanceof Component$1) {
+            componentName = c.name;
+        }
+        else if (c.componentName) {
+            componentName = c.componentName;
+        }
+        if (componentName === 'Transform') {
+            throw new Error("Transform can't be removed");
+        }
+        return this._removeComponent(componentName);
+    };
+    GameObject.prototype._removeComponent = function (componentName) {
+        var index = this.components.findIndex(function (_a) {
+            var name = _a.name;
+            return name === componentName;
+        });
+        if (index === -1)
+            return;
+        var component = this.components.splice(index, 1)[0];
+        delete this._componentCache[componentName];
+        delete component.__componentDefaultParams;
+        component.onDestroy && component.onDestroy();
+        observerRemoved(component, componentName);
+        component.gameObject = undefined;
+        return component;
+    };
+    GameObject.prototype.getComponent = function (c) {
+        var componentName;
+        if (typeof c === 'string') {
+            componentName = c;
+        }
+        else if (c instanceof Component$1) {
+            componentName = c.name;
+        }
+        else if (c.componentName) {
+            componentName = c.componentName;
+        }
+        if (typeof this._componentCache[componentName] !== 'undefined') {
+            return this._componentCache[componentName];
+        }
+        else {
+            return;
+        }
+    };
+    GameObject.prototype.remove = function () {
+        if (this.parent)
+            return this.parent.removeChild(this);
+    };
+    GameObject.prototype.destroy = function () {
+        if (!this.transform) {
+            console.error('Cannot destroy gameObject that have already been destroyed.');
+            return;
+        }
+        Array.from(this.transform.children).forEach(function (_a) {
+            var gameObject = _a.gameObject;
+            gameObject.destroy();
+        });
+        this.remove();
+        this.transform.clearChildren();
+        for (var key in this._componentCache) {
+            this._removeComponent(key);
+        }
+        this.components.length = 0;
+    };
+    return GameObject;
+}());
+var GameObject$1 = GameObject;
+
+var ComponentObserver = (function () {
+    function ComponentObserver() {
+        this.events = [];
+    }
+    ComponentObserver.prototype.add = function (_a) {
+        var component = _a.component, prop = _a.prop, type = _a.type, componentName = _a.componentName;
+        if (type === ObserverType.REMOVE) {
+            if (this.events.find(function (changed) { return changed.component === component && changed.type === ObserverType.ADD; })) {
+                return;
+            }
+            this.events = this.events.filter(function (changed) { return changed.component !== component; });
+        }
+        var index = this.events.findIndex(function (changed) { return changed.component === component && isEqual(changed.prop, prop) && changed.type === type; });
+        if (index > -1) {
+            this.events.splice(index, 1);
+        }
+        this.events.push({
+            gameObject: component.gameObject,
+            component: component,
+            prop: prop,
+            type: type,
+            componentName: componentName,
+        });
+    };
+    ComponentObserver.prototype.getChanged = function () {
+        return this.events;
+    };
+    Object.defineProperty(ComponentObserver.prototype, "changed", {
+        get: function () {
+            return this.events;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ComponentObserver.prototype.clear = function () {
+        var events = this.events;
+        this.events = [];
+        return events;
+    };
+    return ComponentObserver;
+}());
+var ComponentObserver$1 = ComponentObserver;
+
+var System = (function () {
+    function System(params) {
+        this.started = false;
+        this.componentObserver = new ComponentObserver$1();
+        this.__systemDefaultParams = params;
+        this.name = this.constructor.systemName;
+    }
+    System.prototype.destroy = function () {
+        var _a;
+        this.componentObserver = null;
+        this.__systemDefaultParams = null;
+        (_a = this.onDestroy) === null || _a === void 0 ? void 0 : _a.call(this);
+    };
+    return System;
+}());
+var System$1 = System;
+
+function createNowTime() {
+    var nowtime = null;
+    if (Date.now) {
+        nowtime = Date.now;
+    }
+    else {
+        nowtime = function () { return new Date().getTime(); };
+    }
+    return nowtime;
+}
+
+var _nowtime = createNowTime();
+var defaultOptions$1 = {
+    originTime: 0,
+    playbackRate: 1.0,
+};
+var Timeline = (function () {
+    function Timeline(options, parent) {
+        if (options instanceof Timeline) {
+            parent = options;
+            options = {};
+        }
+        options = Object.assign({}, defaultOptions$1, options);
+        if (parent) {
+            this._parent = parent;
+        }
+        this._createTime = _nowtime();
+        this._timeMark = [
+            {
+                globalTime: this.globalTime,
+                localTime: -options.originTime,
+                entropy: -options.originTime,
+                playbackRate: options.playbackRate,
+                globalEntropy: 0,
+            },
+        ];
+        if (this._parent) {
+            this._timeMark[0].globalEntropy = this._parent.entropy;
+        }
+        this._playbackRate = options.playbackRate;
+    }
+    Object.defineProperty(Timeline.prototype, "globalTime", {
+        get: function () {
+            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 = {
+            globalTime: this.globalTime,
+            localTime: time,
+            entropy: entropy,
+            playbackRate: 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) {
+        return new Timeline(options, this);
+    };
+    Timeline.prototype.seekGlobalTime = function (seekEntropy) {
+        var idx = this.seekTimeMark(seekEntropy), timeMark = this._timeMark[idx];
+        var entropy = timeMark.entropy, playbackRate = timeMark.playbackRate, globalTime = timeMark.globalTime;
+        return globalTime + (seekEntropy - entropy) / Math.abs(playbackRate);
+    };
+    Timeline.prototype.seekLocalTime = function (seekEntropy) {
+        var idx = this.seekTimeMark(seekEntropy), timeMark = this._timeMark[idx];
+        var localTime = timeMark.localTime, entropy = timeMark.entropy, playbackRate = timeMark.playbackRate;
+        if (playbackRate > 0) {
+            return localTime + (seekEntropy - entropy);
+        }
+        return localTime - (seekEntropy - entropy);
+    };
+    Timeline.prototype.seekTimeMark = function (entropy) {
+        var timeMark = this._timeMark;
+        var l = 0, r = timeMark.length - 1;
+        if (entropy <= timeMark[l].entropy) {
+            return l;
+        }
+        if (entropy >= timeMark[r].entropy) {
+            return r;
+        }
+        var m = Math.floor((l + r) / 2);
+        while (m > l && m < r) {
+            if (entropy === timeMark[m].entropy) {
+                return m;
+            }
+            if (entropy < timeMark[m].entropy) {
+                r = m;
+            }
+            else if (entropy > timeMark[m].entropy) {
+                l = m;
+            }
+            m = Math.floor((l + r) / 2);
+        }
+        return l;
+    };
+    Object.defineProperty(Timeline.prototype, "playbackRate", {
+        get: function () {
+            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)
+                return true;
+            var parent = this.parent;
+            while (parent) {
+                if (parent.playbackRate === 0)
+                    return true;
+                parent = parent.parent;
+            }
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Timeline;
+}());
+var Timeline$1 = Timeline;
+
+var defaultOptions = {
+    autoStart: true,
+    frameRate: 60,
+};
+var Ticker = (function () {
+    function Ticker(options) {
+        var _this = this;
+        options = Object.assign({}, defaultOptions, options);
+        this._frameCount = 0;
+        this._frameDuration = 1000 / options.frameRate;
+        this.autoStart = options.autoStart;
+        this.frameRate = options.frameRate;
+        this.timeline = new Timeline$1({ originTime: 0, playbackRate: 1.0 });
+        this._lastFrameTime = this.timeline.currentTime;
+        this._tickers = new Set();
+        this._requestId = null;
+        this._ticker = function () {
+            if (_this._started) {
+                _this._requestId = requestAnimationFrame(_this._ticker);
+                _this.update();
+            }
+        };
+        if (this.autoStart) {
+            this.start();
+        }
+    }
+    Ticker.prototype.update = function () {
+        var e_1, _a;
+        var currentTime = this.timeline.currentTime;
+        var durationTime = currentTime - this._lastFrameTime;
+        if (durationTime >= this._frameDuration) {
+            var frameTime = currentTime - (durationTime % this._frameDuration);
+            var deltaTime = frameTime - this._lastFrameTime;
+            this._lastFrameTime = frameTime;
+            var options = {
+                deltaTime: deltaTime,
+                time: frameTime,
+                currentTime: frameTime,
+                frameCount: ++this._frameCount,
+                fps: Math.round(1000 / deltaTime),
+            };
+            try {
+                for (var _b = __values(this._tickers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var func = _c.value;
+                    if (typeof func === 'function') {
+                        func(options);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    };
+    Ticker.prototype.add = function (fn) {
+        this._tickers.add(fn);
+    };
+    Ticker.prototype.remove = function (fn) {
+        this._tickers.delete(fn);
+    };
+    Ticker.prototype.start = function () {
+        if (this._started)
+            return;
+        this._started = true;
+        this.timeline.playbackRate = 1.0;
+        this._requestId = requestAnimationFrame(this._ticker);
+    };
+    Ticker.prototype.pause = function () {
+        this._started = false;
+        this.timeline.playbackRate = 0;
+    };
+    Ticker.prototype.setPlaybackRate = function (rate) {
+        this.timeline.playbackRate = rate;
+    };
+    return Ticker;
+}());
+var Ticker$1 = Ticker;
+
+var Scene = (function (_super) {
+    __extends(Scene, _super);
+    function Scene(name, obj) {
+        var _this = _super.call(this, name, obj) || this;
+        _this.gameObjects = [];
+        _this.scene = _this;
+        return _this;
+    }
+    Scene.prototype.addGameObject = function (gameObject) {
+        this.gameObjects.push(gameObject);
+        if (gameObject.transform) {
+            gameObject.transform.inScene = true;
+        }
+    };
+    Scene.prototype.removeGameObject = function (gameObject) {
+        var index = this.gameObjects.indexOf(gameObject);
+        if (index === -1)
+            return;
+        if (gameObject.transform) {
+            gameObject.transform.inScene = false;
+        }
+        this.gameObjects.splice(index, 1);
+    };
+    Scene.prototype.destroy = function () {
+        this.scene = null;
+        _super.prototype.destroy.call(this);
+        this.gameObjects = null;
+        this.canvas = null;
+    };
+    return Scene;
+}(GameObject$1));
+var Scene$1 = Scene;
+
+var LOAD_SCENE_MODE;
+(function (LOAD_SCENE_MODE) {
+    LOAD_SCENE_MODE["SINGLE"] = "SINGLE";
+    LOAD_SCENE_MODE["MULTI_CANVAS"] = "MULTI_CANVAS";
+})(LOAD_SCENE_MODE || (LOAD_SCENE_MODE = {}));
+var triggerStart = function (obj) {
+    if (!(obj instanceof System$1) && !(obj instanceof Component$1))
+        return;
+    if (obj.started)
+        return;
+    obj.started = true;
+    try {
+        obj.start && obj.start();
+    }
+    catch (e) {
+        if (obj instanceof Component$1) {
+            console.error(obj.constructor.componentName + " start error", e);
+        }
+        else {
+            console.error(obj.constructor.systemName + " start error", e);
+        }
+    }
+};
+var getAllGameObjects = function (game) {
+    var e_1, _a;
+    var _b;
+    var mainSceneGameObjects = ((_b = game === null || game === void 0 ? void 0 : game.scene) === null || _b === void 0 ? void 0 : _b.gameObjects) || [];
+    var gameObjectsArray = game === null || game === void 0 ? void 0 : game.multiScenes.map(function (_a) {
+        var gameObjects = _a.gameObjects;
+        return gameObjects;
+    });
+    var otherSceneGameObjects = [];
+    try {
+        for (var gameObjectsArray_1 = __values(gameObjectsArray), gameObjectsArray_1_1 = gameObjectsArray_1.next(); !gameObjectsArray_1_1.done; gameObjectsArray_1_1 = gameObjectsArray_1.next()) {
+            var gameObjects = gameObjectsArray_1_1.value;
+            otherSceneGameObjects = __spread(otherSceneGameObjects, gameObjects);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (gameObjectsArray_1_1 && !gameObjectsArray_1_1.done && (_a = gameObjectsArray_1.return)) _a.call(gameObjectsArray_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return __spread(mainSceneGameObjects, otherSceneGameObjects);
+};
+var gameObjectLoop = function (e, gameObjects) {
+    var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
+    if (gameObjects === void 0) { gameObjects = []; }
+    try {
+        for (var gameObjects_1 = __values(gameObjects), gameObjects_1_1 = gameObjects_1.next(); !gameObjects_1_1.done; gameObjects_1_1 = gameObjects_1.next()) {
+            var gameObject = gameObjects_1_1.value;
+            try {
+                for (var _e = (e_3 = void 0, __values(gameObject.components)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var component = _f.value;
+                    try {
+                        triggerStart(component);
+                        component.update && component.update(e);
+                    }
+                    catch (e) {
+                        console.error("gameObject: " + gameObject.name + " " + component.name + " update error", e);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (gameObjects_1_1 && !gameObjects_1_1.done && (_a = gameObjects_1.return)) _a.call(gameObjects_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        for (var gameObjects_2 = __values(gameObjects), gameObjects_2_1 = gameObjects_2.next(); !gameObjects_2_1.done; gameObjects_2_1 = gameObjects_2.next()) {
+            var gameObject = gameObjects_2_1.value;
+            try {
+                for (var _g = (e_5 = void 0, __values(gameObject.components)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var component = _h.value;
+                    try {
+                        component.lateUpdate && component.lateUpdate(e);
+                    }
+                    catch (e) {
+                        console.error("gameObject: " + gameObject.name + " " + component.name + " lateUpdate error", e);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_d = _g.return)) _d.call(_g);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (gameObjects_2_1 && !gameObjects_2_1.done && (_c = gameObjects_2.return)) _c.call(gameObjects_2);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+};
+var gameObjectResume = function (gameObjects) {
+    var e_6, _a, e_7, _b;
+    try {
+        for (var gameObjects_3 = __values(gameObjects), gameObjects_3_1 = gameObjects_3.next(); !gameObjects_3_1.done; gameObjects_3_1 = gameObjects_3.next()) {
+            var gameObject = gameObjects_3_1.value;
+            try {
+                for (var _c = (e_7 = void 0, __values(gameObject.components)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var component = _d.value;
+                    try {
+                        component.onResume && component.onResume();
+                    }
+                    catch (e) {
+                        console.error("gameObject: " + gameObject.name + ", " + component.name + ", onResume error", e);
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (gameObjects_3_1 && !gameObjects_3_1.done && (_a = gameObjects_3.return)) _a.call(gameObjects_3);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+};
+var gameObjectPause = function (gameObjects) {
+    var e_8, _a, e_9, _b;
+    try {
+        for (var gameObjects_4 = __values(gameObjects), gameObjects_4_1 = gameObjects_4.next(); !gameObjects_4_1.done; gameObjects_4_1 = gameObjects_4.next()) {
+            var gameObject = gameObjects_4_1.value;
+            try {
+                for (var _c = (e_9 = void 0, __values(gameObject.components)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var component = _d.value;
+                    try {
+                        component.onPause && component.onPause();
+                    }
+                    catch (e) {
+                        console.error("gameObject: " + gameObject.name + ", " + component.name + ", onResume error", e);
+                    }
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (gameObjects_4_1 && !gameObjects_4_1.done && (_a = gameObjects_4.return)) _a.call(gameObjects_4);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+};
+var Game = (function (_super) {
+    __extends(Game, _super);
+    function Game(_a) {
+        var e_10, _b;
+        var _c = _a === void 0 ? {} : _a, systems = _c.systems, _d = _c.frameRate, frameRate = _d === void 0 ? 60 : _d, _e = _c.autoStart, autoStart = _e === void 0 ? true : _e, _f = _c.needScene, needScene = _f === void 0 ? true : _f;
+        var _this = _super.call(this) || this;
+        _this.playing = false;
+        _this.started = false;
+        _this.multiScenes = [];
+        _this.systems = [];
+        if (window.__EVA_INSPECTOR_ENV__) {
+            window.__EVA_GAME_INSTANCE__ = _this;
+        }
+        _this.ticker = new Ticker$1({ autoStart: false, frameRate: frameRate });
+        _this.initTicker();
+        if (systems && systems.length) {
+            try {
+                for (var systems_1 = __values(systems), systems_1_1 = systems_1.next(); !systems_1_1.done; systems_1_1 = systems_1.next()) {
+                    var system = systems_1_1.value;
+                    _this.addSystem(system);
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (systems_1_1 && !systems_1_1.done && (_b = systems_1.return)) _b.call(systems_1);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+        }
+        if (needScene) {
+            _this.loadScene(new Scene$1('scene'));
+        }
+        if (autoStart) {
+            _this.start();
+        }
+        return _this;
+    }
+    Object.defineProperty(Game.prototype, "scene", {
+        get: function () {
+            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) {
+        var system;
+        if (S instanceof Function) {
+            system = new S(obj);
+        }
+        else if (S instanceof System$1) {
+            system = S;
+        }
+        else {
+            console.warn('can only add System');
+            return;
+        }
+        var hasTheSystem = this.systems.find(function (item) {
+            return item.constructor === system.constructor;
+        });
+        if (hasTheSystem) {
+            console.warn(system.constructor.systemName + " System has been added");
+            return;
+        }
+        system.game = this;
+        system.init && system.init(system.__systemDefaultParams);
+        setSystemObserver(system, system.constructor);
+        initObserver(system.constructor);
+        try {
+            system.awake && system.awake();
+        }
+        catch (e) {
+            console.error(system.constructor.systemName + " awake error", e);
+        }
+        this.systems.push(system);
+        return system;
+    };
+    Game.prototype.removeSystem = function (system) {
+        if (!system)
+            return;
+        var index = -1;
+        if (typeof system === 'string') {
+            index = this.systems.findIndex(function (s) { return s.name === system; });
+        }
+        else if (system instanceof Function) {
+            index = this.systems.findIndex(function (s) { return s.constructor === system; });
+        }
+        else if (system instanceof System$1) {
+            index = this.systems.findIndex(function (s) { return s === system; });
+        }
+        if (index > -1) {
+            this.systems[index].destroy && this.systems[index].destroy();
+            this.systems.splice(index, 1);
+        }
+    };
+    Game.prototype.getSystem = function (S) {
+        return this.systems.find(function (system) {
+            if (typeof S === 'string') {
+                return system.name === S;
+            }
+            else {
+                return system instanceof S;
+            }
+        });
+    };
+    Game.prototype.pause = function () {
+        if (!this.playing)
+            return;
+        this.playing = false;
+        this.ticker.pause();
+        this.triggerPause();
+    };
+    Game.prototype.start = function () {
+        if (this.playing)
+            return;
+        this.playing = true;
+        this.started = true;
+        this.ticker.start();
+    };
+    Game.prototype.resume = function () {
+        if (this.playing)
+            return;
+        this.playing = true;
+        this.ticker.start();
+        this.triggerResume();
+    };
+    Game.prototype.initTicker = function () {
+        var _this = this;
+        this.ticker.add(function (e) {
+            var e_11, _a, e_12, _b;
+            _this.scene && gameObjectLoop(e, _this.gameObjects);
+            try {
+                for (var _c = __values(_this.systems), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var system = _d.value;
+                    try {
+                        triggerStart(system);
+                        system.update && system.update(e);
+                    }
+                    catch (e) {
+                        console.error(system.constructor.systemName + " update error", e);
+                    }
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+            try {
+                for (var _e = __values(_this.systems), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var system = _f.value;
+                    try {
+                        system.lateUpdate && system.lateUpdate(e);
+                    }
+                    catch (e) {
+                        console.error(system.constructor.systemName + " lateUpdate error", e);
+                    }
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+        });
+    };
+    Game.prototype.triggerResume = function () {
+        var e_13, _a;
+        gameObjectResume(this.gameObjects);
+        try {
+            for (var _b = __values(this.systems), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var system = _c.value;
+                try {
+                    system.onResume && system.onResume();
+                }
+                catch (e) {
+                    console.error(system.constructor.systemName + ", onResume error", e);
+                }
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+    };
+    Game.prototype.triggerPause = function () {
+        var e_14, _a;
+        gameObjectPause(this.gameObjects);
+        try {
+            for (var _b = __values(this.systems), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var system = _c.value;
+                try {
+                    system.onPause && system.onPause();
+                }
+                catch (e) {
+                    console.error(system.constructor.systemName + ", onPause error", e);
+                }
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+    };
+    Game.prototype.destroySystems = function () {
+        var e_15, _a;
+        try {
+            for (var _b = __values(__spread(this.systems)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var system = _c.value;
+                this.removeSystem(system);
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        this.systems.length = 0;
+    };
+    Game.prototype.destroy = function () {
+        this.removeAllListeners();
+        this.pause();
+        this.scene.destroy();
+        this.destroySystems();
+        this.ticker = null;
+        this.scene = null;
+        this.canvas = null;
+        this.multiScenes = null;
+    };
+    Game.prototype.loadScene = function (_a) {
+        var scene = _a.scene, _b = _a.mode, mode = _b === void 0 ? LOAD_SCENE_MODE.SINGLE : _b, _c = _a.params, params = _c === void 0 ? {} : _c;
+        if (!scene) {
+            return;
+        }
+        switch (mode) {
+            case LOAD_SCENE_MODE.SINGLE:
+                this.scene = scene;
+                break;
+            case LOAD_SCENE_MODE.MULTI_CANVAS:
+                this.multiScenes.push(scene);
+                break;
+        }
+        this.emit('sceneChanged', { scene: scene, mode: mode, params: params });
+    };
+    return Game;
+}(EventEmitter));
+var Game$1 = Game;
+
+function IDEProp(target, propertyKey) {
+    if (!target.constructor.IDEProps) {
+        target.constructor.IDEProps = [];
+    }
+    target.constructor.IDEProps.push(propertyKey);
+}
+
+function componentObserver(observerInfo) {
+    if (observerInfo === void 0) { observerInfo = {}; }
+    return function (constructor) {
+        if (!constructor.observerInfo) {
+            for (var key in observerInfo) {
+                for (var index in observerInfo[key]) {
+                    if (typeof observerInfo[key][index] === 'string') {
+                        observerInfo[key][index] = [observerInfo[key][index]];
+                    }
+                    var observerProp = void 0;
+                    if (Array.isArray(observerInfo[key][index])) {
+                        observerProp = {
+                            prop: observerInfo[key][index],
+                            deep: false,
+                        };
+                        observerInfo[key][index] = observerProp;
+                    }
+                    observerProp = observerInfo[key][index];
+                    if (typeof observerProp.prop === 'string') {
+                        observerProp.prop = [observerProp.prop];
+                    }
+                }
+            }
+            constructor.observerInfo = observerInfo;
+        }
+    };
+}
+
+var 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;
+        if (resourceTotal === 0) {
+            _this.resource.emit(LOAD_EVENT.COMPLETE, _this);
+        }
+        return _this;
+    }
+    Progress.prototype.onStart = function () {
+        this.resource.emit(LOAD_EVENT.START, this);
+    };
+    Progress.prototype.onProgress = function (param) {
+        this.resourceLoadedCount++;
+        this.progress = Math.floor((this.resourceLoadedCount / this.resourceTotal) * 100) / 100;
+        if (param.success) {
+            this.resource.emit(LOAD_EVENT.LOADED, this, param);
+        }
+        else {
+            this.resource.emit(LOAD_EVENT.ERROR, this, param);
+        }
+        this.resource.emit(LOAD_EVENT.PROGRESS, this, param);
+        if (this.resourceLoadedCount === this.resourceTotal) {
+            this.resource.emit(LOAD_EVENT.COMPLETE, this);
+        }
+    };
+    return Progress;
+}(EventEmitter));
+var Progress$1 = Progress;
+
+var resourceLoader = {
+    AbstractLoadStrategy: AbstractLoadStrategy,
+    AudioLoadStrategy: AudioLoadStrategy,
+    ImageLoadStrategy: ImageLoadStrategy,
+    XhrResponseType: XhrResponseType,
+    MediaElementLoadStrategy: MediaElementLoadStrategy,
+    VideoLoadStrategy: VideoLoadStrategy,
+    XhrLoadStrategy: XhrLoadStrategy,
+    Loader: Loader,
+    Resource: Resource$1,
+    ResourceType: ResourceType,
+    ResourceState: ResourceState
+};
+
+var LOAD_EVENT;
+(function (LOAD_EVENT) {
+    LOAD_EVENT["START"] = "start";
+    LOAD_EVENT["PROGRESS"] = "progress";
+    LOAD_EVENT["LOADED"] = "loaded";
+    LOAD_EVENT["COMPLETE"] = "complete";
+    LOAD_EVENT["ERROR"] = "error";
+})(LOAD_EVENT || (LOAD_EVENT = {}));
+var RESOURCE_TYPE;
+(function (RESOURCE_TYPE) {
+    RESOURCE_TYPE["IMAGE"] = "IMAGE";
+    RESOURCE_TYPE["SPRITE"] = "SPRITE";
+    RESOURCE_TYPE["SPRITE_ANIMATION"] = "SPRITE_ANIMATION";
+    RESOURCE_TYPE["AUDIO"] = "AUDIO";
+    RESOURCE_TYPE["VIDEO"] = "VIDEO";
+})(RESOURCE_TYPE || (RESOURCE_TYPE = {}));
+XhrLoadStrategy.setExtensionXhrType('json', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('tex', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('ske', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('mp3', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('wav', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('aac', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('ogg', XhrResponseType.Buffer);
+var RESOURCE_TYPE_STRATEGY = {
+    png: ImageLoadStrategy,
+    jpg: ImageLoadStrategy,
+    jpeg: ImageLoadStrategy,
+    webp: ImageLoadStrategy,
+    json: XhrLoadStrategy,
+    tex: XhrLoadStrategy,
+    ske: XhrLoadStrategy,
+    audio: XhrLoadStrategy,
+    video: VideoLoadStrategy,
+};
+var Resource = (function (_super) {
+    __extends(Resource, _super);
+    function Resource(options) {
+        var _this = _super.call(this) || this;
+        _this.timeout = 6000;
+        _this.preProcessResourceHandlers = [];
+        _this.resourcesMap = {};
+        _this.makeInstanceFunctions = {};
+        _this.destroyInstanceFunctions = {};
+        _this.promiseMap = {};
+        _this.loaders = [];
+        if (options && typeof options.timeout === 'number') {
+            _this.timeout = options.timeout;
+        }
+        return _this;
+    }
+    Resource.prototype.loadConfig = function (resources) {
+        this.addResource(resources);
+        this.preload();
+    };
+    Resource.prototype.loadSingle = function (resource) {
+        this.addResource([resource]);
+        return this.getResource(resource.name);
+    };
+    Resource.prototype.addResource = function (resources) {
+        var e_1, _a;
+        if (!resources || resources.length < 1) {
+            console.warn('no resources');
+            return;
+        }
+        try {
+            for (var resources_1 = __values(resources), resources_1_1 = resources_1.next(); !resources_1_1.done; resources_1_1 = resources_1.next()) {
+                var res = resources_1_1.value;
+                if (this.resourcesMap[res.name]) {
+                    console.warn(res.name + ' was already added');
+                    continue;
+                }
+                this.resourcesMap[res.name] = res;
+                this.resourcesMap[res.name].data = {};
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (resources_1_1 && !resources_1_1.done && (_a = resources_1.return)) _a.call(resources_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    Resource.prototype.addPreProcessResourceHandler = function (handler) {
+        this.preProcessResourceHandlers.push(handler);
+    };
+    Resource.prototype.removePreProcessResourceHandler = function (handler) {
+        this.preProcessResourceHandlers.splice(this.preProcessResourceHandlers.indexOf(handler), 1);
+    };
+    Resource.prototype.preload = function () {
+        var names = [];
+        for (var key in this.resourcesMap) {
+            var resource_1 = this.resourcesMap[key];
+            if (resource_1.preload && !resource_1.complete && !this.promiseMap[key]) {
+                names.push(resource_1.name);
+            }
+        }
+        this.progress = new Progress$1({
+            resource: this,
+            resourceTotal: names.length,
+        });
+        this.loadResource({ names: names, preload: true });
+    };
+    Resource.prototype.getResource = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.loadResource({ names: [name] });
+                return [2, this.promiseMap[name] || Promise.resolve({})];
+            });
+        });
+    };
+    Resource.prototype.instance = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        res = this.resourcesMap[name];
+                        _a = this.makeInstanceFunctions[res.type];
+                        if (!_a) return [3, 2];
+                        return [4, this.makeInstanceFunctions[res.type](res)];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2: return [2, _a];
+                }
+            });
+        });
+    };
+    Resource.prototype.destroy = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this._destroy(name)];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    Resource.prototype._destroy = function (name, loadError) {
+        if (loadError === void 0) { loadError = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var resource, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resource = this.resourcesMap[name];
+                        if (!resource)
+                            return [2];
+                        if (!!loadError) return [3, 5];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        if (!this.destroyInstanceFunctions[resource.type]) return [3, 3];
+                        return [4, this.destroyInstanceFunctions[resource.type](resource)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [3, 5];
+                    case 4:
+                        e_2 = _a.sent();
+                        console.warn("destroy resource " + resource.name + " error with '" + e_2.message + "'");
+                        return [3, 5];
+                    case 5:
+                        delete this.promiseMap[name];
+                        resource.data = {};
+                        resource.complete = false;
+                        resource.instance = undefined;
+                        return [2];
+                }
+            });
+        });
+    };
+    Resource.prototype.registerResourceType = function (type, value) {
+        if (value === void 0) { value = type; }
+        if (RESOURCE_TYPE[type]) {
+            throw new Error("The type " + type + " already exists in RESOURCE_TYPE");
+        }
+        RESOURCE_TYPE[type] = value;
+    };
+    Resource.prototype.registerInstance = function (type, callback) {
+        this.makeInstanceFunctions[type] = callback;
+    };
+    Resource.prototype.registerDestroy = function (type, callback) {
+        this.destroyInstanceFunctions[type] = callback;
+    };
+    Resource.prototype.loadResource = function (_a) {
+        var _this = this;
+        var _b = _a.names, names = _b === void 0 ? [] : _b, _c = _a.preload, preload = _c === void 0 ? false : _c;
+        var unLoadNames = names.filter(function (name) { return !_this.promiseMap[name] && _this.resourcesMap[name]; });
+        if (!unLoadNames.length)
+            return;
+        var resolves = {};
+        var loader = this.getLoader(preload);
+        unLoadNames.forEach(function (name) {
+            var e_3, _a;
+            _this.promiseMap[name] = new Promise(function (r) { return (resolves[name] = r); });
+            var res = _this.resourcesMap[name];
+            try {
+                for (var _b = __values(_this.preProcessResourceHandlers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var handler = _c.value;
+                    handler(res);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            for (var key in res.src) {
+                var resourceType = res.src[key].type;
+                if (resourceType === 'data') {
+                    res.data[key] = res.src[key].data;
+                    _this.doComplete(name, resolves[name], preload);
+                }
+                else {
+                    loader.add({
+                        url: res.src[key].url,
+                        name: res.name + "_" + key,
+                        strategy: RESOURCE_TYPE_STRATEGY[resourceType],
+                        metadata: {
+                            key: key,
+                            name: res.name,
+                            resolves: resolves,
+                        },
+                    });
+                }
+            }
+        });
+        loader.load();
+    };
+    Resource.prototype.doComplete = function (name, resolve, preload) {
+        if (preload === void 0) { preload = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var res, param, _a, err_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        res = this.resourcesMap[name];
+                        param = {
+                            name: name,
+                            resource: this.resourcesMap[name],
+                            success: true,
+                        };
+                        if (!this.checkAllLoaded(name)) return [3, 4];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        _a = res;
+                        return [4, this.instance(name)];
+                    case 2:
+                        _a.instance = _b.sent();
+                        res.complete = true;
+                        if (preload) {
+                            this.progress.onProgress(param);
+                        }
+                        resolve(res);
+                        return [3, 4];
+                    case 3:
+                        err_1 = _b.sent();
+                        console.error(err_1);
+                        res.complete = false;
+                        if (preload) {
+                            param.errMsg = err_1.message;
+                            param.success = false;
+                            this.progress.onProgress(param);
+                        }
+                        resolve({});
+                        return [3, 4];
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    Resource.prototype.checkAllLoaded = function (name) {
+        var res = this.resourcesMap[name];
+        return Array.from(Object.keys(res.src)).every(function (resourceKey) { return res.data[resourceKey]; });
+    };
+    Resource.prototype.getLoader = function (preload) {
+        var _this = this;
+        if (preload === void 0) { preload = false; }
+        var loader = this.loaders.find(function (_a) {
+            var loading = _a.loading;
+            return !loading;
+        });
+        if (!loader) {
+            loader = new Loader();
+            this.loaders.push(loader);
+        }
+        if (preload) {
+            loader.onStart.once(function () {
+                _this.progress.onStart();
+            });
+        }
+        loader.onLoad.add(function (_, resource) {
+            _this.onLoad({ preload: preload, resource: resource });
+        });
+        loader.onError.add(function (errMsg, _, resource) {
+            _this.onError({ errMsg: errMsg, resource: resource, preload: preload });
+        });
+        loader.onComplete.once(function () {
+            loader.onLoad.detachAll();
+            loader.onError.detachAll();
+            loader.reset();
+        });
+        return loader;
+    };
+    Resource.prototype.onLoad = function (_a) {
+        var _b = _a.preload, preload = _b === void 0 ? false : _b, resource = _a.resource;
+        return __awaiter(this, void 0, void 0, function () {
+            var _c, key, name, resolves, data, res;
+            return __generator(this, function (_d) {
+                _c = resource.metadata, key = _c.key, name = _c.name, resolves = _c.resolves, data = resource.data;
+                res = this.resourcesMap[name];
+                res.data[key] = data;
+                this.doComplete(name, resolves[name], preload);
+                return [2];
+            });
+        });
+    };
+    Resource.prototype.onError = function (_a) {
+        var errMsg = _a.errMsg, _b = _a.preload, preload = _b === void 0 ? false : _b, resource = _a.resource;
+        return __awaiter(this, void 0, void 0, function () {
+            var _c, name, resolves, param;
+            return __generator(this, function (_d) {
+                _c = resource.metadata, name = _c.name, resolves = _c.resolves;
+                this._destroy(name, true);
+                resolves[name]({});
+                if (preload) {
+                    param = {
+                        name: name,
+                        resource: this.resourcesMap[name],
+                        success: false,
+                        errMsg: errMsg,
+                    };
+                    this.progress.onProgress(param);
+                }
+                return [2];
+            });
+        });
+    };
+    return Resource;
+}(EventEmitter));
+var resource = new Resource();
+
+var decorators = {
+    IDEProp: IDEProp,
+    componentObserver: componentObserver,
+};
+var version = '1.2.2-alpha.5';
+console.log("Eva.js version: " + version);
+
+export { Component$1 as Component, Game$1 as Game, GameObject$1 as GameObject, IDEProp, LOAD_EVENT, LOAD_SCENE_MODE, ObserverType as OBSERVER_TYPE, RESOURCE_TYPE, RESOURCE_TYPE_STRATEGY, Scene$1 as Scene, System$1 as System, Transform$1 as Transform, componentObserver, decorators, resource, resourceLoader, version };