@eva/plugin-a11y 1.2.7-editor.8 → 1.2.7-fix.1

package/dist/EVA.plugin.a11y.js

@@ -1,968 +1,3715 @@
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-window.EVA = window.EVA || {};
-window.EVA.plugin = window.EVA.plugin || {};
-
-var _EVA_IIFE_a11y = function (exports, eva_js, pluginRenderer) {
-  'use strict';
-
-  var _extendStatics = function extendStatics(d, b) {
-    _extendStatics = Object.setPrototypeOf || {
-      __proto__: []
-    } instanceof Array && function (d, b) {
-      d.__proto__ = b;
-    } || function (d, b) {
-      for (var p in b) {
-        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-      }
-    };
-
-    return _extendStatics(d, b);
-  };
-
-  function __extends(d, b) {
-    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-
-    _extendStatics(d, b);
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@eva/eva.js'), require('pixi.js')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@eva/eva.js', 'pixi.js'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.EVA = global.EVA || {}, global.EVA.plugin = global.EVA.plugin || {}, global.EVA.plugin.a11y = {}), global.EVA, global.PIXI));
+}(this, (function (exports, eva_js, pixi_js) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics$2 = function(d, b) {
+        extendStatics$2 = 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$2(d, b);
+    };
+
+    function __extends$2(d, b) {
+        extendStatics$2(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign$1 = function() {
+        __assign$1 = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$1.apply(this, arguments);
+    };
+
+    function __decorate$1(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) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        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) : adopt(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$1(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
 
-    function __() {
-      this.constructor = d;
+    /*! *****************************************************************************
+    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$1 = function(d, b) {
+        extendStatics$1 = 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$1(d, b);
+    };
+
+    function __extends$1(d, b) {
+        extendStatics$1(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     }
 
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
+    var Application = (function (_super) {
+        __extends$1(Application, _super);
+        function Application(params) {
+            var _this = this;
+            params.autoStart = false;
+            _this = _super.call(this, params) || this;
+            return _this;
+        }
+        return Application;
+    }(pixi_js.Application));
+    var Application$1 = Application;
+
+    var Container = (function (_super) {
+        __extends$1(Container, _super);
+        function Container() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return Container;
+    }(pixi_js.Container));
+    var Container$1 = Container;
+
+    ((function (_super) {
+        __extends$1(Graphics, _super);
+        function Graphics() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return Graphics;
+    })(pixi_js.Graphics));
+
+    ((function (_super) {
+        __extends$1(NinePatch, _super);
+        function NinePatch(img, leftWidth, topHeight, rightWidth, bottomHeight) {
+            var _this = this;
+            var texture;
+            if (img === 'string') {
+                texture = pixi_js.Texture.fromFrame(img);
+            }
+            else {
+                texture = pixi_js.Texture.from(img);
+            }
+            _this = _super.call(this, texture, leftWidth, topHeight, rightWidth, bottomHeight) || this;
+            return _this;
+        }
+        return NinePatch;
+    })(pixi_js.mesh.NineSlicePlane));
+
+    ((function () {
+        function Sprite(image) {
+            this._image = null;
+            this._image = image;
+            if (image) {
+                if (image instanceof HTMLImageElement) {
+                    this.sprite = pixi_js.Sprite.from(image);
+                }
+                else if (image instanceof pixi_js.Texture) {
+                    this.sprite = new pixi_js.Sprite(image);
+                }
+            }
+            else {
+                this.sprite = new pixi_js.Sprite();
+            }
+        }
+        Object.defineProperty(Sprite.prototype, "image", {
+            get: function () {
+                return this._image;
+            },
+            set: function (val) {
+                if (this._image === val) {
+                    return;
+                }
+                if (val instanceof HTMLImageElement) {
+                    this.sprite.texture && this.sprite.texture.destroy(false);
+                    this.sprite.texture = pixi_js.Texture.from(val);
+                }
+                else if (val instanceof pixi_js.Texture) {
+                    this.sprite.texture = val;
+                }
+                this._image = val;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return Sprite;
+    })());
+
+    ((function () {
+        function SpriteAnimation(_a) {
+            var frames = _a.frames;
+            this.animatedSprite = new pixi_js.extras.AnimatedSprite(frames);
+        }
+        SpriteAnimation.prototype.play = function () {
+            this.animatedSprite.play();
+        };
+        SpriteAnimation.prototype.stop = function () {
+            this.animatedSprite.stop();
+        };
+        SpriteAnimation.prototype.gotoAndPlay = function (frameNumber) {
+            this.animatedSprite.gotoAndPlay(frameNumber);
+        };
+        SpriteAnimation.prototype.gotoAndStop = function (frameNumber) {
+            this.animatedSprite.gotoAndStop(frameNumber);
+        };
+        Object.defineProperty(SpriteAnimation.prototype, "speed", {
+            get: function () {
+                return this.animatedSprite.animationSpeed;
+            },
+            set: function (val) {
+                this.animatedSprite.animationSpeed = val;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return SpriteAnimation;
+    })());
+
+    ((function (_super) {
+        __extends$1(Text, _super);
+        function Text(text, style) {
+            return _super.call(this, text, style) || this;
+        }
+        return Text;
+    })(pixi_js.Text));
+
+    var PIXITilingSprite = pixi_js.extras.TilingSprite;
+    ((function () {
+        function TilingSprite(image) {
+            this._image = null;
+            this._image = image;
+            if (image) {
+                if (image instanceof HTMLImageElement) {
+                    this.tilingSprite = new PIXITilingSprite(pixi_js.Texture.from(image));
+                }
+                else if (image instanceof pixi_js.Texture) {
+                    this.tilingSprite = new PIXITilingSprite(image);
+                }
+            }
+            else {
+                this.tilingSprite = new PIXITilingSprite(pixi_js.Texture.EMPTY);
+            }
+        }
+        Object.defineProperty(TilingSprite.prototype, "image", {
+            get: function () {
+                return this._image;
+            },
+            set: function (val) {
+                if (this._image === val) {
+                    return;
+                }
+                if (val instanceof HTMLImageElement) {
+                    this.tilingSprite.texture = pixi_js.Texture.from(val);
+                }
+                else if (val instanceof pixi_js.Texture) {
+                    this.tilingSprite.texture = val;
+                }
+                this._image = val;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return TilingSprite;
+    })());
+
+    /**
+     * Removes all key-value entries from the list cache.
+     *
+     * @private
+     * @name clear
+     * @memberOf ListCache
+     */
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
 
-  var _assign = function __assign() {
-    _assign = Object.assign || function __assign(t) {
-      for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
+    /**
+     * Performs a
+     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+     * comparison between two values to determine if they are equivalent.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to compare.
+     * @param {*} other The other value to compare.
+     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+     * @example
+     *
+     * var object = { 'a': 1 };
+     * var other = { 'a': 1 };
+     *
+     * _.eq(object, object);
+     * // => true
+     *
+     * _.eq(object, other);
+     * // => false
+     *
+     * _.eq('a', 'a');
+     * // => true
+     *
+     * _.eq('a', Object('a'));
+     * // => false
+     *
+     * _.eq(NaN, NaN);
+     * // => true
+     */
+    function eq(value, other) {
+      return value === other || (value !== value && other !== other);
+    }
 
-        for (var p in s) {
-          if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    /**
+     * Gets the index at which the `key` is found in `array` of key-value pairs.
+     *
+     * @private
+     * @param {Array} array The array to inspect.
+     * @param {*} key The key to search for.
+     * @returns {number} Returns the index of the matched value, else `-1`.
+     */
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
         }
       }
+      return -1;
+    }
 
-      return t;
-    };
-
-    return _assign.apply(this, arguments);
-  };
-
-  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;
+    /** Used for built-in method references. */
+    var arrayProto = Array.prototype;
+
+    /** Built-in value references. */
+    var splice = arrayProto.splice;
+
+    /**
+     * Removes `key` and its value from the list cache.
+     *
+     * @private
+     * @name delete
+     * @memberOf ListCache
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function listCacheDelete(key) {
+      var data = this.__data__,
+          index = assocIndexOf(data, key);
+
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
     }
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-  }
 
-  function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-  }
+    /**
+     * Gets the list cache value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf ListCache
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function listCacheGet(key) {
+      var data = this.__data__,
+          index = assocIndexOf(data, key);
+
+      return index < 0 ? undefined : data[index][1];
+    }
 
-  function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) {
-      return value instanceof P ? value : new P(function (resolve) {
-        resolve(value);
-      });
+    /**
+     * Checks if a list cache value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf ListCache
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
     }
 
-    return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
+    /**
+     * Sets the list cache `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf ListCache
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the list cache instance.
+     */
+    function listCacheSet(key, value) {
+      var data = this.__data__,
+          index = assocIndexOf(data, key);
+
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
       }
+      return this;
+    }
 
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
-        }
+    /**
+     * Creates an list cache object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function ListCache(entries) {
+      var index = -1,
+          length = entries == null ? 0 : entries.length;
+
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
       }
+    }
 
-      function step(result) {
-        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-      }
+    // Add methods to `ListCache`.
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype['delete'] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+
+    /**
+     * Removes all key-value entries from the stack.
+     *
+     * @private
+     * @name clear
+     * @memberOf Stack
+     */
+    function stackClear() {
+      this.__data__ = new ListCache;
+      this.size = 0;
+    }
 
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-  }
-
-  function __generator(thisArg, body) {
-    var _ = {
-      label: 0,
-      sent: function sent() {
-        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;
+    /**
+     * Removes `key` and its value from the stack.
+     *
+     * @private
+     * @name delete
+     * @memberOf Stack
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function stackDelete(key) {
+      var data = this.__data__,
+          result = data['delete'](key);
+
+      this.size = data.size;
+      return result;
+    }
 
-    function verb(n) {
-      return function (v) {
-        return step([n, v]);
-      };
+    /**
+     * Gets the stack value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf Stack
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function stackGet(key) {
+      return this.__data__.get(key);
     }
 
-    function step(op) {
-      if (f) throw new TypeError("Generator is already executing.");
+    /**
+     * Checks if a stack value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf Stack
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
 
-      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];
+    /** Detect free variable `global` from Node.js. */
+    var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
 
-          switch (op[0]) {
-            case 0:
-            case 1:
-              t = op;
-              break;
+    var freeGlobal$1 = freeGlobal;
 
-            case 4:
-              _.label++;
-              return {
-                value: op[1],
-                done: false
-              };
+    /** Detect free variable `self`. */
+    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
 
-            case 5:
-              _.label++;
-              y = op[1];
-              op = [0];
-              continue;
+    /** Used as a reference to the global object. */
+    var root = freeGlobal$1 || freeSelf || Function('return this')();
 
-            case 7:
-              op = _.ops.pop();
+    var root$1 = root;
 
-              _.trys.pop();
+    /** Built-in value references. */
+    var Symbol$1 = root$1.Symbol;
 
-              continue;
+    var Symbol$2 = Symbol$1;
 
-            default:
-              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                _ = 0;
-                continue;
-              }
+    /** Used for built-in method references. */
+    var objectProto$b = Object.prototype;
 
-              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                _.label = op[1];
-                break;
-              }
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$8 = objectProto$b.hasOwnProperty;
 
-              if (op[0] === 6 && _.label < t[1]) {
-                _.label = t[1];
-                t = op;
-                break;
-              }
+    /**
+     * Used to resolve the
+     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+     * of values.
+     */
+    var nativeObjectToString$1 = objectProto$b.toString;
 
-              if (t && _.label < t[2]) {
-                _.label = t[2];
+    /** Built-in value references. */
+    var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
 
-                _.ops.push(op);
+    /**
+     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @returns {string} Returns the raw `toStringTag`.
+     */
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty$8.call(value, symToStringTag$1),
+          tag = value[symToStringTag$1];
 
-                break;
-              }
+      try {
+        value[symToStringTag$1] = undefined;
+        var unmasked = true;
+      } catch (e) {}
+
+      var result = nativeObjectToString$1.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag$1] = tag;
+        } else {
+          delete value[symToStringTag$1];
+        }
+      }
+      return result;
+    }
 
-              if (t[2]) _.ops.pop();
+    /** Used for built-in method references. */
+    var objectProto$a = Object.prototype;
+
+    /**
+     * Used to resolve the
+     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+     * of values.
+     */
+    var nativeObjectToString = objectProto$a.toString;
+
+    /**
+     * Converts `value` to a string using `Object.prototype.toString`.
+     *
+     * @private
+     * @param {*} value The value to convert.
+     * @returns {string} Returns the converted string.
+     */
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
 
-              _.trys.pop();
+    /** `Object#toString` result references. */
+    var nullTag = '[object Null]',
+        undefinedTag = '[object Undefined]';
+
+    /** Built-in value references. */
+    var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+    /**
+     * The base implementation of `getTag` without fallbacks for buggy environments.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @returns {string} Returns the `toStringTag`.
+     */
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === undefined ? undefinedTag : nullTag;
+      }
+      return (symToStringTag && symToStringTag in Object(value))
+        ? getRawTag(value)
+        : objectToString(value);
+    }
 
-              continue;
-          }
+    /**
+     * Checks if `value` is the
+     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+     * @example
+     *
+     * _.isObject({});
+     * // => true
+     *
+     * _.isObject([1, 2, 3]);
+     * // => true
+     *
+     * _.isObject(_.noop);
+     * // => true
+     *
+     * _.isObject(null);
+     * // => false
+     */
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == 'object' || type == 'function');
+    }
 
-          op = body.call(thisArg, _);
-        } catch (e) {
-          op = [6, e];
-          y = 0;
-        } finally {
-          f = t = 0;
-        }
+    /** `Object#toString` result references. */
+    var asyncTag = '[object AsyncFunction]',
+        funcTag$1 = '[object Function]',
+        genTag = '[object GeneratorFunction]',
+        proxyTag = '[object Proxy]';
+
+    /**
+     * Checks if `value` is classified as a `Function` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+     * @example
+     *
+     * _.isFunction(_);
+     * // => true
+     *
+     * _.isFunction(/abc/);
+     * // => false
+     */
+    function isFunction(value) {
+      if (!isObject(value)) {
+        return false;
       }
+      // The use of `Object#toString` avoids issues with the `typeof` operator
+      // in Safari 9 which returns 'object' for typed arrays and other constructors.
+      var tag = baseGetTag(value);
+      return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
 
-      if (op[0] & 5) throw op[1];
-      return {
-        value: op[0] ? op[1] : void 0,
-        done: true
-      };
+    /** Used to detect overreaching core-js shims. */
+    var coreJsData = root$1['__core-js_shared__'];
+
+    var coreJsData$1 = coreJsData;
+
+    /** Used to detect methods masquerading as native. */
+    var maskSrcKey = (function() {
+      var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || '');
+      return uid ? ('Symbol(src)_1.' + uid) : '';
+    }());
+
+    /**
+     * Checks if `func` has its source masked.
+     *
+     * @private
+     * @param {Function} func The function to check.
+     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+     */
+    function isMasked(func) {
+      return !!maskSrcKey && (maskSrcKey in func);
     }
-  }
-
-  function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator,
-        m = s && o[s],
-        i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-      next: function next() {
-        if (o && i >= o.length) o = void 0;
-        return {
-          value: o && o[i++],
-          done: !o
-        };
-      }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-  }
 
-  var SymbolKeysNotSupportedError = function (_super) {
-    __extends(SymbolKeysNotSupportedError, _super);
+    /** Used for built-in method references. */
+    var funcProto$1 = Function.prototype;
+
+    /** Used to resolve the decompiled source of functions. */
+    var funcToString$1 = funcProto$1.toString;
+
+    /**
+     * Converts `func` to its source code.
+     *
+     * @private
+     * @param {Function} func The function to convert.
+     * @returns {string} Returns the source code.
+     */
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString$1.call(func);
+        } catch (e) {}
+        try {
+          return (func + '');
+        } catch (e) {}
+      }
+      return '';
+    }
 
-    function SymbolKeysNotSupportedError() {
-      var _newTarget = this.constructor;
+    /**
+     * Used to match `RegExp`
+     * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+     */
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+    /** Used to detect host constructors (Safari). */
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+    /** Used for built-in method references. */
+    var funcProto = Function.prototype,
+        objectProto$9 = Object.prototype;
+
+    /** Used to resolve the decompiled source of functions. */
+    var funcToString = funcProto.toString;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+
+    /** Used to detect if a method is native. */
+    var reIsNative = RegExp('^' +
+      funcToString.call(hasOwnProperty$7).replace(reRegExpChar, '\\$&')
+      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+    );
+
+    /**
+     * The base implementation of `_.isNative` without bad shim checks.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a native function,
+     *  else `false`.
+     */
+    function baseIsNative(value) {
+      if (!isObject(value) || isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value));
+    }
 
-      var _this = _super.call(this, 'Symbol keys are not supported yet!') || this;
+    /**
+     * Gets the value at `key` of `object`.
+     *
+     * @private
+     * @param {Object} [object] The object to query.
+     * @param {string} key The key of the property to get.
+     * @returns {*} Returns the property value.
+     */
+    function getValue(object, key) {
+      return object == null ? undefined : object[key];
+    }
 
-      Object.setPrototypeOf(_this, _newTarget.prototype);
-      return _this;
+    /**
+     * Gets the native function at `key` of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @param {string} key The key of the method to get.
+     * @returns {*} Returns the function if it's native, else `undefined`.
+     */
+    function getNative(object, key) {
+      var value = getValue(object, key);
+      return baseIsNative(value) ? value : undefined;
     }
 
-    return SymbolKeysNotSupportedError;
-  }(Error);
+    /* Built-in method references that are verified to be native. */
+    var Map$1 = getNative(root$1, 'Map');
 
-  (function (_super) {
-    __extends(StaticGetPropertiesIsNotAFunctionError, _super);
+    var Map$2 = Map$1;
 
-    function StaticGetPropertiesIsNotAFunctionError() {
-      var _newTarget = this.constructor;
+    /* Built-in method references that are verified to be native. */
+    var nativeCreate = getNative(Object, 'create');
 
-      var _this = _super.call(this, 'getProperties is not a function!') || this;
+    var nativeCreate$1 = nativeCreate;
 
-      Object.setPrototypeOf(_this, _newTarget.prototype);
-      return _this;
+    /**
+     * Removes all key-value entries from the hash.
+     *
+     * @private
+     * @name clear
+     * @memberOf Hash
+     */
+    function hashClear() {
+      this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {};
+      this.size = 0;
     }
 
-    return StaticGetPropertiesIsNotAFunctionError;
-  })(Error);
+    /**
+     * Removes `key` and its value from the hash.
+     *
+     * @private
+     * @name delete
+     * @memberOf Hash
+     * @param {Object} hash The hash to modify.
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
 
-  var IDE_PROPERTY_METADATA = 'IDE_PROPERTY_METADATA';
+    /** Used to stand-in for `undefined` hash values. */
+    var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';
+
+    /** Used for built-in method references. */
+    var objectProto$8 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+
+    /**
+     * Gets the hash value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf Hash
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate$1) {
+        var result = data[key];
+        return result === HASH_UNDEFINED$2 ? undefined : result;
+      }
+      return hasOwnProperty$6.call(data, key) ? data[key] : undefined;
+    }
 
-  function transformBasicType(type) {
-    if (type === String) {
-      return 'string';
+    /** Used for built-in method references. */
+    var objectProto$7 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
+
+    /**
+     * Checks if a hash value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf Hash
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate$1 ? (data[key] !== undefined) : hasOwnProperty$5.call(data, key);
     }
 
-    if (type === Number) {
-      return 'number';
+    /** Used to stand-in for `undefined` hash values. */
+    var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+
+    /**
+     * Sets the hash `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf Hash
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the hash instance.
+     */
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = (nativeCreate$1 && value === undefined) ? HASH_UNDEFINED$1 : value;
+      return this;
     }
 
-    if (type === Boolean) {
-      return 'boolean';
+    /**
+     * Creates a hash object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function Hash(entries) {
+      var index = -1,
+          length = entries == null ? 0 : entries.length;
+
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
     }
 
-    return 'unknown';
-  }
+    // Add methods to `Hash`.
+    Hash.prototype.clear = hashClear;
+    Hash.prototype['delete'] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+
+    /**
+     * Removes all key-value entries from the map.
+     *
+     * @private
+     * @name clear
+     * @memberOf MapCache
+     */
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        'hash': new Hash,
+        'map': new (Map$2 || ListCache),
+        'string': new Hash
+      };
+    }
 
-  function defineTypes(target, key, options, returnTypeFunction) {
-    var type = Reflect.getMetadata('design:type', target, key);
-    var isArray = type === Array;
-    var str = transformBasicType(type);
+    /**
+     * Checks if `value` is suitable for use as unique object key.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+     */
+    function isKeyable(value) {
+      var type = typeof value;
+      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+        ? (value !== '__proto__')
+        : (value === null);
+    }
 
-    if (str !== 'unknown') {
-      type = str;
+    /**
+     * Gets the data for `map`.
+     *
+     * @private
+     * @param {Object} map The map to query.
+     * @param {string} key The reference key.
+     * @returns {*} Returns the map data.
+     */
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key)
+        ? data[typeof key == 'string' ? 'string' : 'hash']
+        : data.map;
     }
 
-    if (returnTypeFunction) {
-      var returnType = returnTypeFunction();
+    /**
+     * Removes `key` and its value from the map.
+     *
+     * @private
+     * @name delete
+     * @memberOf MapCache
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)['delete'](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
 
-      if (Array.isArray(returnType)) {
-        isArray = true;
-        type = returnType[0];
-      } else {
-        type = returnType;
-      }
+    /**
+     * Gets the map value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf MapCache
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
     }
 
-    var properties = Reflect.getMetadata(IDE_PROPERTY_METADATA, target.constructor) || {};
-    properties[key] = _assign({
-      type: type,
-      isArray: isArray
-    }, options);
-    Reflect.defineMetadata(IDE_PROPERTY_METADATA, properties, target.constructor);
-  }
+    /**
+     * Checks if a map value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf MapCache
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
 
-  function getTypeDecoratorParams(returnTypeFuncOrOptions, maybeOptions) {
-    if (typeof returnTypeFuncOrOptions === 'function') {
-      return {
-        returnTypeFunc: returnTypeFuncOrOptions,
-        options: maybeOptions || {}
-      };
+    /**
+     * Sets the map `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf MapCache
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the map cache instance.
+     */
+    function mapCacheSet(key, value) {
+      var data = getMapData(this, key),
+          size = data.size;
+
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
     }
 
-    return {
-      options: returnTypeFuncOrOptions || {}
-    };
-  }
+    /**
+     * Creates a map cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function MapCache(entries) {
+      var index = -1,
+          length = entries == null ? 0 : entries.length;
+
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
 
-  function Field(returnTypeFunction, maybeOptions) {
-    return function (target, propertyKey) {
-      if (typeof propertyKey === 'symbol') {
-        throw new SymbolKeysNotSupportedError();
+    // Add methods to `MapCache`.
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype['delete'] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+
+    /** Used as the size to enable large array optimizations. */
+    var LARGE_ARRAY_SIZE = 200;
+
+    /**
+     * Sets the stack `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf Stack
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the stack cache instance.
+     */
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map$2 || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+          pairs.push([key, value]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
       }
+      data.set(key, value);
+      this.size = data.size;
+      return this;
+    }
 
-      var _a = getTypeDecoratorParams(returnTypeFunction, maybeOptions),
-          options = _a.options,
-          returnTypeFunc = _a.returnTypeFunc;
+    /**
+     * Creates a stack cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
 
-      defineTypes(target, propertyKey, options, returnTypeFunc);
-    };
-  }
-
-  var ExecuteMode;
-
-  (function (ExecuteMode) {
-    ExecuteMode[ExecuteMode["Edit"] = 2] = "Edit";
-    ExecuteMode[ExecuteMode["Game"] = 4] = "Game";
-    ExecuteMode[ExecuteMode["All"] = 6] = "All";
-  })(ExecuteMode || (ExecuteMode = {}));
-
-  function uuid(len) {
-    var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
-    var uuid = [];
-    var radix = chars.length;
-
-    for (var i = 0; i < len; i++) {
-      uuid[i] = chars[0 | Math.random() * radix];
-    }
-
-    return uuid.join('');
-  }
-
-  var setStyle = function setStyle(element, style) {
-    var width = style.width,
-        height = style.height,
-        position = style.position,
-        _a = style.left,
-        left = _a === void 0 ? 0 : _a,
-        _b = style.top,
-        top = _b === void 0 ? 0 : _b,
-        zIndex = style.zIndex,
-        pointerEvents = style.pointerEvents,
-        background = style.background;
-    element.style.width = width + "px";
-    element.style.height = height + "px";
-    element.style.position = position;
-    element.style.left = "" + left;
-    element.style.top = "" + top;
-    element.style.zIndex = "" + zIndex;
-    element.style.pointerEvents = pointerEvents;
-    element.style.background = background;
-    element.style.border = 'none';
-    element.style.overflow = 'hidden';
-  };
-
-  var setTransform = function setTransform(element, transform, ratioX, ratioY) {
-    var worldTransform = transform.worldTransform;
-    var a = worldTransform.a,
-        b = worldTransform.b,
-        c = worldTransform.c,
-        d = worldTransform.d,
-        tx = worldTransform.tx,
-        ty = worldTransform.ty;
-    var matrix = "matrix(" + a + ", " + b + ", " + c + ", " + d + ", " + tx * ratioX + ", " + ty * ratioY + ")";
-    element.style.transform = "" + matrix;
-    element.style.webkitTransform = "" + matrix;
-    element.style.transformOrigin = 'left top';
-    element.style.webkitTransformOrigin = 'left top';
-  };
-
-  var A11y = function (_super) {
-    __extends(A11y, _super);
-
-    function A11y(param) {
-      var _this = _super.call(this) || this;
-
-      _extends(_this, param);
-
-      var _a = param.hint,
-          hint = _a === void 0 ? '' : _a,
-          event = param.event,
-          _b = param.delay,
-          delay = _b === void 0 ? 0 : _b,
-          _c = param.attr,
-          attr = _c === void 0 ? {} : _c,
-          _d = param.role,
-          role = _d === void 0 ? '' : _d,
-          _e = param.props,
-          props = _e === void 0 ? {} : _e,
-          _f = param.state,
-          state = _f === void 0 ? {} : _f;
-      _this.hint = hint;
-      _this.event = event;
-      _this.delay = delay;
-      _this.attr = attr;
-      _this.role = role;
-      _this.props = props;
-      _this.state = state;
-      _this.a11yId = "_" + uuid(6);
-      return _this;
-    }
-
-    A11y.componentName = 'A11y';
-
-    __decorate([Field(), __metadata("design:type", Boolean)], A11y.prototype, "interactive", void 0);
-
-    __decorate([Field(), __metadata("design:type", String)], A11y.prototype, "hint", void 0);
-
-    __decorate([Field({
-      step: 1
-    }), __metadata("design:type", Number)], A11y.prototype, "delay", void 0);
-
-    __decorate([Field(), __metadata("design:type", String)], A11y.prototype, "role", void 0);
-
-    __decorate([Field(), __metadata("design:type", String)], A11y.prototype, "a11yId", void 0);
-
-    return A11y;
-  }(eva_js.Component);
-
-  var A11y$1 = A11y;
-  var POSITION = 'absolute';
-  var ZINDEX = 3;
-  exports.A11yActivate = void 0;
-
-  (function (A11yActivate) {
-    A11yActivate[A11yActivate["ENABLE"] = 0] = "ENABLE";
-    A11yActivate[A11yActivate["DISABLE"] = 1] = "DISABLE";
-    A11yActivate[A11yActivate["CHECK"] = 2] = "CHECK";
-  })(exports.A11yActivate || (exports.A11yActivate = {}));
-
-  var PointerEvents;
-
-  (function (PointerEvents) {
-    PointerEvents["NONE"] = "none";
-    PointerEvents["AUTO"] = "auto";
-  })(PointerEvents || (PointerEvents = {}));
-
-  var MaskBackground;
-
-  (function (MaskBackground) {
-    MaskBackground["DEBUG"] = "rgba(255,0,0,0.5)";
-    MaskBackground["NONE"] = "transparent";
-  })(MaskBackground || (MaskBackground = {}));
-
-  var ElementType;
-
-  (function (ElementType) {
-    ElementType["BUTTON"] = "button";
-    ElementType["DIV"] = "div";
-  })(ElementType || (ElementType = {}));
-
-  var notAttr = ['hint', 'event', 'delay', 'attr', 'role', 'props', 'state', 'a11yId', 'name'];
-
-  var getEventFunc = function getEventFunc(event, gameObject, e) {
-    var _this = this;
-
-    ['touchstart', 'touchend', 'tap'].forEach(function (name) {
-      event.emit(name, {
-        stopPropagation: function stopPropagation() {
-          return e.stopPropagation();
-        },
-        data: {
-          position: _this.eventPosition
-        },
-        gameObject: gameObject
-      });
-    });
-  };
+    // Add methods to `Stack`.
+    Stack.prototype.clear = stackClear;
+    Stack.prototype['delete'] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+
+    /** Used to stand-in for `undefined` hash values. */
+    var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+    /**
+     * Adds `value` to the array cache.
+     *
+     * @private
+     * @name add
+     * @memberOf SetCache
+     * @alias push
+     * @param {*} value The value to cache.
+     * @returns {Object} Returns the cache instance.
+     */
+    function setCacheAdd(value) {
+      this.__data__.set(value, HASH_UNDEFINED);
+      return this;
+    }
 
-  var A11ySystem = function (_super) {
-    __extends(A11ySystem, _super);
+    /**
+     * Checks if `value` is in the array cache.
+     *
+     * @private
+     * @name has
+     * @memberOf SetCache
+     * @param {*} value The value to search for.
+     * @returns {number} Returns `true` if `value` is found, else `false`.
+     */
+    function setCacheHas(value) {
+      return this.__data__.has(value);
+    }
 
-    function A11ySystem(opt) {
-      var _this = _super.call(this, opt) || this;
+    /**
+     *
+     * Creates an array cache object to store unique values.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [values] The values to cache.
+     */
+    function SetCache(values) {
+      var index = -1,
+          length = values == null ? 0 : values.length;
+
+      this.__data__ = new MapCache;
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
 
-      _this.cache = new Map();
-      _this.eventCache = new Map();
-      _this.zIndex = ZINDEX;
-      return _this;
+    // Add methods to `SetCache`.
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+
+    /**
+     * A specialized version of `_.some` for arrays without support for iteratee
+     * shorthands.
+     *
+     * @private
+     * @param {Array} [array] The array to iterate over.
+     * @param {Function} predicate The function invoked per iteration.
+     * @returns {boolean} Returns `true` if any element passes the predicate check,
+     *  else `false`.
+     */
+    function arraySome(array, predicate) {
+      var index = -1,
+          length = array == null ? 0 : array.length;
+
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
     }
 
-    Object.defineProperty(A11ySystem.prototype, "ratioX", {
-      get: function get() {
-        if (this._ratioX) {
-          return this._ratioX;
-        } else {
-          var success = this.setRatio();
+    /**
+     * Checks if a `cache` value for `key` exists.
+     *
+     * @private
+     * @param {Object} cache The cache to query.
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function cacheHas(cache, key) {
+      return cache.has(key);
+    }
 
-          if (success) {
-            return this._ratioX;
-          } else {
-            return 0;
+    /** Used to compose bitmasks for value comparisons. */
+    var COMPARE_PARTIAL_FLAG$3 = 1,
+        COMPARE_UNORDERED_FLAG$1 = 2;
+
+    /**
+     * A specialized version of `baseIsEqualDeep` for arrays with support for
+     * partial deep comparisons.
+     *
+     * @private
+     * @param {Array} array The array to compare.
+     * @param {Array} other The other array to compare.
+     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+     * @param {Function} customizer The function to customize comparisons.
+     * @param {Function} equalFunc The function to determine equivalents of values.
+     * @param {Object} stack Tracks traversed `array` and `other` objects.
+     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+     */
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3,
+          arrLength = array.length,
+          othLength = other.length;
+
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      // Check that cyclic values are equal.
+      var arrStacked = stack.get(array);
+      var othStacked = stack.get(other);
+      if (arrStacked && othStacked) {
+        return arrStacked == other && othStacked == array;
+      }
+      var index = -1,
+          result = true,
+          seen = (bitmask & COMPARE_UNORDERED_FLAG$1) ? new SetCache : undefined;
+
+      stack.set(array, other);
+      stack.set(other, array);
+
+      // Ignore non-index properties.
+      while (++index < arrLength) {
+        var arrValue = array[index],
+            othValue = other[index];
+
+        if (customizer) {
+          var compared = isPartial
+            ? customizer(othValue, arrValue, index, other, array, stack)
+            : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== undefined) {
+          if (compared) {
+            continue;
           }
+          result = false;
+          break;
         }
-      },
-      enumerable: false,
-      configurable: true
-    });
-    Object.defineProperty(A11ySystem.prototype, "ratioY", {
-      get: function get() {
-        if (this._ratioY) {
-          return this._ratioY;
-        } else {
-          var success = this.setRatio();
-
-          if (success) {
-            return this._ratioY;
-          } else {
-            return 0;
+        // Recursively compare arrays (susceptible to call stack limits).
+        if (seen) {
+          if (!arraySome(other, function(othValue, othIndex) {
+                if (!cacheHas(seen, othIndex) &&
+                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+                  return seen.push(othIndex);
+                }
+              })) {
+            result = false;
+            break;
           }
+        } else if (!(
+              arrValue === othValue ||
+                equalFunc(arrValue, othValue, bitmask, customizer, stack)
+            )) {
+          result = false;
+          break;
         }
-      },
-      enumerable: false,
-      configurable: true
-    });
-
-    A11ySystem.prototype.init = function (opt) {
-      if (opt === void 0) {
-        opt = {};
       }
+      stack['delete'](array);
+      stack['delete'](other);
+      return result;
+    }
 
-      return __awaiter(this, void 0, void 0, function () {
-        var _a, activate, _b, delay, _c, checkA11yOpen, zIndex, _d, _e, div;
-
-        return __generator(this, function (_f) {
-          switch (_f.label) {
-            case 0:
-              _a = opt.activate, activate = _a === void 0 ? exports.A11yActivate.CHECK : _a, _b = opt.delay, delay = _b === void 0 ? 100 : _b, _c = opt.checkA11yOpen, checkA11yOpen = _c === void 0 ? function () {
-                return Promise.resolve(false);
-              } : _c, zIndex = opt.zIndex;
-              this.delay = delay;
-              this.zIndex = zIndex || this.zIndex;
-              _d = activate;
+    /** Built-in value references. */
+    var Uint8Array = root$1.Uint8Array;
 
-              switch (_d) {
-                case exports.A11yActivate.CHECK:
-                  return [3, 1];
+    var Uint8Array$1 = Uint8Array;
 
-                case exports.A11yActivate.DISABLE:
-                  return [3, 5];
+    /**
+     * Converts `map` to its key-value pairs.
+     *
+     * @private
+     * @param {Object} map The map to convert.
+     * @returns {Array} Returns the key-value pairs.
+     */
+    function mapToArray(map) {
+      var index = -1,
+          result = Array(map.size);
 
-                case exports.A11yActivate.ENABLE:
-                  return [3, 6];
-              }
+      map.forEach(function(value, key) {
+        result[++index] = [key, value];
+      });
+      return result;
+    }
 
-              return [3, 7];
+    /**
+     * Converts `set` to an array of its values.
+     *
+     * @private
+     * @param {Object} set The set to convert.
+     * @returns {Array} Returns the values.
+     */
+    function setToArray(set) {
+      var index = -1,
+          result = Array(set.size);
+
+      set.forEach(function(value) {
+        result[++index] = value;
+      });
+      return result;
+    }
 
-            case 1:
-              _f.trys.push([1, 3,, 4]);
+    /** Used to compose bitmasks for value comparisons. */
+    var COMPARE_PARTIAL_FLAG$2 = 1,
+        COMPARE_UNORDERED_FLAG = 2;
+
+    /** `Object#toString` result references. */
+    var boolTag$1 = '[object Boolean]',
+        dateTag$1 = '[object Date]',
+        errorTag$1 = '[object Error]',
+        mapTag$2 = '[object Map]',
+        numberTag$1 = '[object Number]',
+        regexpTag$1 = '[object RegExp]',
+        setTag$2 = '[object Set]',
+        stringTag$1 = '[object String]',
+        symbolTag = '[object Symbol]';
+
+    var arrayBufferTag$1 = '[object ArrayBuffer]',
+        dataViewTag$2 = '[object DataView]';
+
+    /** Used to convert symbols to primitives and strings. */
+    var symbolProto = Symbol$2 ? Symbol$2.prototype : undefined,
+        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+    /**
+     * A specialized version of `baseIsEqualDeep` for comparing objects of
+     * the same `toStringTag`.
+     *
+     * **Note:** This function only supports comparing values with tags of
+     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+     *
+     * @private
+     * @param {Object} object The object to compare.
+     * @param {Object} other The other object to compare.
+     * @param {string} tag The `toStringTag` of the objects to compare.
+     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+     * @param {Function} customizer The function to customize comparisons.
+     * @param {Function} equalFunc The function to determine equivalents of values.
+     * @param {Object} stack Tracks traversed `object` and `other` objects.
+     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+     */
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag$2:
+          if ((object.byteLength != other.byteLength) ||
+              (object.byteOffset != other.byteOffset)) {
+            return false;
+          }
+          object = object.buffer;
+          other = other.buffer;
 
-              _e = this;
-              return [4, checkA11yOpen()];
+        case arrayBufferTag$1:
+          if ((object.byteLength != other.byteLength) ||
+              !equalFunc(new Uint8Array$1(object), new Uint8Array$1(other))) {
+            return false;
+          }
+          return true;
+
+        case boolTag$1:
+        case dateTag$1:
+        case numberTag$1:
+          // Coerce booleans to `1` or `0` and dates to milliseconds.
+          // Invalid dates are coerced to `NaN`.
+          return eq(+object, +other);
+
+        case errorTag$1:
+          return object.name == other.name && object.message == other.message;
+
+        case regexpTag$1:
+        case stringTag$1:
+          // Coerce regexes to strings and treat strings, primitives and objects,
+          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+          // for more details.
+          return object == (other + '');
+
+        case mapTag$2:
+          var convert = mapToArray;
+
+        case setTag$2:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2;
+          convert || (convert = setToArray);
+
+          if (object.size != other.size && !isPartial) {
+            return false;
+          }
+          // Assume cyclic values are equal.
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
 
-            case 2:
-              _e.activate = _f.sent();
-              return [3, 4];
+          // Recursively compare objects (susceptible to call stack limits).
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack['delete'](object);
+          return result;
 
-            case 3:
-              _f.sent();
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
+      return false;
+    }
 
-              this.activate = false;
-              return [3, 4];
+    /**
+     * Appends the elements of `values` to `array`.
+     *
+     * @private
+     * @param {Array} array The array to modify.
+     * @param {Array} values The values to append.
+     * @returns {Array} Returns `array`.
+     */
+    function arrayPush(array, values) {
+      var index = -1,
+          length = values.length,
+          offset = array.length;
+
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
 
-            case 4:
-              return [3, 7];
+    /**
+     * Checks if `value` is classified as an `Array` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+     * @example
+     *
+     * _.isArray([1, 2, 3]);
+     * // => true
+     *
+     * _.isArray(document.body.children);
+     * // => false
+     *
+     * _.isArray('abc');
+     * // => false
+     *
+     * _.isArray(_.noop);
+     * // => false
+     */
+    var isArray = Array.isArray;
+
+    var isArray$1 = isArray;
+
+    /**
+     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+     * symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @param {Function} keysFunc The function to get the keys of `object`.
+     * @param {Function} symbolsFunc The function to get the symbols of `object`.
+     * @returns {Array} Returns the array of property names and symbols.
+     */
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
 
-            case 5:
-              this.activate = false;
-              return [3, 7];
+    /**
+     * A specialized version of `_.filter` for arrays without support for
+     * iteratee shorthands.
+     *
+     * @private
+     * @param {Array} [array] The array to iterate over.
+     * @param {Function} predicate The function invoked per iteration.
+     * @returns {Array} Returns the new filtered array.
+     */
+    function arrayFilter(array, predicate) {
+      var index = -1,
+          length = array == null ? 0 : array.length,
+          resIndex = 0,
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
+    }
 
-            case 6:
-              this.activate = true;
-              return [3, 7];
+    /**
+     * This method returns a new empty array.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.13.0
+     * @category Util
+     * @returns {Array} Returns the new empty array.
+     * @example
+     *
+     * var arrays = _.times(2, _.stubArray);
+     *
+     * console.log(arrays);
+     * // => [[], []]
+     *
+     * console.log(arrays[0] === arrays[1]);
+     * // => false
+     */
+    function stubArray() {
+      return [];
+    }
 
-            case 7:
-              this.debug = opt.debug || false;
+    /** Used for built-in method references. */
+    var objectProto$6 = Object.prototype;
+
+    /** Built-in value references. */
+    var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+    /**
+     * Creates an array of the own enumerable symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of symbols.
+     */
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable$1.call(object, symbol);
+      });
+    };
 
-              if (this.debug) {
-                this.activate = true;
-              }
+    var getSymbols$1 = getSymbols;
+
+    /**
+     * The base implementation of `_.times` without support for iteratee shorthands
+     * or max array length checks.
+     *
+     * @private
+     * @param {number} n The number of times to invoke `iteratee`.
+     * @param {Function} iteratee The function invoked per iteration.
+     * @returns {Array} Returns the array of results.
+     */
+    function baseTimes(n, iteratee) {
+      var index = -1,
+          result = Array(n);
+
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
 
-              if (!this.activate) return [2];
-              div = document.createElement('div');
-              this.div = div;
+    /**
+     * Checks if `value` is object-like. A value is object-like if it's not `null`
+     * and has a `typeof` result of "object".
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+     * @example
+     *
+     * _.isObjectLike({});
+     * // => true
+     *
+     * _.isObjectLike([1, 2, 3]);
+     * // => true
+     *
+     * _.isObjectLike(_.noop);
+     * // => false
+     *
+     * _.isObjectLike(null);
+     * // => false
+     */
+    function isObjectLike(value) {
+      return value != null && typeof value == 'object';
+    }
 
-              if (this.game.canvas.parentNode) {
-                this.game.canvas.parentNode.insertBefore(this.div, this.game.canvas);
-              }
+    /** `Object#toString` result references. */
+    var argsTag$2 = '[object Arguments]';
+
+    /**
+     * The base implementation of `_.isArguments`.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+     */
+    function baseIsArguments(value) {
+      return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+    }
 
-              return [2];
-          }
-        });
-      });
+    /** Used for built-in method references. */
+    var objectProto$5 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+
+    /** Built-in value references. */
+    var propertyIsEnumerable = objectProto$5.propertyIsEnumerable;
+
+    /**
+     * Checks if `value` is likely an `arguments` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+     *  else `false`.
+     * @example
+     *
+     * _.isArguments(function() { return arguments; }());
+     * // => true
+     *
+     * _.isArguments([1, 2, 3]);
+     * // => false
+     */
+    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+      return isObjectLike(value) && hasOwnProperty$4.call(value, 'callee') &&
+        !propertyIsEnumerable.call(value, 'callee');
     };
 
-    A11ySystem.prototype.setRatio = function () {
-      var _a = this.getCanvasBoundingClientRect(),
-          width = _a.width,
-          height = _a.height;
+    var isArguments$1 = isArguments;
+
+    /**
+     * This method returns `false`.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.13.0
+     * @category Util
+     * @returns {boolean} Returns `false`.
+     * @example
+     *
+     * _.times(2, _.stubFalse);
+     * // => [false, false]
+     */
+    function stubFalse() {
+      return false;
+    }
 
-      var _b = this.getRenderRect(),
-          renderWidth = _b.renderWidth,
-          renderHeight = _b.renderHeight;
+    /** Detect free variable `exports`. */
+    var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+    /** Detect free variable `module`. */
+    var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
+
+    /** Detect the popular CommonJS extension `module.exports`. */
+    var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+
+    /** Built-in value references. */
+    var Buffer = moduleExports$1 ? root$1.Buffer : undefined;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+    /**
+     * Checks if `value` is a buffer.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.3.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+     * @example
+     *
+     * _.isBuffer(new Buffer(2));
+     * // => true
+     *
+     * _.isBuffer(new Uint8Array(2));
+     * // => false
+     */
+    var isBuffer = nativeIsBuffer || stubFalse;
+
+    var isBuffer$1 = isBuffer;
+
+    /** Used as references for various `Number` constants. */
+    var MAX_SAFE_INTEGER$1 = 9007199254740991;
+
+    /** Used to detect unsigned integer values. */
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+    /**
+     * Checks if `value` is a valid array-like index.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+     */
+    function isIndex(value, length) {
+      var type = typeof value;
+      length = length == null ? MAX_SAFE_INTEGER$1 : length;
+
+      return !!length &&
+        (type == 'number' ||
+          (type != 'symbol' && reIsUint.test(value))) &&
+            (value > -1 && value % 1 == 0 && value < length);
+    }
 
-      this._ratioX = width / renderWidth;
-      this._ratioY = height / renderHeight;
+    /** Used as references for various `Number` constants. */
+    var MAX_SAFE_INTEGER = 9007199254740991;
+
+    /**
+     * Checks if `value` is a valid array-like length.
+     *
+     * **Note:** This method is loosely based on
+     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+     * @example
+     *
+     * _.isLength(3);
+     * // => true
+     *
+     * _.isLength(Number.MIN_VALUE);
+     * // => false
+     *
+     * _.isLength(Infinity);
+     * // => false
+     *
+     * _.isLength('3');
+     * // => false
+     */
+    function isLength(value) {
+      return typeof value == 'number' &&
+        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
 
-      if (width || height) {
-        this.initDiv();
-        return true;
-      } else {
-        return false;
-      }
-    };
+    /** `Object#toString` result references. */
+    var argsTag$1 = '[object Arguments]',
+        arrayTag$1 = '[object Array]',
+        boolTag = '[object Boolean]',
+        dateTag = '[object Date]',
+        errorTag = '[object Error]',
+        funcTag = '[object Function]',
+        mapTag$1 = '[object Map]',
+        numberTag = '[object Number]',
+        objectTag$2 = '[object Object]',
+        regexpTag = '[object RegExp]',
+        setTag$1 = '[object Set]',
+        stringTag = '[object String]',
+        weakMapTag$1 = '[object WeakMap]';
+
+    var arrayBufferTag = '[object ArrayBuffer]',
+        dataViewTag$1 = '[object DataView]',
+        float32Tag = '[object Float32Array]',
+        float64Tag = '[object Float64Array]',
+        int8Tag = '[object Int8Array]',
+        int16Tag = '[object Int16Array]',
+        int32Tag = '[object Int32Array]',
+        uint8Tag = '[object Uint8Array]',
+        uint8ClampedTag = '[object Uint8ClampedArray]',
+        uint16Tag = '[object Uint16Array]',
+        uint32Tag = '[object Uint32Array]';
+
+    /** Used to identify `toStringTag` values of typed arrays. */
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+    typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+    typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+    typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+    typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] =
+    typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+    typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag] =
+    typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+    typedArrayTags[mapTag$1] = typedArrayTags[numberTag] =
+    typedArrayTags[objectTag$2] = typedArrayTags[regexpTag] =
+    typedArrayTags[setTag$1] = typedArrayTags[stringTag] =
+    typedArrayTags[weakMapTag$1] = false;
+
+    /**
+     * The base implementation of `_.isTypedArray` without Node.js optimizations.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+     */
+    function baseIsTypedArray(value) {
+      return isObjectLike(value) &&
+        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+    }
 
-    A11ySystem.prototype.getRenderRect = function () {
-      var _a = this.game.getSystem(pluginRenderer.RendererSystem).params,
-          params = _a === void 0 ? {
-        width: 300,
-        height: 300
-      } : _a;
-      var renderHeight = params.height,
-          renderWidth = params.width;
-      return {
-        renderWidth: renderWidth,
-        renderHeight: renderHeight
+    /**
+     * The base implementation of `_.unary` without support for storing metadata.
+     *
+     * @private
+     * @param {Function} func The function to cap arguments for.
+     * @returns {Function} Returns the new capped function.
+     */
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
       };
-    };
+    }
 
-    A11ySystem.prototype.getCanvasBoundingClientRect = function () {
-      var _a = this.game.canvas.getBoundingClientRect(),
-          width = _a.width,
-          height = _a.height,
-          left = _a.left,
-          top = _a.top;
-
-      return {
-        width: width,
-        height: height,
-        left: left,
-        top: top
-      };
-    };
+    /** Detect free variable `exports`. */
+    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+    /** Detect free variable `module`. */
+    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+    /** Detect the popular CommonJS extension `module.exports`. */
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+
+    /** Detect free variable `process` from Node.js. */
+    var freeProcess = moduleExports && freeGlobal$1.process;
+
+    /** Used to access faster Node.js helpers. */
+    var nodeUtil = (function() {
+      try {
+        // Use `util.types` for Node.js 10+.
+        var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+        if (types) {
+          return types;
+        }
+
+        // Legacy `process.binding('util')` for Node.js < 10.
+        return freeProcess && freeProcess.binding && freeProcess.binding('util');
+      } catch (e) {}
+    }());
+
+    var nodeUtil$1 = nodeUtil;
+
+    /* Node.js helper references. */
+    var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray;
+
+    /**
+     * Checks if `value` is classified as a typed array.
+     *
+     * @static
+     * @memberOf _
+     * @since 3.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+     * @example
+     *
+     * _.isTypedArray(new Uint8Array);
+     * // => true
+     *
+     * _.isTypedArray([]);
+     * // => false
+     */
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+    var isTypedArray$1 = isTypedArray;
+
+    /** Used for built-in method references. */
+    var objectProto$4 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+
+    /**
+     * Creates an array of the enumerable property names of the array-like `value`.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @param {boolean} inherited Specify returning inherited property names.
+     * @returns {Array} Returns the array of property names.
+     */
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray$1(value),
+          isArg = !isArr && isArguments$1(value),
+          isBuff = !isArr && !isArg && isBuffer$1(value),
+          isType = !isArr && !isArg && !isBuff && isTypedArray$1(value),
+          skipIndexes = isArr || isArg || isBuff || isType,
+          result = skipIndexes ? baseTimes(value.length, String) : [],
+          length = result.length;
+
+      for (var key in value) {
+        if ((inherited || hasOwnProperty$3.call(value, key)) &&
+            !(skipIndexes && (
+               // Safari 9 has enumerable `arguments.length` in strict mode.
+               key == 'length' ||
+               // Node.js 0.10 has enumerable non-index properties on buffers.
+               (isBuff && (key == 'offset' || key == 'parent')) ||
+               // PhantomJS 2 has enumerable non-index properties on typed arrays.
+               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+               // Skip index properties.
+               isIndex(key, length)
+            ))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+
+    /** Used for built-in method references. */
+    var objectProto$3 = Object.prototype;
+
+    /**
+     * Checks if `value` is likely a prototype object.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+     */
+    function isPrototype(value) {
+      var Ctor = value && value.constructor,
+          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$3;
+
+      return value === proto;
+    }
 
-    A11ySystem.prototype.initDiv = function () {
-      var _this = this;
-
-      var pageXOffset = window.pageXOffset,
-          pageYOffset = window.pageYOffset;
-
-      var _a = this.getCanvasBoundingClientRect(),
-          width = _a.width,
-          height = _a.height,
-          left = _a.left,
-          top = _a.top;
-
-      var style = {
-        width: width,
-        height: height,
-        left: left + pageXOffset + "px",
-        top: top + pageYOffset + "px",
-        position: POSITION,
-        zIndex: this.zIndex,
-        pointerEvents: PointerEvents.NONE,
-        background: MaskBackground.NONE
+    /**
+     * Creates a unary function that invokes `func` with its argument transformed.
+     *
+     * @private
+     * @param {Function} func The function to wrap.
+     * @param {Function} transform The argument transform.
+     * @returns {Function} Returns the new function.
+     */
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
       };
-      setStyle(this.div, style);
-      this.div.addEventListener('click', function (e) {
-        var currentTarget = e.currentTarget;
-
-        var _a = currentTarget.getBoundingClientRect(),
-            left = _a.left,
-            top = _a.top;
-
-        var x = (e.pageX - left) / _this.ratioX;
-        var y = (e.pageY - top) / _this.ratioY;
-        _this.eventPosition = {
-          x: x,
-          y: y
-        };
-      }, true);
-    };
+    }
 
-    A11ySystem.prototype.update = function () {
-      return __awaiter(this, void 0, void 0, function () {
-        var changes, changes_1, changes_1_1, changed;
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeKeys = overArg(Object.keys, Object);
 
-        var e_1, _a;
+    var nativeKeys$1 = nativeKeys;
 
-        return __generator(this, function (_b) {
-          changes = this.componentObserver.clear();
+    /** Used for built-in method references. */
+    var objectProto$2 = Object.prototype;
 
-          if (!this.activate) {
-            return [2];
-          }
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
 
-          try {
-            for (changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
-              changed = changes_1_1.value;
+    /**
+     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     */
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys$1(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty$2.call(object, key) && key != 'constructor') {
+          result.push(key);
+        }
+      }
+      return result;
+    }
 
-              switch (changed.type) {
-                case eva_js.OBSERVER_TYPE.ADD:
-                  changed.componentName === 'Event' && this.addEvent(changed.gameObject);
-                  changed.componentName === 'A11y' && this.add(changed);
-                  break;
+    /**
+     * Checks if `value` is array-like. A value is considered array-like if it's
+     * not a function and has a `value.length` that's an integer greater than or
+     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+     * @example
+     *
+     * _.isArrayLike([1, 2, 3]);
+     * // => true
+     *
+     * _.isArrayLike(document.body.children);
+     * // => true
+     *
+     * _.isArrayLike('abc');
+     * // => true
+     *
+     * _.isArrayLike(_.noop);
+     * // => false
+     */
+    function isArrayLike(value) {
+      return value != null && isLength(value.length) && !isFunction(value);
+    }
 
-                case eva_js.OBSERVER_TYPE.CHANGE:
-                  changed.componentName === 'Transform' && this.transformChange(changed);
-                  changed.componentName === 'A11y' && this.change(changed);
-                  break;
+    /**
+     * Creates an array of the own enumerable property names of `object`.
+     *
+     * **Note:** Non-object values are coerced to objects. See the
+     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+     * for more details.
+     *
+     * @static
+     * @since 0.1.0
+     * @memberOf _
+     * @category Object
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     * @example
+     *
+     * function Foo() {
+     *   this.a = 1;
+     *   this.b = 2;
+     * }
+     *
+     * Foo.prototype.c = 3;
+     *
+     * _.keys(new Foo);
+     * // => ['a', 'b'] (iteration order is not guaranteed)
+     *
+     * _.keys('hi');
+     * // => ['0', '1']
+     */
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
 
-                case eva_js.OBSERVER_TYPE.REMOVE:
-                  changed.componentName === 'Event' && this.removeEvent(changed);
-                  changed.componentName === 'A11y' && this.remove(changed);
-              }
-            }
-          } catch (e_1_1) {
-            e_1 = {
-              error: e_1_1
-            };
-          } finally {
-            try {
-              if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
-            } finally {
-              if (e_1) throw e_1.error;
-            }
+    /**
+     * Creates an array of own enumerable property names and symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names and symbols.
+     */
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols$1);
+    }
+
+    /** Used to compose bitmasks for value comparisons. */
+    var COMPARE_PARTIAL_FLAG$1 = 1;
+
+    /** Used for built-in method references. */
+    var objectProto$1 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+    /**
+     * A specialized version of `baseIsEqualDeep` for objects with support for
+     * partial deep comparisons.
+     *
+     * @private
+     * @param {Object} object The object to compare.
+     * @param {Object} other The other object to compare.
+     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+     * @param {Function} customizer The function to customize comparisons.
+     * @param {Function} equalFunc The function to determine equivalents of values.
+     * @param {Object} stack Tracks traversed `object` and `other` objects.
+     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+     */
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1,
+          objProps = getAllKeys(object),
+          objLength = objProps.length,
+          othProps = getAllKeys(other),
+          othLength = othProps.length;
+
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+          return false;
+        }
+      }
+      // Check that cyclic values are equal.
+      var objStacked = stack.get(object);
+      var othStacked = stack.get(other);
+      if (objStacked && othStacked) {
+        return objStacked == other && othStacked == object;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key],
+            othValue = other[key];
+
+        if (customizer) {
+          var compared = isPartial
+            ? customizer(othValue, objValue, key, other, object, stack)
+            : customizer(objValue, othValue, key, object, other, stack);
+        }
+        // Recursively compare objects (susceptible to call stack limits).
+        if (!(compared === undefined
+              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+              : compared
+            )) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == 'constructor');
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor,
+            othCtor = other.constructor;
+
+        // Non `Object` object instances with different constructors are not equal.
+        if (objCtor != othCtor &&
+            ('constructor' in object && 'constructor' in other) &&
+            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+              typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack['delete'](object);
+      stack['delete'](other);
+      return result;
+    }
+
+    /* Built-in method references that are verified to be native. */
+    var DataView = getNative(root$1, 'DataView');
+
+    var DataView$1 = DataView;
+
+    /* Built-in method references that are verified to be native. */
+    var Promise$1 = getNative(root$1, 'Promise');
+
+    var Promise$2 = Promise$1;
+
+    /* Built-in method references that are verified to be native. */
+    var Set = getNative(root$1, 'Set');
+
+    var Set$1 = Set;
+
+    /* Built-in method references that are verified to be native. */
+    var WeakMap = getNative(root$1, 'WeakMap');
+
+    var WeakMap$1 = WeakMap;
+
+    /** `Object#toString` result references. */
+    var mapTag = '[object Map]',
+        objectTag$1 = '[object Object]',
+        promiseTag = '[object Promise]',
+        setTag = '[object Set]',
+        weakMapTag = '[object WeakMap]';
+
+    var dataViewTag = '[object DataView]';
+
+    /** Used to detect maps, sets, and weakmaps. */
+    var dataViewCtorString = toSource(DataView$1),
+        mapCtorString = toSource(Map$2),
+        promiseCtorString = toSource(Promise$2),
+        setCtorString = toSource(Set$1),
+        weakMapCtorString = toSource(WeakMap$1);
+
+    /**
+     * Gets the `toStringTag` of `value`.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @returns {string} Returns the `toStringTag`.
+     */
+    var getTag = baseGetTag;
+
+    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+    if ((DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag) ||
+        (Map$2 && getTag(new Map$2) != mapTag) ||
+        (Promise$2 && getTag(Promise$2.resolve()) != promiseTag) ||
+        (Set$1 && getTag(new Set$1) != setTag) ||
+        (WeakMap$1 && getTag(new WeakMap$1) != weakMapTag)) {
+      getTag = function(value) {
+        var result = baseGetTag(value),
+            Ctor = result == objectTag$1 ? value.constructor : undefined,
+            ctorString = Ctor ? toSource(Ctor) : '';
+
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString: return dataViewTag;
+            case mapCtorString: return mapTag;
+            case promiseCtorString: return promiseTag;
+            case setCtorString: return setTag;
+            case weakMapCtorString: return weakMapTag;
           }
+        }
+        return result;
+      };
+    }
 
-          return [2];
-        });
-      });
-    };
+    var getTag$1 = getTag;
+
+    /** Used to compose bitmasks for value comparisons. */
+    var COMPARE_PARTIAL_FLAG = 1;
+
+    /** `Object#toString` result references. */
+    var argsTag = '[object Arguments]',
+        arrayTag = '[object Array]',
+        objectTag = '[object Object]';
+
+    /** Used for built-in method references. */
+    var objectProto = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty = objectProto.hasOwnProperty;
+
+    /**
+     * A specialized version of `baseIsEqual` for arrays and objects which performs
+     * deep comparisons and tracks traversed objects enabling objects with circular
+     * references to be compared.
+     *
+     * @private
+     * @param {Object} object The object to compare.
+     * @param {Object} other The other object to compare.
+     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+     * @param {Function} customizer The function to customize comparisons.
+     * @param {Function} equalFunc The function to determine equivalents of values.
+     * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+     */
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray$1(object),
+          othIsArr = isArray$1(other),
+          objTag = objIsArr ? arrayTag : getTag$1(object),
+          othTag = othIsArr ? arrayTag : getTag$1(other);
+
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+
+      var objIsObj = objTag == objectTag,
+          othIsObj = othTag == objectTag,
+          isSameTag = objTag == othTag;
+
+      if (isSameTag && isBuffer$1(object)) {
+        if (!isBuffer$1(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack);
+        return (objIsArr || isTypedArray$1(object))
+          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
 
-    A11ySystem.prototype.change = function (changed) {
-      var component = changed.component;
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object,
+              othUnwrapped = othIsWrapped ? other.value() : other;
 
-      if (changed.prop.prop[0] === 'hint') {
-        var dom = this.cache.get(component.a11yId);
-        dom === null || dom === void 0 ? void 0 : dom.setAttribute('aria-label', component.hint);
-        dom && this.setPosition(dom, changed.gameObject.transform);
+          stack || (stack = new Stack);
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
       }
-    };
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack);
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
 
-    A11ySystem.prototype.remove = function (changed) {
-      var component = changed.component;
-      if (!component) return;
-      var a11yId = component.a11yId;
-      var element = this.div.querySelector("#" + a11yId);
-      element && this.div.removeChild(element);
-      this.cache.delete(a11yId);
-    };
+    /**
+     * The base implementation of `_.isEqual` which supports partial comparisons
+     * and tracks traversed objects.
+     *
+     * @private
+     * @param {*} value The value to compare.
+     * @param {*} other The other value to compare.
+     * @param {boolean} bitmask The bitmask flags.
+     *  1 - Unordered comparison
+     *  2 - Partial comparison
+     * @param {Function} [customizer] The function to customize comparisons.
+     * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+     */
+    function baseIsEqual(value, other, bitmask, customizer, stack) {
+      if (value === other) {
+        return true;
+      }
+      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+        return value !== value && other !== other;
+      }
+      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+    }
+
+    /**
+     * Performs a deep comparison between two values to determine if they are
+     * equivalent.
+     *
+     * **Note:** This method supports comparing arrays, array buffers, booleans,
+     * date objects, error objects, maps, numbers, `Object` objects, regexes,
+     * sets, strings, symbols, and typed arrays. `Object` objects are compared
+     * by their own, not inherited, enumerable properties. Functions and DOM
+     * nodes are compared by strict equality, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to compare.
+     * @param {*} other The other value to compare.
+     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+     * @example
+     *
+     * var object = { 'a': 1 };
+     * var other = { 'a': 1 };
+     *
+     * _.isEqual(object, other);
+     * // => true
+     *
+     * object === other;
+     * // => false
+     */
+    function isEqual(value, other) {
+      return baseIsEqual(value, other);
+    }
+
+    function createCommonjsModule(fn) {
+      var module = { exports: {} };
+    	return fn(module, module.exports), module.exports;
+    }
 
-    A11ySystem.prototype.add = function (changed) {
-      var _this = this;
+    var eventemitter3 = createCommonjsModule(function (module) {
+
+    var has = Object.prototype.hasOwnProperty
+      , prefix = '~';
+
+    /**
+     * Constructor to create a storage for our `EE` objects.
+     * An `Events` instance is a plain object whose properties are event names.
+     *
+     * @constructor
+     * @private
+     */
+    function Events() {}
+
+    //
+    // We try to not inherit from `Object.prototype`. In some engines creating an
+    // instance in this way is faster than calling `Object.create(null)` directly.
+    // If `Object.create(null)` is not supported we prefix the event names with a
+    // character to make sure that the built-in object properties are not
+    // overridden or used as an attack vector.
+    //
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+
+      //
+      // This hack is needed because the `__proto__` property is still inherited in
+      // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+      //
+      if (!new Events().__proto__) prefix = false;
+    }
 
-      if (!this.activate) return;
-      var component = changed.component;
-      var gameObject = changed.gameObject;
-      var delay = component.delay,
-          id = component.a11yId;
-      var event = component.event;
-      if (!gameObject) return;
-      var transform = gameObject.transform;
-      if (!transform) return;
-      var element = document.createElement('div');
-      this.cache.set(id, element);
+    /**
+     * Representation of a single event listener.
+     *
+     * @param {Function} fn The listener function.
+     * @param {*} context The context to invoke the listener with.
+     * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+     * @constructor
+     * @private
+     */
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
 
-      if (!event) {
-        event = gameObject.getComponent('Event');
+    /**
+     * Add a listener for a given event.
+     *
+     * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} context The context to invoke the listener with.
+     * @param {Boolean} once Specify if the listener is a one-time listener.
+     * @returns {EventEmitter}
+     * @private
+     */
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== 'function') {
+        throw new TypeError('The listener must be a function');
       }
 
-      setTimeout(function () {
-        _this.setPosition(element, transform);
+      var listener = new EE(fn, context || emitter, once)
+        , evt = prefix ? prefix + event : event;
 
-        _this.setA11yAttr(element, component);
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
 
-        if (event) {
-          _this.addEvent(gameObject);
-        }
+      return emitter;
+    }
 
-        if (gameObject.scene) {
-          _this.div.appendChild(element);
-        }
-      }, delay || this.delay);
-    };
+    /**
+     * Clear event by name.
+     *
+     * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+     * @param {(String|Symbol)} evt The Event name.
+     * @private
+     */
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
 
-    A11ySystem.prototype.transformChange = function (changed) {
-      var component = changed.component;
-      var gameObject = changed.gameObject;
-      var a11yComponent = gameObject.getComponent(A11y$1);
-      if (!a11yComponent) return;
-      var a11yId = a11yComponent.a11yId;
+    /**
+     * Minimal `EventEmitter` interface that is molded against the Node.js
+     * `EventEmitter` interface.
+     *
+     * @constructor
+     * @public
+     */
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
 
-      if (!component.inScene) {
-        var dom = this.div.querySelector("#" + a11yId);
-        dom && this.div.removeChild(dom);
-      } else {
-        if (this.cache.has(a11yId)) {
-          var addDom = this.cache.get(a11yId);
-          addDom && this.div.appendChild(addDom);
-        }
+    /**
+     * Return an array listing the events for which the emitter has registered
+     * listeners.
+     *
+     * @returns {Array}
+     * @public
+     */
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = []
+        , events
+        , name;
+
+      if (this._eventsCount === 0) return names;
+
+      for (name in (events = this._events)) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
       }
-    };
 
-    A11ySystem.prototype.setEvent = function (element, event, gameObject, id) {
-      if (!event) {
-        return;
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
       }
 
-      var func = getEventFunc.bind(this, event, gameObject);
-      this.eventCache.set(id, func);
-      element.addEventListener('click', func);
+      return names;
     };
 
-    A11ySystem.prototype.addEvent = function (gameObject) {
-      var a11y = gameObject.getComponent(A11y$1);
-      if (!a11y) return;
-      var event = gameObject.getComponent('Event');
-      if (!event) return;
-      var element = this.cache.get(a11y.a11yId);
-      element && this.setEvent(element, event, gameObject, a11y.a11yId);
+    /**
+     * Return the listeners registered for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Array} The registered listeners.
+     * @public
+     */
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event
+        , handlers = this._events[evt];
+
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+
+      return ee;
     };
 
-    A11ySystem.prototype.removeEvent = function (changed) {
-      var gameObject = changed.gameObject;
-      var a11y = gameObject.getComponent(A11y$1);
-      if (!a11y) return;
-      var event = changed.component;
-      if (!event) return;
-      var a11yId = a11y.a11yId;
-      var func = this.eventCache.get(a11yId);
-      var element = this.cache.get(a11yId);
-      element && element.removeEventListener('click', func);
+    /**
+     * Return the number of listeners listening to a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Number} The number of listeners.
+     * @public
+     */
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event
+        , listeners = this._events[evt];
+
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
     };
 
-    A11ySystem.prototype.setA11yAttr = function (element, component) {
-      var e_2, _a, e_3, _b, e_4, _c;
-
-      var hint = component.hint,
-          _d = component.props,
-          props = _d === void 0 ? {} : _d,
-          _e = component.state,
-          state = _e === void 0 ? {} : _e,
-          role = component.role,
-          id = component.a11yId;
-      var realRole = role || 'text';
-      element.setAttribute('role', realRole);
-      element.setAttribute('aria-label', hint);
-      element.id = id;
-      var ariaProps = Object.keys(props);
+    /**
+     * Calls each of the listeners registered for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Boolean} `true` if the event had listeners, else `false`.
+     * @public
+     */
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+
+      if (!this._events[evt]) return false;
+
+      var listeners = this._events[evt]
+        , len = arguments.length
+        , args
+        , i;
+
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+        switch (len) {
+          case 1: return listeners.fn.call(listeners.context), true;
+          case 2: return listeners.fn.call(listeners.context, a1), true;
+          case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
 
-      try {
-        for (var ariaProps_1 = __values(ariaProps), ariaProps_1_1 = ariaProps_1.next(); !ariaProps_1_1.done; ariaProps_1_1 = ariaProps_1.next()) {
-          var key = ariaProps_1_1.value;
-          element.setAttribute(key, props[key]);
+        for (i = 1, args = new Array(len -1); i < len; i++) {
+          args[i - 1] = arguments[i];
         }
-      } catch (e_2_1) {
-        e_2 = {
-          error: e_2_1
-        };
-      } finally {
-        try {
-          if (ariaProps_1_1 && !ariaProps_1_1.done && (_a = ariaProps_1.return)) _a.call(ariaProps_1);
-        } finally {
-          if (e_2) throw e_2.error;
+
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length
+          , j;
+
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+          switch (len) {
+            case 1: listeners[i].fn.call(listeners[i].context); break;
+            case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+            case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+            case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+            default:
+              if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
         }
       }
 
-      var ariaState = Object.keys(state);
+      return true;
+    };
 
-      try {
-        for (var ariaState_1 = __values(ariaState), ariaState_1_1 = ariaState_1.next(); !ariaState_1_1.done; ariaState_1_1 = ariaState_1.next()) {
-          var key = ariaState_1_1.value;
-          element.setAttribute(key, state[key]);
-        }
-      } catch (e_3_1) {
-        e_3 = {
-          error: e_3_1
-        };
-      } finally {
-        try {
-          if (ariaState_1_1 && !ariaState_1_1.done && (_b = ariaState_1.return)) _b.call(ariaState_1);
-        } finally {
-          if (e_3) throw e_3.error;
-        }
+    /**
+     * Add a listener for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+
+    /**
+     * Add a one-time listener for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+
+    /**
+     * Remove the listeners of a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn Only remove the listeners that match this function.
+     * @param {*} context Only remove the listeners that have this context.
+     * @param {Boolean} once Only remove one-time listeners.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
       }
 
-      try {
-        for (var _f = __values(Object.keys(component)), _g = _f.next(); !_g.done; _g = _f.next()) {
-          var key = _g.value;
+      var listeners = this._events[evt];
 
-          if (typeof component[key] === 'string' && notAttr.indexOf(key) === -1 && key.indexOf('_') !== 1) {
-            element.setAttribute(key, component[key]);
-          }
+      if (listeners.fn) {
+        if (
+          listeners.fn === fn &&
+          (!once || listeners.once) &&
+          (!context || listeners.context === context)
+        ) {
+          clearEvent(this, evt);
         }
-      } catch (e_4_1) {
-        e_4 = {
-          error: e_4_1
-        };
-      } finally {
-        try {
-          if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
-        } finally {
-          if (e_4) throw e_4.error;
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (
+            listeners[i].fn !== fn ||
+            (once && !listeners[i].once) ||
+            (context && listeners[i].context !== context)
+          ) {
+            events.push(listeners[i]);
+          }
         }
+
+        //
+        // Reset the array, or remove it completely if we have no more listeners.
+        //
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
       }
-    };
 
-    A11ySystem.prototype.setPosition = function (element, transform) {
-      var _a = transform.size,
-          width = _a.width,
-          height = _a.height;
-      var style = {
-        width: width === 0 ? 1 : width * this.ratioX,
-        height: height === 0 ? 1 : height * this.ratioY,
-        position: POSITION,
-        zIndex: this.zIndex,
-        pointerEvents: PointerEvents.AUTO,
-        background: this.debug ? MaskBackground.DEBUG : MaskBackground.NONE
-      };
+      return this;
+    };
 
-      var transformProps = _assign({}, transform);
+    /**
+     * Remove all listeners, or those of the specified event.
+     *
+     * @param {(String|Symbol)} [event] The event name.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
 
-      setStyle(element, style);
-      setTransform(element, transformProps, this.ratioX, this.ratioY);
+      return this;
     };
 
-    A11ySystem.prototype.onDestroy = function () {
-      this.div.parentElement.removeChild(this.div);
-      this.cache = null;
-      this.eventCache = null;
-      this.div = null;
+    //
+    // Alias methods names because people roll like that.
+    //
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+    //
+    // Expose the prefix.
+    //
+    EventEmitter.prefixed = prefix;
+
+    //
+    // Allow `EventEmitter` to be imported as module namespace.
+    //
+    EventEmitter.EventEmitter = EventEmitter;
+
+    //
+    // Expose the module.
+    //
+    {
+      module.exports = EventEmitter;
+    }
+    });
+
+    var EventEmitter = eventemitter3;
+
+    /*! *****************************************************************************
+    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 __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    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 __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;
+    }
+
+    var RendererManager = (function () {
+        function RendererManager(_a) {
+            var game = _a.game, rendererSystem = _a.rendererSystem;
+            this.renderers = [];
+            this.game = game;
+            this.rendererSystem = rendererSystem;
+        }
+        RendererManager.prototype.register = function () {
+            var e_1, _a;
+            var renderers = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                renderers[_i] = arguments[_i];
+            }
+            try {
+                for (var renderers_1 = __values(renderers), renderers_1_1 = renderers_1.next(); !renderers_1_1.done; renderers_1_1 = renderers_1.next()) {
+                    var renderer = renderers_1_1.value;
+                    renderer.game = this.game;
+                    renderer.rendererManager = this.rendererSystem.rendererManager;
+                    renderer.containerManager = this.rendererSystem.containerManager;
+                    this.renderers.push(renderer);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (renderers_1_1 && !renderers_1_1.done && (_a = renderers_1.return)) _a.call(renderers_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        RendererManager.prototype.componentChanged = function (changes) {
+            var e_2, _a;
+            var _loop_1 = function (changed) {
+                var e_3, _a;
+                try {
+                    for (var _b = (e_3 = void 0, __values(this_1.renderers)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var renderer = _c.value;
+                        var props = renderer.observerInfo[changed.componentName];
+                        if (props) {
+                            if ([eva_js.OBSERVER_TYPE.ADD, eva_js.OBSERVER_TYPE.REMOVE].indexOf(changed.type) > -1) {
+                                try {
+                                    renderer.componentChanged && renderer.componentChanged(changed);
+                                }
+                                catch (e) {
+                                    console.error("gameObject: " + changed.gameObject.name + ", " + changed.componentName + " is error.", changed, e);
+                                }
+                                continue;
+                            }
+                            var index = props.findIndex(function (prop) {
+                                return isEqual(prop, changed.prop);
+                            });
+                            if (index > -1) {
+                                try {
+                                    renderer.componentChanged && renderer.componentChanged(changed);
+                                }
+                                catch (e) {
+                                    console.error("gameObject: " + (changed.gameObject && changed.gameObject.name) + ", " + changed.componentName + " is componentChanged error.", changed, e);
+                                }
+                            }
+                        }
+                    }
+                }
+                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; }
+                }
+            };
+            var this_1 = this;
+            try {
+                for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                    var changed = changes_1_1.value;
+                    _loop_1(changed);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        RendererManager.prototype.update = function (gameObject) {
+            var e_4, _a, e_5, _b;
+            try {
+                for (var _c = __values(gameObject.components), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var component = _d.value;
+                    try {
+                        for (var _e = (e_5 = void 0, __values(this.renderers)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var renderer = _f.value;
+                            var cache = [];
+                            var props = renderer.observerInfo[component.name];
+                            if (props && cache.indexOf(gameObject) === -1) {
+                                cache.push(gameObject);
+                                try {
+                                    renderer.rendererUpdate && renderer.rendererUpdate(gameObject);
+                                }
+                                catch (e) {
+                                    console.info("gameObject: " + gameObject.name + ", " + component.name + " is update error", e);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        };
+        return RendererManager;
+    }());
+    var RendererManager$1 = RendererManager;
+
+    var ContainerManager = (function () {
+        function ContainerManager() {
+            this.containerMap = {};
+        }
+        ContainerManager.prototype.addContainer = function (_a) {
+            var name = _a.name, container = _a.container;
+            this.containerMap[name] = container;
+        };
+        ContainerManager.prototype.getContainer = function (name) {
+            return this.containerMap[name];
+        };
+        ContainerManager.prototype.removeContainer = function (name) {
+            var _a;
+            (_a = this.containerMap[name]) === null || _a === void 0 ? void 0 : _a.destroy({ children: true });
+            delete this.containerMap[name];
+        };
+        ContainerManager.prototype.updateTransform = function (_a) {
+            var name = _a.name, transform = _a.transform;
+            var container = this.containerMap[name];
+            if (!container)
+                return;
+            var anchor = transform.anchor, origin = transform.origin, position = transform.position, rotation = transform.rotation, scale = transform.scale, size = transform.size, skew = transform.skew;
+            container.rotation = rotation;
+            container.scale = scale;
+            container.pivot.x = size.width * origin.x;
+            container.pivot.y = size.height * origin.y;
+            container.skew = skew;
+            var x = position.x;
+            var y = position.y;
+            if (transform.parent) {
+                var parent_1 = transform.parent;
+                x = x + parent_1.size.width * anchor.x;
+                y = y + parent_1.size.height * anchor.y;
+            }
+            container.position = { x: x, y: y };
+        };
+        return ContainerManager;
+    }());
+    var ContainerManager$1 = ContainerManager;
+
+    var Transform = (function (_super) {
+        __extends(Transform, _super);
+        function Transform(_a) {
+            var system = _a.system, containerManager = _a.containerManager;
+            var _this = _super.call(this) || this;
+            _this.name = 'Transform';
+            _this.waitRemoveIds = [];
+            _this.waitChangeScenes = [];
+            _this.containerManager = containerManager;
+            _this.init(system);
+            return _this;
+        }
+        Transform.prototype.init = function (system) {
+            var _this = this;
+            this.system = system;
+            this.on('changeScene', function (_a) {
+                var scene = _a.scene, mode = _a.mode, application = _a.application;
+                _this.waitChangeScenes.push({ scene: scene, mode: mode, application: application });
+            });
+        };
+        Transform.prototype.update = function () {
+            var e_1, _a, e_2, _b;
+            try {
+                for (var _c = __values(this.waitRemoveIds), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var id = _d.value;
+                    this.containerManager.removeContainer(id);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            this.waitRemoveIds = [];
+            try {
+                for (var _e = __values(this.waitChangeScenes), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var sceneInfo = _f.value;
+                    var container = this.containerManager.getContainer(sceneInfo.scene.id);
+                    if (container) {
+                        sceneInfo.application.stage.removeChildren();
+                        sceneInfo.application.stage.addChild(container);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            this.waitChangeScenes = [];
+        };
+        Transform.prototype.componentChanged = function (changed) {
+            if (changed.type === eva_js.OBSERVER_TYPE.ADD) {
+                this.addContainer(changed);
+            }
+            else if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
+                this.change(changed);
+            }
+            else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
+                this.waitRemoveIds.push(changed.gameObject.id);
+            }
+        };
+        Transform.prototype.addContainer = function (changed) {
+            var container = new Container$1();
+            container.name = changed.gameObject.name;
+            this.containerManager.addContainer({
+                name: changed.gameObject.id,
+                container: container,
+            });
+            var transform = changed.component;
+            transform.worldTransform = container.transform.worldTransform;
+        };
+        Transform.prototype.change = function (changed) {
+            var transform = changed.component;
+            if (transform.parent) {
+                var parentContainer = this.containerManager.getContainer(transform.parent.gameObject.id);
+                parentContainer.addChild(this.containerManager.getContainer(changed.gameObject.id));
+                var render = changed.gameObject.transform.parent &&
+                    changed.gameObject.transform.parent.gameObject.getComponent('Render');
+                if (render) {
+                    render.sortDirty = true;
+                }
+            }
+            else {
+                var container = this.containerManager.getContainer(changed.gameObject.id);
+                delete transform.worldTransform;
+                container.parent && container.parent.removeChild(container);
+            }
+        };
+        Transform.prototype.destroy = function () {
+            this.removeAllListeners();
+            this.waitRemoveIds = null;
+            this.waitChangeScenes = null;
+            this.system = null;
+            this.containerManager = null;
+        };
+        Transform = __decorate([
+            eva_js.decorators.componentObserver({
+                Transform: ['_parent'],
+            })
+        ], Transform);
+        return Transform;
+    }(EventEmitter));
+    var Transform$1 = Transform;
+
+    var RENDERER_TYPE;
+    (function (RENDERER_TYPE) {
+        RENDERER_TYPE[RENDERER_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
+        RENDERER_TYPE[RENDERER_TYPE["WEBGL"] = 1] = "WEBGL";
+        RENDERER_TYPE[RENDERER_TYPE["CANVAS"] = 2] = "CANVAS";
+    })(RENDERER_TYPE || (RENDERER_TYPE = {}));
+    var disableScroll = function (renderer) {
+        renderer.plugins.interaction.autoPreventDefault = true;
+        renderer.view.style.touchAction = 'none';
+    };
+    var enableScroll = function (renderer) {
+        renderer.plugins.interaction.autoPreventDefault = false;
+        renderer.view.style.touchAction = 'auto';
+    };
+    var Renderer$2 = (function (_super) {
+        __extends(Renderer, _super);
+        function Renderer() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.multiApps = [];
+            return _this;
+        }
+        Renderer.prototype.init = function (params) {
+            var _this = this;
+            this.params = params;
+            this.application = this.createApplication(params);
+            this.containerManager = new ContainerManager$1();
+            this.rendererManager = new RendererManager$1({
+                game: this.game,
+                rendererSystem: this,
+            });
+            this.game.canvas = this.application.view;
+            this.transform = new Transform$1({
+                system: this,
+                containerManager: this.containerManager,
+            });
+            this.game.on('sceneChanged', function (_a) {
+                var scene = _a.scene, mode = _a.mode, params = _a.params;
+                var application;
+                switch (mode) {
+                    case eva_js.LOAD_SCENE_MODE.SINGLE:
+                        application = _this.application;
+                        break;
+                    case eva_js.LOAD_SCENE_MODE.MULTI_CANVAS:
+                        application = _this.createMultiApplication({ params: params });
+                        break;
+                }
+                scene.canvas = application.view;
+                _this.transform.emit('changeScene', {
+                    scene: scene,
+                    mode: mode,
+                    application: application,
+                });
+            });
+        };
+        Renderer.prototype.registerObserver = function (observerInfo) {
+            var _a;
+            var thisObserverInfo = this.constructor.observerInfo;
+            for (var key in observerInfo) {
+                if (!thisObserverInfo[key]) {
+                    thisObserverInfo[key] = [];
+                }
+                (_a = thisObserverInfo[key]).push.apply(_a, __spread(observerInfo[key]));
+            }
+        };
+        Renderer.prototype.createMultiApplication = function (_a) {
+            var params = _a.params;
+            var app = this.createApplication(params);
+            this.multiApps.push(app);
+            return app;
+        };
+        Renderer.prototype.createApplication = function (params) {
+            params.view = params.canvas;
+            if (params.renderType === RENDERER_TYPE.CANVAS) {
+                params.forceCanvas = true;
+            }
+            pixi_js.ticker.shared.autoStart = false;
+            pixi_js.ticker.shared.stop();
+            var app = new Application$1(__assign({ sharedTicker: true }, params));
+            if (params.preventScroll !== undefined) {
+                console.warn('PreventScroll property will deprecate at next major version, please use enableEnable instead. https://eva.js.org/#/tutorials/game');
+                params.preventScroll ? enableScroll(app.renderer) : disableScroll(app.renderer);
+            }
+            if (params.enableScroll !== undefined) {
+                params.enableScroll ? enableScroll(app.renderer) : disableScroll(app.renderer);
+            }
+            if (params.preventScroll === undefined && params.enableScroll === undefined) {
+                enableScroll(app.renderer);
+            }
+            return app;
+        };
+        Renderer.prototype.update = function () {
+            var e_1, _a, e_2, _b;
+            var changes = this.componentObserver.clear();
+            try {
+                for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                    var changed = changes_1_1.value;
+                    this.transform.componentChanged(changed);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            try {
+                for (var _c = __values(this.game.gameObjects), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var gameObject = _d.value;
+                    this.containerManager.updateTransform({
+                        name: gameObject.id,
+                        transform: gameObject.transform,
+                    });
+                    this.rendererManager.update(gameObject);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        Renderer.prototype.lateUpdate = function (e) {
+            this.transform.update();
+            this.application.ticker.update(e.time);
+        };
+        Renderer.prototype.onDestroy = function () {
+            var e_3, _a;
+            this.application.destroy();
+            try {
+                for (var _b = __values(this.multiApps), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var app = _c.value;
+                    app && app.destroy();
+                }
+            }
+            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; }
+            }
+            this.transform.destroy();
+            this.transform = null;
+            this.params = null;
+            this.rendererManager = null;
+            this.containerManager = null;
+            this.application = null;
+            this.game = null;
+            this.multiApps = null;
+        };
+        Renderer.prototype.resize = function (width, height) {
+            this.params.width = width;
+            this.params.height = height;
+            this.application.renderer.resize(width, height);
+        };
+        Renderer.systemName = 'Renderer';
+        Renderer = __decorate([
+            eva_js.decorators.componentObserver({
+                Transform: ['_parent'],
+            })
+        ], Renderer);
+        return Renderer;
+    }(eva_js.System));
+    var Renderer$3 = Renderer$2;
+
+    ((function (_super) {
+        __extends(Renderer, _super);
+        function Renderer(params) {
+            var _this = _super.call(this, params) || this;
+            _this.observerInfo = _this.constructor.observerInfo;
+            return _this;
+        }
+        Renderer.prototype.componentChanged = function (_changed) { };
+        Renderer.prototype.rendererUpdate = function (_gameObject) { };
+        Renderer.prototype.update = function () {
+            var e_1, _a;
+            var changes = this.componentObserver.clear();
+            try {
+                for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                    var changed = changes_1_1.value;
+                    this.componentChanged(changed);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        return Renderer;
+    })(eva_js.System));
+
+    function uuid(len) {
+        var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
+        var uuid = [];
+        var radix = chars.length;
+        for (var i = 0; i < len; i++)
+            uuid[i] = chars[0 | (Math.random() * radix)];
+        return uuid.join('');
+    }
+    var setStyle = function (element, style) {
+        var width = style.width, height = style.height, position = style.position, _a = style.left, left = _a === void 0 ? 0 : _a, _b = style.top, top = _b === void 0 ? 0 : _b, zIndex = style.zIndex, pointerEvents = style.pointerEvents, background = style.background;
+        element.style.width = width + "px";
+        element.style.height = height + "px";
+        element.style.position = position;
+        element.style.left = "" + left;
+        element.style.top = "" + top;
+        element.style.zIndex = "" + zIndex;
+        element.style.pointerEvents = pointerEvents;
+        element.style.background = background;
+        element.style.border = 'none';
+        element.style.overflow = 'hidden';
+    };
+    var setTransform = function (element, transform, ratioX, ratioY) {
+        var worldTransform = transform.worldTransform;
+        var a = worldTransform.a, b = worldTransform.b, c = worldTransform.c, d = worldTransform.d, tx = worldTransform.tx, ty = worldTransform.ty;
+        var matrix = "matrix(" + a + ", " + b + ", " + c + ", " + d + ", " + tx * ratioX + ", " + ty * ratioY + ")";
+        element.style.transform = "" + matrix;
+        element.style.webkitTransform = "" + matrix;
+        element.style.transformOrigin = 'left top';
+        element.style.webkitTransformOrigin = 'left top';
     };
 
-    A11ySystem.systemName = 'A11ySystem';
-    A11ySystem = __decorate([eva_js.decorators.componentObserver({
-      A11y: ['hint'],
-      Transform: ['inScene'],
-      Event: []
-    }), __metadata("design:paramtypes", [Object])], A11ySystem);
-    return A11ySystem;
-  }(eva_js.System);
-
-  var A11ySystem$1 = A11ySystem;
-  exports.A11y = A11y$1;
-  exports.A11ySystem = A11ySystem$1;
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-  return exports;
-}({}, EVA, EVA.plugin.renderer);
-
-window.EVA.plugin.a11y = window.EVA.plugin.a11y || _EVA_IIFE_a11y;
+    var A11y = (function (_super) {
+        __extends$2(A11y, _super);
+        function A11y(param) {
+            var _this = _super.call(this) || this;
+            Object.assign(_this, param);
+            var _a = param.hint, hint = _a === void 0 ? '' : _a, event = param.event, _b = param.delay, delay = _b === void 0 ? 0 : _b, _c = param.attr, attr = _c === void 0 ? {} : _c, _d = param.role, role = _d === void 0 ? '' : _d, _e = param.props, props = _e === void 0 ? {} : _e, _f = param.state, state = _f === void 0 ? {} : _f;
+            _this.hint = hint;
+            _this.event = event;
+            _this.delay = delay;
+            _this.attr = attr;
+            _this.role = role;
+            _this.props = props;
+            _this.state = state;
+            _this.a11yId = "_" + uuid(6);
+            return _this;
+        }
+        A11y.componentName = 'A11y';
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "interactive", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "hint", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "event", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "delay", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "role", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "props", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "state", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "attr", void 0);
+        __decorate$1([
+            eva_js.decorators.IDEProp
+        ], A11y.prototype, "a11yId", void 0);
+        return A11y;
+    }(eva_js.Component));
+    var A11y$1 = A11y;
+
+    var POSITION = 'absolute';
+    var ZINDEX = 3;
+    exports.A11yActivate = void 0;
+    (function (A11yActivate) {
+        A11yActivate[A11yActivate["ENABLE"] = 0] = "ENABLE";
+        A11yActivate[A11yActivate["DISABLE"] = 1] = "DISABLE";
+        A11yActivate[A11yActivate["CHECK"] = 2] = "CHECK";
+    })(exports.A11yActivate || (exports.A11yActivate = {}));
+    var PointerEvents;
+    (function (PointerEvents) {
+        PointerEvents["NONE"] = "none";
+        PointerEvents["AUTO"] = "auto";
+    })(PointerEvents || (PointerEvents = {}));
+    var MaskBackground;
+    (function (MaskBackground) {
+        MaskBackground["DEBUG"] = "rgba(255,0,0,0.5)";
+        MaskBackground["NONE"] = "transparent";
+    })(MaskBackground || (MaskBackground = {}));
+    var ElementType;
+    (function (ElementType) {
+        ElementType["BUTTON"] = "button";
+        ElementType["DIV"] = "div";
+    })(ElementType || (ElementType = {}));
+
+    var notAttr = ['hint', 'event', 'delay', 'attr', 'role', 'props', 'state', 'a11yId', 'name'];
+    var getEventFunc = function (event, gameObject, e) {
+        var _this = this;
+        ['touchstart', 'touchend', 'tap'].forEach(function (name) {
+            event.emit(name, {
+                stopPropagation: function () { return e.stopPropagation(); },
+                data: {
+                    position: _this.eventPosition,
+                },
+                gameObject: gameObject,
+            });
+        });
+    };
+    var A11ySystem = (function (_super) {
+        __extends$2(A11ySystem, _super);
+        function A11ySystem(opt) {
+            var _this = _super.call(this, opt) || this;
+            _this.cache = new Map();
+            _this.eventCache = new Map();
+            return _this;
+        }
+        Object.defineProperty(A11ySystem.prototype, "ratioX", {
+            get: function () {
+                if (this._ratioX) {
+                    return this._ratioX;
+                }
+                else {
+                    var success = this.setRatio();
+                    if (success) {
+                        return this._ratioX;
+                    }
+                    else {
+                        return 0;
+                    }
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(A11ySystem.prototype, "ratioY", {
+            get: function () {
+                if (this._ratioY) {
+                    return this._ratioY;
+                }
+                else {
+                    var success = this.setRatio();
+                    if (success) {
+                        return this._ratioY;
+                    }
+                    else {
+                        return 0;
+                    }
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        A11ySystem.prototype.init = function (opt) {
+            if (opt === void 0) { opt = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, activate, _b, delay, _c, checkA11yOpen, _d, _e, div;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            _a = opt.activate, activate = _a === void 0 ? exports.A11yActivate.CHECK : _a, _b = opt.delay, delay = _b === void 0 ? 100 : _b, _c = opt.checkA11yOpen, checkA11yOpen = _c === void 0 ? function () { return Promise.resolve(false); } : _c;
+                            this.delay = delay;
+                            _d = activate;
+                            switch (_d) {
+                                case exports.A11yActivate.CHECK: return [3, 1];
+                                case exports.A11yActivate.DISABLE: return [3, 5];
+                                case exports.A11yActivate.ENABLE: return [3, 6];
+                            }
+                            return [3, 7];
+                        case 1:
+                            _f.trys.push([1, 3, , 4]);
+                            _e = this;
+                            return [4, checkA11yOpen()];
+                        case 2:
+                            _e.activate = _f.sent();
+                            return [3, 4];
+                        case 3:
+                            _f.sent();
+                            this.activate = false;
+                            return [3, 4];
+                        case 4: return [3, 7];
+                        case 5:
+                            this.activate = false;
+                            return [3, 7];
+                        case 6:
+                            this.activate = true;
+                            return [3, 7];
+                        case 7:
+                            this.debug = opt.debug || false;
+                            if (this.debug) {
+                                this.activate = true;
+                            }
+                            if (!this.activate)
+                                return [2];
+                            div = document.createElement('div');
+                            this.div = div;
+                            if (this.game.canvas.parentNode) {
+                                this.game.canvas.parentNode.appendChild(this.div);
+                            }
+                            return [2];
+                    }
+                });
+            });
+        };
+        A11ySystem.prototype.setRatio = function () {
+            var _a = this.getCanvasBoundingClientRect(), width = _a.width, height = _a.height;
+            var _b = this.getRenderRect(), renderWidth = _b.renderWidth, renderHeight = _b.renderHeight;
+            this._ratioX = width / renderWidth;
+            this._ratioY = height / renderHeight;
+            if (width || height) {
+                this.initDiv();
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        A11ySystem.prototype.getRenderRect = function () {
+            var params = (this.game.getSystem(Renderer$3) || { width: 300, height: 300 }).params;
+            var renderHeight = params.height, renderWidth = params.width;
+            return { renderWidth: renderWidth, renderHeight: renderHeight };
+        };
+        A11ySystem.prototype.getCanvasBoundingClientRect = function () {
+            var _a = this.game.canvas.getBoundingClientRect(), width = _a.width, height = _a.height, left = _a.left, top = _a.top;
+            return { width: width, height: height, left: left, top: top };
+        };
+        A11ySystem.prototype.initDiv = function () {
+            var _this = this;
+            var pageXOffset = window.pageXOffset, pageYOffset = window.pageYOffset;
+            var _a = this.getCanvasBoundingClientRect(), width = _a.width, height = _a.height, left = _a.left, top = _a.top;
+            var style = {
+                width: width,
+                height: height,
+                left: left + pageXOffset + "px",
+                top: top + pageYOffset + "px",
+                position: POSITION,
+                zIndex: ZINDEX,
+                pointerEvents: PointerEvents.NONE,
+                background: MaskBackground.NONE,
+            };
+            setStyle(this.div, style);
+            this.div.addEventListener('click', function (e) {
+                var currentTarget = e.currentTarget;
+                var _a = currentTarget.getBoundingClientRect(), left = _a.left, top = _a.top;
+                var x = (e.pageX - left) / _this.ratioX;
+                var y = (e.pageY - top) / _this.ratioY;
+                _this.eventPosition = { x: x, y: y };
+            }, true);
+        };
+        A11ySystem.prototype.update = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var changes, changes_1, changes_1_1, changed;
+                var e_1, _a;
+                return __generator(this, function (_b) {
+                    changes = this.componentObserver.clear();
+                    if (!this.activate) {
+                        return [2];
+                    }
+                    try {
+                        for (changes_1 = __values$1(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                            changed = changes_1_1.value;
+                            switch (changed.type) {
+                                case eva_js.OBSERVER_TYPE.ADD:
+                                    changed.componentName === 'Event' && this.addEvent(changed.gameObject);
+                                    changed.componentName === 'A11y' && this.add(changed);
+                                    break;
+                                case eva_js.OBSERVER_TYPE.CHANGE:
+                                    changed.componentName === 'Transform' && this.transformChange(changed);
+                                    break;
+                                case eva_js.OBSERVER_TYPE.REMOVE:
+                                    changed.componentName === 'Event' && this.removeEvent(changed);
+                                    changed.componentName === 'A11y' && this.remove(changed);
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return [2];
+                });
+            });
+        };
+        A11ySystem.prototype.remove = function (changed) {
+            var component = changed.component;
+            if (!component)
+                return;
+            var a11yId = component.a11yId;
+            var element = this.div.querySelector("#" + a11yId);
+            element && this.div.removeChild(element);
+            this.cache.delete(a11yId);
+        };
+        A11ySystem.prototype.add = function (changed) {
+            var _this = this;
+            if (!this.activate)
+                return;
+            var component = changed.component;
+            var gameObject = changed.gameObject;
+            var delay = component.delay, id = component.a11yId;
+            var event = component.event;
+            if (!gameObject)
+                return;
+            var transform = gameObject.transform;
+            if (!transform)
+                return;
+            var element = document.createElement('div');
+            this.cache.set(id, element);
+            if (!event) {
+                event = gameObject.getComponent('Event');
+            }
+            setTimeout(function () {
+                _this.setPosition(element, transform);
+                _this.setA11yAttr(element, component);
+                if (event) {
+                    _this.addEvent(gameObject);
+                }
+                if (gameObject.scene) {
+                    _this.div.appendChild(element);
+                }
+            }, delay || this.delay);
+        };
+        A11ySystem.prototype.transformChange = function (changed) {
+            var component = changed.component;
+            var gameObject = changed.gameObject;
+            var a11yComponent = gameObject.getComponent(A11y$1);
+            if (!a11yComponent)
+                return;
+            var a11yId = a11yComponent.a11yId;
+            if (!component.inScene) {
+                var dom = this.div.querySelector("#" + a11yId);
+                dom && this.div.removeChild(dom);
+            }
+            else {
+                if (this.cache.has(a11yId)) {
+                    var addDom = this.cache.get(a11yId);
+                    addDom && this.div.appendChild(addDom);
+                }
+            }
+        };
+        A11ySystem.prototype.setEvent = function (element, event, gameObject, id) {
+            if (!event) {
+                return;
+            }
+            var func = getEventFunc.bind(this, event, gameObject);
+            this.eventCache.set(id, func);
+            element.addEventListener('click', func);
+        };
+        A11ySystem.prototype.addEvent = function (gameObject) {
+            var a11y = gameObject.getComponent(A11y$1);
+            if (!a11y)
+                return;
+            var event = gameObject.getComponent('Event');
+            if (!event)
+                return;
+            var element = this.cache.get(a11y.a11yId);
+            element && this.setEvent(element, event, gameObject, a11y.a11yId);
+        };
+        A11ySystem.prototype.removeEvent = function (changed) {
+            var gameObject = changed.gameObject;
+            var a11y = gameObject.getComponent(A11y$1);
+            if (!a11y)
+                return;
+            var event = changed.component;
+            if (!event)
+                return;
+            var a11yId = a11y.a11yId;
+            var func = this.eventCache.get(a11yId);
+            var element = this.cache.get(a11yId);
+            element && element.removeEventListener('click', func);
+        };
+        A11ySystem.prototype.setA11yAttr = function (element, component) {
+            var e_2, _a, e_3, _b, e_4, _c;
+            var hint = component.hint, _d = component.props, props = _d === void 0 ? {} : _d, _e = component.state, state = _e === void 0 ? {} : _e, role = component.role, id = component.a11yId;
+            var realRole = role || 'text';
+            element.setAttribute('role', realRole);
+            element.setAttribute('aria-label', hint);
+            element.id = id;
+            var ariaProps = Object.keys(props);
+            try {
+                for (var ariaProps_1 = __values$1(ariaProps), ariaProps_1_1 = ariaProps_1.next(); !ariaProps_1_1.done; ariaProps_1_1 = ariaProps_1.next()) {
+                    var key = ariaProps_1_1.value;
+                    element.setAttribute(key, props[key]);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (ariaProps_1_1 && !ariaProps_1_1.done && (_a = ariaProps_1.return)) _a.call(ariaProps_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            var ariaState = Object.keys(state);
+            try {
+                for (var ariaState_1 = __values$1(ariaState), ariaState_1_1 = ariaState_1.next(); !ariaState_1_1.done; ariaState_1_1 = ariaState_1.next()) {
+                    var key = ariaState_1_1.value;
+                    element.setAttribute(key, state[key]);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (ariaState_1_1 && !ariaState_1_1.done && (_b = ariaState_1.return)) _b.call(ariaState_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var _f = __values$1(Object.keys(component)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var key = _g.value;
+                    if (typeof component[key] === 'string' && notAttr.indexOf(key) === -1 && key.indexOf('_') !== 1) {
+                        element.setAttribute(key, component[key]);
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        };
+        A11ySystem.prototype.setPosition = function (element, transform) {
+            var _a = transform.size, width = _a.width, height = _a.height;
+            var style = {
+                width: width === 0 ? 1 : width * this.ratioX,
+                height: height === 0 ? 1 : height * this.ratioY,
+                position: POSITION,
+                zIndex: ZINDEX,
+                pointerEvents: PointerEvents.AUTO,
+                background: this.debug ? MaskBackground.DEBUG : MaskBackground.NONE,
+            };
+            var transformProps = __assign$1({}, transform);
+            setStyle(element, style);
+            setTransform(element, transformProps, this.ratioX, this.ratioY);
+        };
+        A11ySystem.prototype.onDestroy = function () {
+            this.div.parentElement.removeChild(this.div);
+            this.cache = null;
+            this.eventCache = null;
+        };
+        A11ySystem.systemName = 'A11ySystem';
+        A11ySystem = __decorate$1([
+            eva_js.decorators.componentObserver({
+                A11y: [],
+                Transform: ['inScene'],
+                Event: [],
+            })
+        ], A11ySystem);
+        return A11ySystem;
+    }(eva_js.System));
+    var A11ySystem$1 = A11ySystem;
+
+    exports.A11y = A11y$1;
+    exports.A11ySystem = A11ySystem$1;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=EVA.plugin.a11y.js.map