opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/libs/ecsy.module.js

@@ -0,0 +1,1999 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.ecsyModule = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Component = void 0;
+  _exports.Not = Not;
+  _exports.copyValue = _exports.copyJSON = _exports.copyCopyable = _exports.copyArray = _exports.cloneValue = _exports.cloneJSON = _exports.cloneClonable = _exports.cloneArray = _exports._Entity = _exports.World = _exports.Version = _exports.Types = _exports.TagComponent = _exports.SystemStateComponent = _exports.System = _exports.ObjectPool = void 0;
+  _exports.createType = createType;
+  _exports.enableRemoteDevtools = enableRemoteDevtools;
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  /**
+   * Return the name of a component
+   * @param {Component} Component
+   * @private
+   */
+
+  /**
+   * Get a key from a list of components
+   * @param {Array(Component)} Components Array of components to generate the key
+   * @private
+   */
+  function queryKey(Components) {
+    var ids = [];
+
+    for (var n = 0; n < Components.length; n++) {
+      var T = Components[n];
+
+      if (!componentRegistered(T)) {
+        throw new Error("Tried to create a query with an unregistered component");
+      }
+
+      if (typeof T === "object") {
+        var operator = T.operator === "not" ? "!" : T.operator;
+        ids.push(operator + T.Component._typeId);
+      } else {
+        ids.push(T._typeId);
+      }
+    }
+
+    return ids.sort().join("-");
+  } // Detector for browser's "window"
+
+
+  var hasWindow = typeof window !== "undefined"; // performance.now() "polyfill"
+
+  var now = hasWindow && typeof window.performance !== "undefined" ? performance.now.bind(performance) : Date.now.bind(Date);
+
+  function componentRegistered(T) {
+    return typeof T === "object" && T.Component._typeId !== undefined || T.isComponent && T._typeId !== undefined;
+  }
+
+  var SystemManager = /*#__PURE__*/function () {
+    function SystemManager(world) {
+      _classCallCheck(this, SystemManager);
+
+      this._systems = [];
+      this._executeSystems = []; // Systems that have `execute` method
+
+      this.world = world;
+      this.lastExecutedSystem = null;
+    }
+
+    _createClass(SystemManager, [{
+      key: "registerSystem",
+      value: function registerSystem(SystemClass, attributes) {
+        if (!SystemClass.isSystem) {
+          throw new Error("System '".concat(SystemClass.name, "' does not extend 'System' class"));
+        }
+
+        if (this.getSystem(SystemClass) !== undefined) {
+          console.warn("System '".concat(SystemClass.getName(), "' already registered."));
+          return this;
+        }
+
+        var system = new SystemClass(this.world, attributes);
+        if (system.init) system.init(attributes);
+        system.order = this._systems.length;
+
+        this._systems.push(system);
+
+        if (system.execute) {
+          this._executeSystems.push(system);
+
+          this.sortSystems();
+        }
+
+        return this;
+      }
+    }, {
+      key: "unregisterSystem",
+      value: function unregisterSystem(SystemClass) {
+        var system = this.getSystem(SystemClass);
+
+        if (system === undefined) {
+          console.warn("Can unregister system '".concat(SystemClass.getName(), "'. It doesn't exist."));
+          return this;
+        }
+
+        this._systems.splice(this._systems.indexOf(system), 1);
+
+        if (system.execute) {
+          this._executeSystems.splice(this._executeSystems.indexOf(system), 1);
+        } // @todo Add system.unregister() call to free resources
+
+
+        return this;
+      }
+    }, {
+      key: "sortSystems",
+      value: function sortSystems() {
+        this._executeSystems.sort(function (a, b) {
+          return a.priority - b.priority || a.order - b.order;
+        });
+      }
+    }, {
+      key: "getSystem",
+      value: function getSystem(SystemClass) {
+        return this._systems.find(function (s) {
+          return s instanceof SystemClass;
+        });
+      }
+    }, {
+      key: "getSystems",
+      value: function getSystems() {
+        return this._systems;
+      }
+    }, {
+      key: "removeSystem",
+      value: function removeSystem(SystemClass) {
+        var index = this._systems.indexOf(SystemClass);
+
+        if (!~index) return;
+
+        this._systems.splice(index, 1);
+      }
+    }, {
+      key: "executeSystem",
+      value: function executeSystem(system, delta, time) {
+        if (system.initialized) {
+          if (system.canExecute()) {
+            var startTime = now();
+            system.execute(delta, time);
+            system.executeTime = now() - startTime;
+            this.lastExecutedSystem = system;
+            system.clearEvents();
+          }
+        }
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        this._executeSystems.forEach(function (system) {
+          return system.stop();
+        });
+      }
+    }, {
+      key: "execute",
+      value: function execute(delta, time, forcePlay) {
+        var _this = this;
+
+        this._executeSystems.forEach(function (system) {
+          return (forcePlay || system.enabled) && _this.executeSystem(system, delta, time);
+        });
+      }
+    }, {
+      key: "stats",
+      value: function stats() {
+        var stats = {
+          numSystems: this._systems.length,
+          systems: {}
+        };
+
+        for (var i = 0; i < this._systems.length; i++) {
+          var system = this._systems[i];
+          var systemStats = stats.systems[system.getName()] = {
+            queries: {},
+            executeTime: system.executeTime
+          };
+
+          for (var name in system.ctx) {
+            systemStats.queries[name] = system.ctx[name].stats();
+          }
+        }
+
+        return stats;
+      }
+    }]);
+
+    return SystemManager;
+  }();
+
+  var ObjectPool = /*#__PURE__*/function () {
+    // @todo Add initial size
+    function ObjectPool(T, initialSize) {
+      _classCallCheck(this, ObjectPool);
+
+      this.freeList = [];
+      this.count = 0;
+      this.T = T;
+      this.isObjectPool = true;
+
+      if (typeof initialSize !== "undefined") {
+        this.expand(initialSize);
+      }
+    }
+
+    _createClass(ObjectPool, [{
+      key: "acquire",
+      value: function acquire() {
+        // Grow the list by 20%ish if we're out
+        if (this.freeList.length <= 0) {
+          this.expand(Math.round(this.count * 0.2) + 1);
+        }
+
+        var item = this.freeList.pop();
+        return item;
+      }
+    }, {
+      key: "release",
+      value: function release(item) {
+        item.reset();
+        this.freeList.push(item);
+      }
+    }, {
+      key: "expand",
+      value: function expand(count) {
+        for (var n = 0; n < count; n++) {
+          var clone = new this.T();
+          clone._pool = this;
+          this.freeList.push(clone);
+        }
+
+        this.count += count;
+      }
+    }, {
+      key: "totalSize",
+      value: function totalSize() {
+        return this.count;
+      }
+    }, {
+      key: "totalFree",
+      value: function totalFree() {
+        return this.freeList.length;
+      }
+    }, {
+      key: "totalUsed",
+      value: function totalUsed() {
+        return this.count - this.freeList.length;
+      }
+    }]);
+
+    return ObjectPool;
+  }();
+  /**
+   * @private
+   * @class EventDispatcher
+   */
+
+
+  _exports.ObjectPool = ObjectPool;
+
+  var EventDispatcher = /*#__PURE__*/function () {
+    function EventDispatcher() {
+      _classCallCheck(this, EventDispatcher);
+
+      this._listeners = {};
+      this.stats = {
+        fired: 0,
+        handled: 0
+      };
+    }
+    /**
+     * Add an event listener
+     * @param {String} eventName Name of the event to listen
+     * @param {Function} listener Callback to trigger when the event is fired
+     */
+
+
+    _createClass(EventDispatcher, [{
+      key: "addEventListener",
+      value: function addEventListener(eventName, listener) {
+        var listeners = this._listeners;
+
+        if (listeners[eventName] === undefined) {
+          listeners[eventName] = [];
+        }
+
+        if (listeners[eventName].indexOf(listener) === -1) {
+          listeners[eventName].push(listener);
+        }
+      }
+      /**
+       * Check if an event listener is already added to the list of listeners
+       * @param {String} eventName Name of the event to check
+       * @param {Function} listener Callback for the specified event
+       */
+
+    }, {
+      key: "hasEventListener",
+      value: function hasEventListener(eventName, listener) {
+        return this._listeners[eventName] !== undefined && this._listeners[eventName].indexOf(listener) !== -1;
+      }
+      /**
+       * Remove an event listener
+       * @param {String} eventName Name of the event to remove
+       * @param {Function} listener Callback for the specified event
+       */
+
+    }, {
+      key: "removeEventListener",
+      value: function removeEventListener(eventName, listener) {
+        var listenerArray = this._listeners[eventName];
+
+        if (listenerArray !== undefined) {
+          var index = listenerArray.indexOf(listener);
+
+          if (index !== -1) {
+            listenerArray.splice(index, 1);
+          }
+        }
+      }
+      /**
+       * Dispatch an event
+       * @param {String} eventName Name of the event to dispatch
+       * @param {Entity} entity (Optional) Entity to emit
+       * @param {Component} component
+       */
+
+    }, {
+      key: "dispatchEvent",
+      value: function dispatchEvent(eventName, entity, component) {
+        this.stats.fired++;
+        var listenerArray = this._listeners[eventName];
+
+        if (listenerArray !== undefined) {
+          var array = listenerArray.slice(0);
+
+          for (var i = 0; i < array.length; i++) {
+            array[i].call(this, entity, component);
+          }
+        }
+      }
+      /**
+       * Reset stats counters
+       */
+
+    }, {
+      key: "resetCounters",
+      value: function resetCounters() {
+        this.stats.fired = this.stats.handled = 0;
+      }
+    }]);
+
+    return EventDispatcher;
+  }();
+
+  var Query = /*#__PURE__*/function () {
+    /**
+     * @param {Array(Component)} Components List of types of components to query
+     */
+    function Query(Components, manager) {
+      var _this2 = this;
+
+      _classCallCheck(this, Query);
+
+      this.Components = [];
+      this.NotComponents = [];
+      Components.forEach(function (component) {
+        if (typeof component === "object") {
+          _this2.NotComponents.push(component.Component);
+        } else {
+          _this2.Components.push(component);
+        }
+      });
+
+      if (this.Components.length === 0) {
+        throw new Error("Can't create a query without components");
+      }
+
+      this.entities = [];
+      this.eventDispatcher = new EventDispatcher(); // This query is being used by a reactive system
+
+      this.reactive = false;
+      this.key = queryKey(Components); // Fill the query with the existing entities
+
+      for (var i = 0; i < manager._entities.length; i++) {
+        var entity = manager._entities[i];
+
+        if (this.match(entity)) {
+          // @todo ??? this.addEntity(entity); => preventing the event to be generated
+          entity.queries.push(this);
+          this.entities.push(entity);
+        }
+      }
+    }
+    /**
+     * Add entity to this query
+     * @param {Entity} entity
+     */
+
+
+    _createClass(Query, [{
+      key: "addEntity",
+      value: function addEntity(entity) {
+        entity.queries.push(this);
+        this.entities.push(entity);
+        this.eventDispatcher.dispatchEvent(Query.prototype.ENTITY_ADDED, entity);
+      }
+      /**
+       * Remove entity from this query
+       * @param {Entity} entity
+       */
+
+    }, {
+      key: "removeEntity",
+      value: function removeEntity(entity) {
+        var index = this.entities.indexOf(entity);
+
+        if (~index) {
+          this.entities.splice(index, 1);
+          index = entity.queries.indexOf(this);
+          entity.queries.splice(index, 1);
+          this.eventDispatcher.dispatchEvent(Query.prototype.ENTITY_REMOVED, entity);
+        }
+      }
+    }, {
+      key: "match",
+      value: function match(entity) {
+        return entity.hasAllComponents(this.Components) && !entity.hasAnyComponents(this.NotComponents);
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return {
+          key: this.key,
+          reactive: this.reactive,
+          components: {
+            included: this.Components.map(function (C) {
+              return C.name;
+            }),
+            not: this.NotComponents.map(function (C) {
+              return C.name;
+            })
+          },
+          numEntities: this.entities.length
+        };
+      }
+      /**
+       * Return stats for this query
+       */
+
+    }, {
+      key: "stats",
+      value: function stats() {
+        return {
+          numComponents: this.Components.length,
+          numEntities: this.entities.length
+        };
+      }
+    }]);
+
+    return Query;
+  }();
+
+  Query.prototype.ENTITY_ADDED = "Query#ENTITY_ADDED";
+  Query.prototype.ENTITY_REMOVED = "Query#ENTITY_REMOVED";
+  Query.prototype.COMPONENT_CHANGED = "Query#COMPONENT_CHANGED";
+  /**
+   * @private
+   * @class QueryManager
+   */
+
+  var QueryManager = /*#__PURE__*/function () {
+    function QueryManager(world) {
+      _classCallCheck(this, QueryManager);
+
+      this._world = world; // Queries indexed by a unique identifier for the components it has
+
+      this._queries = {};
+    }
+
+    _createClass(QueryManager, [{
+      key: "onEntityRemoved",
+      value: function onEntityRemoved(entity) {
+        for (var queryName in this._queries) {
+          var query = this._queries[queryName];
+
+          if (entity.queries.indexOf(query) !== -1) {
+            query.removeEntity(entity);
+          }
+        }
+      }
+      /**
+       * Callback when a component is added to an entity
+       * @param {Entity} entity Entity that just got the new component
+       * @param {Component} Component Component added to the entity
+       */
+
+    }, {
+      key: "onEntityComponentAdded",
+      value: function onEntityComponentAdded(entity, Component) {
+        // @todo Use bitmask for checking components?
+        // Check each indexed query to see if we need to add this entity to the list
+        for (var queryName in this._queries) {
+          var query = this._queries[queryName];
+
+          if (!!~query.NotComponents.indexOf(Component) && ~query.entities.indexOf(entity)) {
+            query.removeEntity(entity);
+            continue;
+          } // Add the entity only if:
+          // Component is in the query
+          // and Entity has ALL the components of the query
+          // and Entity is not already in the query
+
+
+          if (!~query.Components.indexOf(Component) || !query.match(entity) || ~query.entities.indexOf(entity)) continue;
+          query.addEntity(entity);
+        }
+      }
+      /**
+       * Callback when a component is removed from an entity
+       * @param {Entity} entity Entity to remove the component from
+       * @param {Component} Component Component to remove from the entity
+       */
+
+    }, {
+      key: "onEntityComponentRemoved",
+      value: function onEntityComponentRemoved(entity, Component) {
+        for (var queryName in this._queries) {
+          var query = this._queries[queryName];
+
+          if (!!~query.NotComponents.indexOf(Component) && !~query.entities.indexOf(entity) && query.match(entity)) {
+            query.addEntity(entity);
+            continue;
+          }
+
+          if (!!~query.Components.indexOf(Component) && !!~query.entities.indexOf(entity) && !query.match(entity)) {
+            query.removeEntity(entity);
+            continue;
+          }
+        }
+      }
+      /**
+       * Get a query for the specified components
+       * @param {Component} Components Components that the query should have
+       */
+
+    }, {
+      key: "getQuery",
+      value: function getQuery(Components) {
+        var key = queryKey(Components);
+        var query = this._queries[key];
+
+        if (!query) {
+          this._queries[key] = query = new Query(Components, this._world);
+        }
+
+        return query;
+      }
+      /**
+       * Return some stats from this class
+       */
+
+    }, {
+      key: "stats",
+      value: function stats() {
+        var stats = {};
+
+        for (var queryName in this._queries) {
+          stats[queryName] = this._queries[queryName].stats();
+        }
+
+        return stats;
+      }
+    }]);
+
+    return QueryManager;
+  }();
+
+  var Component = /*#__PURE__*/function () {
+    function Component(props) {
+      _classCallCheck(this, Component);
+
+      if (props !== false) {
+        var schema = this.constructor.schema;
+
+        for (var key in schema) {
+          if (props && props.hasOwnProperty(key)) {
+            this[key] = props[key];
+          } else {
+            var schemaProp = schema[key];
+
+            if (schemaProp.hasOwnProperty("default")) {
+              this[key] = schemaProp.type.clone(schemaProp.default);
+            } else {
+              var type = schemaProp.type;
+              this[key] = type.clone(type.default);
+            }
+          }
+        }
+
+        if (props !== undefined) {
+          this.checkUndefinedAttributes(props);
+        }
+      }
+
+      this._pool = null;
+    }
+
+    _createClass(Component, [{
+      key: "copy",
+      value: function copy(source) {
+        var schema = this.constructor.schema;
+
+        for (var key in schema) {
+          var prop = schema[key];
+
+          if (source.hasOwnProperty(key)) {
+            this[key] = prop.type.copy(source[key], this[key]);
+          }
+        } // @DEBUG
+
+
+        {
+          this.checkUndefinedAttributes(source);
+        }
+        return this;
+      }
+    }, {
+      key: "clone",
+      value: function clone() {
+        return new this.constructor().copy(this);
+      }
+    }, {
+      key: "reset",
+      value: function reset() {
+        var schema = this.constructor.schema;
+
+        for (var key in schema) {
+          var schemaProp = schema[key];
+
+          if (schemaProp.hasOwnProperty("default")) {
+            this[key] = schemaProp.type.copy(schemaProp.default, this[key]);
+          } else {
+            var type = schemaProp.type;
+            this[key] = type.copy(type.default, this[key]);
+          }
+        }
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        if (this._pool) {
+          this._pool.release(this);
+        }
+      }
+    }, {
+      key: "getName",
+      value: function getName() {
+        return this.constructor.getName();
+      }
+    }, {
+      key: "checkUndefinedAttributes",
+      value: function checkUndefinedAttributes(src) {
+        var _this3 = this;
+
+        var schema = this.constructor.schema; // Check that the attributes defined in source are also defined in the schema
+
+        Object.keys(src).forEach(function (srcKey) {
+          if (!schema.hasOwnProperty(srcKey)) {
+            console.warn("Trying to set attribute '".concat(srcKey, "' not defined in the '").concat(_this3.constructor.name, "' schema. Please fix the schema, the attribute value won't be set"));
+          }
+        });
+      }
+    }]);
+
+    return Component;
+  }();
+
+  _exports.Component = Component;
+  Component.schema = {};
+  Component.isComponent = true;
+
+  Component.getName = function () {
+    return this.displayName || this.name;
+  };
+
+  var SystemStateComponent = /*#__PURE__*/function (_Component) {
+    _inherits(SystemStateComponent, _Component);
+
+    var _super = _createSuper(SystemStateComponent);
+
+    function SystemStateComponent() {
+      _classCallCheck(this, SystemStateComponent);
+
+      return _super.apply(this, arguments);
+    }
+
+    return _createClass(SystemStateComponent);
+  }(Component);
+
+  _exports.SystemStateComponent = SystemStateComponent;
+  SystemStateComponent.isSystemStateComponent = true;
+
+  var EntityPool = /*#__PURE__*/function (_ObjectPool) {
+    _inherits(EntityPool, _ObjectPool);
+
+    var _super2 = _createSuper(EntityPool);
+
+    function EntityPool(entityManager, entityClass, initialSize) {
+      var _this4;
+
+      _classCallCheck(this, EntityPool);
+
+      _this4 = _super2.call(this, entityClass, undefined);
+      _this4.entityManager = entityManager;
+
+      if (typeof initialSize !== "undefined") {
+        _this4.expand(initialSize);
+      }
+
+      return _this4;
+    }
+
+    _createClass(EntityPool, [{
+      key: "expand",
+      value: function expand(count) {
+        for (var n = 0; n < count; n++) {
+          var clone = new this.T(this.entityManager);
+          clone._pool = this;
+          this.freeList.push(clone);
+        }
+
+        this.count += count;
+      }
+    }]);
+
+    return EntityPool;
+  }(ObjectPool);
+  /**
+   * @private
+   * @class EntityManager
+   */
+
+
+  var EntityManager = /*#__PURE__*/function () {
+    function EntityManager(world) {
+      _classCallCheck(this, EntityManager);
+
+      this.world = world;
+      this.componentsManager = world.componentsManager; // All the entities in this instance
+
+      this._entities = [];
+      this._nextEntityId = 0;
+      this._entitiesByNames = {};
+      this._queryManager = new QueryManager(this);
+      this.eventDispatcher = new EventDispatcher();
+      this._entityPool = new EntityPool(this, this.world.options.entityClass, this.world.options.entityPoolSize); // Deferred deletion
+
+      this.entitiesWithComponentsToRemove = [];
+      this.entitiesToRemove = [];
+      this.deferredRemovalEnabled = true;
+    }
+
+    _createClass(EntityManager, [{
+      key: "getEntityByName",
+      value: function getEntityByName(name) {
+        return this._entitiesByNames[name];
+      }
+      /**
+       * Create a new entity
+       */
+
+    }, {
+      key: "createEntity",
+      value: function createEntity(name) {
+        var entity = this._entityPool.acquire();
+
+        entity.alive = true;
+        entity.name = name || "";
+
+        if (name) {
+          if (this._entitiesByNames[name]) {
+            console.warn("Entity name '".concat(name, "' already exist"));
+          } else {
+            this._entitiesByNames[name] = entity;
+          }
+        }
+
+        this._entities.push(entity);
+
+        this.eventDispatcher.dispatchEvent(ENTITY_CREATED, entity);
+        return entity;
+      } // COMPONENTS
+
+      /**
+       * Add a component to an entity
+       * @param {Entity} entity Entity where the component will be added
+       * @param {Component} Component Component to be added to the entity
+       * @param {Object} values Optional values to replace the default attributes
+       */
+
+    }, {
+      key: "entityAddComponent",
+      value: function entityAddComponent(entity, Component, values) {
+        // @todo Probably define Component._typeId with a default value and avoid using typeof
+        if (typeof Component._typeId === "undefined" && !this.world.componentsManager._ComponentsMap[Component._typeId]) {
+          throw new Error("Attempted to add unregistered component \"".concat(Component.getName(), "\""));
+        }
+
+        if (~entity._ComponentTypes.indexOf(Component)) {
+          {
+            console.warn("Component type already exists on entity.", entity, Component.getName());
+          }
+          return;
+        }
+
+        entity._ComponentTypes.push(Component);
+
+        if (Component.__proto__ === SystemStateComponent) {
+          entity.numStateComponents++;
+        }
+
+        var componentPool = this.world.componentsManager.getComponentsPool(Component);
+        var component = componentPool ? componentPool.acquire() : new Component(values);
+
+        if (componentPool && values) {
+          component.copy(values);
+        }
+
+        entity._components[Component._typeId] = component;
+
+        this._queryManager.onEntityComponentAdded(entity, Component);
+
+        this.world.componentsManager.componentAddedToEntity(Component);
+        this.eventDispatcher.dispatchEvent(COMPONENT_ADDED, entity, Component);
+      }
+      /**
+       * Remove a component from an entity
+       * @param {Entity} entity Entity which will get removed the component
+       * @param {*} Component Component to remove from the entity
+       * @param {Bool} immediately If you want to remove the component immediately instead of deferred (Default is false)
+       */
+
+    }, {
+      key: "entityRemoveComponent",
+      value: function entityRemoveComponent(entity, Component, immediately) {
+        var index = entity._ComponentTypes.indexOf(Component);
+
+        if (!~index) return;
+        this.eventDispatcher.dispatchEvent(COMPONENT_REMOVE, entity, Component);
+
+        if (immediately) {
+          this._entityRemoveComponentSync(entity, Component, index);
+        } else {
+          if (entity._ComponentTypesToRemove.length === 0) this.entitiesWithComponentsToRemove.push(entity);
+
+          entity._ComponentTypes.splice(index, 1);
+
+          entity._ComponentTypesToRemove.push(Component);
+
+          entity._componentsToRemove[Component._typeId] = entity._components[Component._typeId];
+          delete entity._components[Component._typeId];
+        } // Check each indexed query to see if we need to remove it
+
+
+        this._queryManager.onEntityComponentRemoved(entity, Component);
+
+        if (Component.__proto__ === SystemStateComponent) {
+          entity.numStateComponents--; // Check if the entity was a ghost waiting for the last system state component to be removed
+
+          if (entity.numStateComponents === 0 && !entity.alive) {
+            entity.remove();
+          }
+        }
+      }
+    }, {
+      key: "_entityRemoveComponentSync",
+      value: function _entityRemoveComponentSync(entity, Component, index) {
+        // Remove T listing on entity and property ref, then free the component.
+        entity._ComponentTypes.splice(index, 1);
+
+        var component = entity._components[Component._typeId];
+        delete entity._components[Component._typeId];
+        component.dispose();
+        this.world.componentsManager.componentRemovedFromEntity(Component);
+      }
+      /**
+       * Remove all the components from an entity
+       * @param {Entity} entity Entity from which the components will be removed
+       */
+
+    }, {
+      key: "entityRemoveAllComponents",
+      value: function entityRemoveAllComponents(entity, immediately) {
+        var Components = entity._ComponentTypes;
+
+        for (var j = Components.length - 1; j >= 0; j--) {
+          if (Components[j].__proto__ !== SystemStateComponent) this.entityRemoveComponent(entity, Components[j], immediately);
+        }
+      }
+      /**
+       * Remove the entity from this manager. It will clear also its components
+       * @param {Entity} entity Entity to remove from the manager
+       * @param {Bool} immediately If you want to remove the component immediately instead of deferred (Default is false)
+       */
+
+    }, {
+      key: "removeEntity",
+      value: function removeEntity(entity, immediately) {
+        var index = this._entities.indexOf(entity);
+
+        if (!~index) throw new Error("Tried to remove entity not in list");
+        entity.alive = false;
+        this.entityRemoveAllComponents(entity, immediately);
+
+        if (entity.numStateComponents === 0) {
+          // Remove from entity list
+          this.eventDispatcher.dispatchEvent(ENTITY_REMOVED, entity);
+
+          this._queryManager.onEntityRemoved(entity);
+
+          if (immediately === true) {
+            this._releaseEntity(entity, index);
+          } else {
+            this.entitiesToRemove.push(entity);
+          }
+        }
+      }
+    }, {
+      key: "_releaseEntity",
+      value: function _releaseEntity(entity, index) {
+        this._entities.splice(index, 1);
+
+        if (this._entitiesByNames[entity.name]) {
+          delete this._entitiesByNames[entity.name];
+        }
+
+        entity._pool.release(entity);
+      }
+      /**
+       * Remove all entities from this manager
+       */
+
+    }, {
+      key: "removeAllEntities",
+      value: function removeAllEntities() {
+        for (var i = this._entities.length - 1; i >= 0; i--) {
+          this.removeEntity(this._entities[i]);
+        }
+      }
+    }, {
+      key: "processDeferredRemoval",
+      value: function processDeferredRemoval() {
+        if (!this.deferredRemovalEnabled) {
+          return;
+        }
+
+        for (var i = 0; i < this.entitiesToRemove.length; i++) {
+          var entity = this.entitiesToRemove[i];
+
+          var index = this._entities.indexOf(entity);
+
+          this._releaseEntity(entity, index);
+        }
+
+        this.entitiesToRemove.length = 0;
+
+        for (var _i = 0; _i < this.entitiesWithComponentsToRemove.length; _i++) {
+          var _entity = this.entitiesWithComponentsToRemove[_i];
+
+          while (_entity._ComponentTypesToRemove.length > 0) {
+            var _Component2 = _entity._ComponentTypesToRemove.pop();
+
+            var component = _entity._componentsToRemove[_Component2._typeId];
+            delete _entity._componentsToRemove[_Component2._typeId];
+            component.dispose();
+            this.world.componentsManager.componentRemovedFromEntity(_Component2); //this._entityRemoveComponentSync(entity, Component, index);
+          }
+        }
+
+        this.entitiesWithComponentsToRemove.length = 0;
+      }
+      /**
+       * Get a query based on a list of components
+       * @param {Array(Component)} Components List of components that will form the query
+       */
+
+    }, {
+      key: "queryComponents",
+      value: function queryComponents(Components) {
+        return this._queryManager.getQuery(Components);
+      } // EXTRAS
+
+      /**
+       * Return number of entities
+       */
+
+    }, {
+      key: "count",
+      value: function count() {
+        return this._entities.length;
+      }
+      /**
+       * Return some stats
+       */
+
+    }, {
+      key: "stats",
+      value: function stats() {
+        var stats = {
+          numEntities: this._entities.length,
+          numQueries: Object.keys(this._queryManager._queries).length,
+          queries: this._queryManager.stats(),
+          numComponentPool: Object.keys(this.componentsManager._componentPool).length,
+          componentPool: {},
+          eventDispatcher: this.eventDispatcher.stats
+        };
+
+        for (var ecsyComponentId in this.componentsManager._componentPool) {
+          var pool = this.componentsManager._componentPool[ecsyComponentId];
+          stats.componentPool[pool.T.getName()] = {
+            used: pool.totalUsed(),
+            size: pool.count
+          };
+        }
+
+        return stats;
+      }
+    }]);
+
+    return EntityManager;
+  }();
+
+  var ENTITY_CREATED = "EntityManager#ENTITY_CREATE";
+  var ENTITY_REMOVED = "EntityManager#ENTITY_REMOVED";
+  var COMPONENT_ADDED = "EntityManager#COMPONENT_ADDED";
+  var COMPONENT_REMOVE = "EntityManager#COMPONENT_REMOVE";
+
+  var ComponentManager = /*#__PURE__*/function () {
+    function ComponentManager() {
+      _classCallCheck(this, ComponentManager);
+
+      this.Components = [];
+      this._ComponentsMap = {};
+      this._componentPool = {};
+      this.numComponents = {};
+      this.nextComponentId = 0;
+    }
+
+    _createClass(ComponentManager, [{
+      key: "hasComponent",
+      value: function hasComponent(Component) {
+        return this.Components.indexOf(Component) !== -1;
+      }
+    }, {
+      key: "registerComponent",
+      value: function registerComponent(Component, objectPool) {
+        if (this.Components.indexOf(Component) !== -1) {
+          console.warn("Component type: '".concat(Component.getName(), "' already registered."));
+          return;
+        }
+
+        var schema = Component.schema;
+
+        if (!schema) {
+          throw new Error("Component \"".concat(Component.getName(), "\" has no schema property."));
+        }
+
+        for (var propName in schema) {
+          var prop = schema[propName];
+
+          if (!prop.type) {
+            throw new Error("Invalid schema for component \"".concat(Component.getName(), "\". Missing type for \"").concat(propName, "\" property."));
+          }
+        }
+
+        Component._typeId = this.nextComponentId++;
+        this.Components.push(Component);
+        this._ComponentsMap[Component._typeId] = Component;
+        this.numComponents[Component._typeId] = 0;
+
+        if (objectPool === undefined) {
+          objectPool = new ObjectPool(Component);
+        } else if (objectPool === false) {
+          objectPool = undefined;
+        }
+
+        this._componentPool[Component._typeId] = objectPool;
+      }
+    }, {
+      key: "componentAddedToEntity",
+      value: function componentAddedToEntity(Component) {
+        this.numComponents[Component._typeId]++;
+      }
+    }, {
+      key: "componentRemovedFromEntity",
+      value: function componentRemovedFromEntity(Component) {
+        this.numComponents[Component._typeId]--;
+      }
+    }, {
+      key: "getComponentsPool",
+      value: function getComponentsPool(Component) {
+        return this._componentPool[Component._typeId];
+      }
+    }]);
+
+    return ComponentManager;
+  }();
+
+  var Version = "0.3.1";
+  _exports.Version = Version;
+  var proxyMap = new WeakMap();
+  var proxyHandler = {
+    set: function set(target, prop) {
+      throw new Error("Tried to write to \"".concat(target.constructor.getName(), "#").concat(String(prop), "\" on immutable component. Use .getMutableComponent() to modify a component."));
+    }
+  };
+
+  function wrapImmutableComponent(T, component) {
+    if (component === undefined) {
+      return undefined;
+    }
+
+    var wrappedComponent = proxyMap.get(component);
+
+    if (!wrappedComponent) {
+      wrappedComponent = new Proxy(component, proxyHandler);
+      proxyMap.set(component, wrappedComponent);
+    }
+
+    return wrappedComponent;
+  }
+
+  var Entity = /*#__PURE__*/function () {
+    function Entity(entityManager) {
+      _classCallCheck(this, Entity);
+
+      this._entityManager = entityManager || null; // Unique ID for this entity
+
+      this.id = entityManager._nextEntityId++; // List of components types the entity has
+
+      this._ComponentTypes = []; // Instance of the components
+
+      this._components = {};
+      this._componentsToRemove = {}; // Queries where the entity is added
+
+      this.queries = []; // Used for deferred removal
+
+      this._ComponentTypesToRemove = [];
+      this.alive = false; //if there are state components on a entity, it can't be removed completely
+
+      this.numStateComponents = 0;
+    } // COMPONENTS
+
+
+    _createClass(Entity, [{
+      key: "getComponent",
+      value: function getComponent(Component, includeRemoved) {
+        var component = this._components[Component._typeId];
+
+        if (!component && includeRemoved === true) {
+          component = this._componentsToRemove[Component._typeId];
+        }
+
+        return wrapImmutableComponent(Component, component);
+      }
+    }, {
+      key: "getRemovedComponent",
+      value: function getRemovedComponent(Component) {
+        var component = this._componentsToRemove[Component._typeId];
+        return wrapImmutableComponent(Component, component);
+      }
+    }, {
+      key: "getComponents",
+      value: function getComponents() {
+        return this._components;
+      }
+    }, {
+      key: "getComponentsToRemove",
+      value: function getComponentsToRemove() {
+        return this._componentsToRemove;
+      }
+    }, {
+      key: "getComponentTypes",
+      value: function getComponentTypes() {
+        return this._ComponentTypes;
+      }
+    }, {
+      key: "getMutableComponent",
+      value: function getMutableComponent(Component) {
+        var component = this._components[Component._typeId];
+
+        if (!component) {
+          return;
+        }
+
+        for (var i = 0; i < this.queries.length; i++) {
+          var query = this.queries[i]; // @todo accelerate this check. Maybe having query._Components as an object
+          // @todo add Not components
+
+          if (query.reactive && query.Components.indexOf(Component) !== -1) {
+            query.eventDispatcher.dispatchEvent(Query.prototype.COMPONENT_CHANGED, this, component);
+          }
+        }
+
+        return component;
+      }
+    }, {
+      key: "addComponent",
+      value: function addComponent(Component, values) {
+        this._entityManager.entityAddComponent(this, Component, values);
+
+        return this;
+      }
+    }, {
+      key: "removeComponent",
+      value: function removeComponent(Component, forceImmediate) {
+        this._entityManager.entityRemoveComponent(this, Component, forceImmediate);
+
+        return this;
+      }
+    }, {
+      key: "hasComponent",
+      value: function hasComponent(Component, includeRemoved) {
+        return !!~this._ComponentTypes.indexOf(Component) || includeRemoved === true && this.hasRemovedComponent(Component);
+      }
+    }, {
+      key: "hasRemovedComponent",
+      value: function hasRemovedComponent(Component) {
+        return !!~this._ComponentTypesToRemove.indexOf(Component);
+      }
+    }, {
+      key: "hasAllComponents",
+      value: function hasAllComponents(Components) {
+        for (var i = 0; i < Components.length; i++) {
+          if (!this.hasComponent(Components[i])) return false;
+        }
+
+        return true;
+      }
+    }, {
+      key: "hasAnyComponents",
+      value: function hasAnyComponents(Components) {
+        for (var i = 0; i < Components.length; i++) {
+          if (this.hasComponent(Components[i])) return true;
+        }
+
+        return false;
+      }
+    }, {
+      key: "removeAllComponents",
+      value: function removeAllComponents(forceImmediate) {
+        return this._entityManager.entityRemoveAllComponents(this, forceImmediate);
+      }
+    }, {
+      key: "copy",
+      value: function copy(src) {
+        // TODO: This can definitely be optimized
+        for (var ecsyComponentId in src._components) {
+          var srcComponent = src._components[ecsyComponentId];
+          this.addComponent(srcComponent.constructor);
+          var component = this.getComponent(srcComponent.constructor);
+          component.copy(srcComponent);
+        }
+
+        return this;
+      }
+    }, {
+      key: "clone",
+      value: function clone() {
+        return new Entity(this._entityManager).copy(this);
+      }
+    }, {
+      key: "reset",
+      value: function reset() {
+        this.id = this._entityManager._nextEntityId++;
+        this._ComponentTypes.length = 0;
+        this.queries.length = 0;
+
+        for (var ecsyComponentId in this._components) {
+          delete this._components[ecsyComponentId];
+        }
+      }
+    }, {
+      key: "remove",
+      value: function remove(forceImmediate) {
+        return this._entityManager.removeEntity(this, forceImmediate);
+      }
+    }]);
+
+    return Entity;
+  }();
+
+  _exports._Entity = Entity;
+  var DEFAULT_OPTIONS = {
+    entityPoolSize: 0,
+    entityClass: Entity
+  };
+
+  var World = /*#__PURE__*/function () {
+    function World() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      _classCallCheck(this, World);
+
+      this.options = Object.assign({}, DEFAULT_OPTIONS, options);
+      this.componentsManager = new ComponentManager(this);
+      this.entityManager = new EntityManager(this);
+      this.systemManager = new SystemManager(this);
+      this.enabled = true;
+      this.eventQueues = {};
+
+      if (hasWindow && typeof CustomEvent !== "undefined") {
+        var event = new CustomEvent("ecsy-world-created", {
+          detail: {
+            world: this,
+            version: Version
+          }
+        });
+        window.dispatchEvent(event);
+      }
+
+      this.lastTime = now() / 1000;
+    }
+
+    _createClass(World, [{
+      key: "registerComponent",
+      value: function registerComponent(Component, objectPool) {
+        this.componentsManager.registerComponent(Component, objectPool);
+        return this;
+      }
+    }, {
+      key: "registerSystem",
+      value: function registerSystem(System, attributes) {
+        this.systemManager.registerSystem(System, attributes);
+        return this;
+      }
+    }, {
+      key: "hasRegisteredComponent",
+      value: function hasRegisteredComponent(Component) {
+        return this.componentsManager.hasComponent(Component);
+      }
+    }, {
+      key: "unregisterSystem",
+      value: function unregisterSystem(System) {
+        this.systemManager.unregisterSystem(System);
+        return this;
+      }
+    }, {
+      key: "getSystem",
+      value: function getSystem(SystemClass) {
+        return this.systemManager.getSystem(SystemClass);
+      }
+    }, {
+      key: "getSystems",
+      value: function getSystems() {
+        return this.systemManager.getSystems();
+      }
+    }, {
+      key: "execute",
+      value: function execute(delta, time) {
+        if (!delta) {
+          time = now() / 1000;
+          delta = time - this.lastTime;
+          this.lastTime = time;
+        }
+
+        if (this.enabled) {
+          this.systemManager.execute(delta, time);
+          this.entityManager.processDeferredRemoval();
+        }
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        this.enabled = false;
+      }
+    }, {
+      key: "play",
+      value: function play() {
+        this.enabled = true;
+      }
+    }, {
+      key: "createEntity",
+      value: function createEntity(name) {
+        return this.entityManager.createEntity(name);
+      }
+    }, {
+      key: "stats",
+      value: function stats() {
+        var stats = {
+          entities: this.entityManager.stats(),
+          system: this.systemManager.stats()
+        };
+        return stats;
+      }
+    }]);
+
+    return World;
+  }();
+
+  _exports.World = World;
+
+  var System = /*#__PURE__*/function () {
+    function System(world, attributes) {
+      var _this5 = this;
+
+      _classCallCheck(this, System);
+
+      this.world = world;
+      this.enabled = true; // @todo Better naming :)
+
+      this._queries = {};
+      this.queries = {};
+      this.priority = 0; // Used for stats
+
+      this.executeTime = 0;
+
+      if (attributes && attributes.priority) {
+        this.priority = attributes.priority;
+      }
+
+      this._mandatoryQueries = [];
+      this.initialized = true;
+
+      if (this.constructor.queries) {
+        var _loop = function _loop() {
+          queryConfig = _this5.constructor.queries[queryName];
+          Components = queryConfig.components;
+
+          if (!Components || Components.length === 0) {
+            throw new Error("'components' attribute can't be empty in a query");
+          } // Detect if the components have already been registered
+
+
+          var unregisteredComponents = Components.filter(function (Component) {
+            return !componentRegistered(Component);
+          });
+
+          if (unregisteredComponents.length > 0) {
+            throw new Error("Tried to create a query '".concat(_this5.constructor.name, ".").concat(queryName, "' with unregistered components: [").concat(unregisteredComponents.map(function (c) {
+              return c.getName();
+            }).join(", "), "]"));
+          }
+
+          query = _this5.world.entityManager.queryComponents(Components);
+          _this5._queries[queryName] = query;
+
+          if (queryConfig.mandatory === true) {
+            _this5._mandatoryQueries.push(query);
+          }
+
+          _this5.queries[queryName] = {
+            results: query.entities
+          }; // Reactive configuration added/removed/changed
+
+          validEvents = ["added", "removed", "changed"];
+          var eventMapping = {
+            added: Query.prototype.ENTITY_ADDED,
+            removed: Query.prototype.ENTITY_REMOVED,
+            changed: Query.prototype.COMPONENT_CHANGED // Query.prototype.ENTITY_CHANGED
+
+          };
+
+          if (queryConfig.listen) {
+            validEvents.forEach(function (eventName) {
+              if (!_this5.execute) {
+                console.warn("System '".concat(_this5.getName(), "' has defined listen events (").concat(validEvents.join(", "), ") for query '").concat(queryName, "' but it does not implement the 'execute' method."));
+              } // Is the event enabled on this system's query?
+
+
+              if (queryConfig.listen[eventName]) {
+                var event = queryConfig.listen[eventName];
+
+                if (eventName === "changed") {
+                  query.reactive = true;
+
+                  if (event === true) {
+                    // Any change on the entity from the components in the query
+                    var eventList = _this5.queries[queryName][eventName] = [];
+                    query.eventDispatcher.addEventListener(Query.prototype.COMPONENT_CHANGED, function (entity) {
+                      // Avoid duplicates
+                      if (eventList.indexOf(entity) === -1) {
+                        eventList.push(entity);
+                      }
+                    });
+                  } else if (Array.isArray(event)) {
+                    var _eventList = _this5.queries[queryName][eventName] = [];
+
+                    query.eventDispatcher.addEventListener(Query.prototype.COMPONENT_CHANGED, function (entity, changedComponent) {
+                      // Avoid duplicates
+                      if (event.indexOf(changedComponent.constructor) !== -1 && _eventList.indexOf(entity) === -1) {
+                        _eventList.push(entity);
+                      }
+                    });
+                  }
+                } else {
+                  var _eventList2 = _this5.queries[queryName][eventName] = [];
+
+                  query.eventDispatcher.addEventListener(eventMapping[eventName], function (entity) {
+                    // @fixme overhead?
+                    if (_eventList2.indexOf(entity) === -1) _eventList2.push(entity);
+                  });
+                }
+              }
+            });
+          }
+        };
+
+        for (var queryName in this.constructor.queries) {
+          var queryConfig;
+          var Components;
+          var query;
+          var validEvents;
+
+          _loop();
+        }
+      }
+    }
+
+    _createClass(System, [{
+      key: "canExecute",
+      value: function canExecute() {
+        if (this._mandatoryQueries.length === 0) return true;
+
+        for (var i = 0; i < this._mandatoryQueries.length; i++) {
+          var query = this._mandatoryQueries[i];
+
+          if (query.entities.length === 0) {
+            return false;
+          }
+        }
+
+        return true;
+      }
+    }, {
+      key: "getName",
+      value: function getName() {
+        return this.constructor.getName();
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        this.executeTime = 0;
+        this.enabled = false;
+      }
+    }, {
+      key: "play",
+      value: function play() {
+        this.enabled = true;
+      } // @question rename to clear queues?
+
+    }, {
+      key: "clearEvents",
+      value: function clearEvents() {
+        for (var queryName in this.queries) {
+          var query = this.queries[queryName];
+
+          if (query.added) {
+            query.added.length = 0;
+          }
+
+          if (query.removed) {
+            query.removed.length = 0;
+          }
+
+          if (query.changed) {
+            if (Array.isArray(query.changed)) {
+              query.changed.length = 0;
+            } else {
+              for (var name in query.changed) {
+                query.changed[name].length = 0;
+              }
+            }
+          }
+        }
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        var _this6 = this;
+
+        var json = {
+          name: this.getName(),
+          enabled: this.enabled,
+          executeTime: this.executeTime,
+          priority: this.priority,
+          queries: {}
+        };
+
+        if (this.constructor.queries) {
+          var queries = this.constructor.queries;
+
+          var _loop2 = function _loop2(queryName) {
+            var query = _this6.queries[queryName];
+            var queryDefinition = queries[queryName];
+            var jsonQuery = json.queries[queryName] = {
+              key: _this6._queries[queryName].key
+            };
+            jsonQuery.mandatory = queryDefinition.mandatory === true;
+            jsonQuery.reactive = queryDefinition.listen && (queryDefinition.listen.added === true || queryDefinition.listen.removed === true || queryDefinition.listen.changed === true || Array.isArray(queryDefinition.listen.changed));
+
+            if (jsonQuery.reactive) {
+              jsonQuery.listen = {};
+              var methods = ["added", "removed", "changed"];
+              methods.forEach(function (method) {
+                if (query[method]) {
+                  jsonQuery.listen[method] = {
+                    entities: query[method].length
+                  };
+                }
+              });
+            }
+          };
+
+          for (var queryName in queries) {
+            _loop2(queryName);
+          }
+        }
+
+        return json;
+      }
+    }]);
+
+    return System;
+  }();
+
+  _exports.System = System;
+  System.isSystem = true;
+
+  System.getName = function () {
+    return this.displayName || this.name;
+  };
+
+  function Not(Component) {
+    return {
+      operator: "not",
+      Component: Component
+    };
+  }
+
+  var TagComponent = /*#__PURE__*/function (_Component3) {
+    _inherits(TagComponent, _Component3);
+
+    var _super3 = _createSuper(TagComponent);
+
+    function TagComponent() {
+      _classCallCheck(this, TagComponent);
+
+      return _super3.call(this, false);
+    }
+
+    return _createClass(TagComponent);
+  }(Component);
+
+  _exports.TagComponent = TagComponent;
+  TagComponent.isTagComponent = true;
+
+  var copyValue = function copyValue(src) {
+    return src;
+  };
+
+  _exports.copyValue = copyValue;
+
+  var cloneValue = function cloneValue(src) {
+    return src;
+  };
+
+  _exports.cloneValue = cloneValue;
+
+  var copyArray = function copyArray(src, dest) {
+    if (!src) {
+      return src;
+    }
+
+    if (!dest) {
+      return src.slice();
+    }
+
+    dest.length = 0;
+
+    for (var i = 0; i < src.length; i++) {
+      dest.push(src[i]);
+    }
+
+    return dest;
+  };
+
+  _exports.copyArray = copyArray;
+
+  var cloneArray = function cloneArray(src) {
+    return src && src.slice();
+  };
+
+  _exports.cloneArray = cloneArray;
+
+  var copyJSON = function copyJSON(src) {
+    return JSON.parse(JSON.stringify(src));
+  };
+
+  _exports.copyJSON = copyJSON;
+
+  var cloneJSON = function cloneJSON(src) {
+    return JSON.parse(JSON.stringify(src));
+  };
+
+  _exports.cloneJSON = cloneJSON;
+
+  var copyCopyable = function copyCopyable(src, dest) {
+    if (!src) {
+      return src;
+    }
+
+    if (!dest) {
+      return src.clone();
+    }
+
+    return dest.copy(src);
+  };
+
+  _exports.copyCopyable = copyCopyable;
+
+  var cloneClonable = function cloneClonable(src) {
+    return src && src.clone();
+  };
+
+  _exports.cloneClonable = cloneClonable;
+
+  function createType(typeDefinition) {
+    var mandatoryProperties = ["name", "default", "copy", "clone"];
+    var undefinedProperties = mandatoryProperties.filter(function (p) {
+      return !typeDefinition.hasOwnProperty(p);
+    });
+
+    if (undefinedProperties.length > 0) {
+      throw new Error("createType expects a type definition with the following properties: ".concat(undefinedProperties.join(", ")));
+    }
+
+    typeDefinition.isType = true;
+    return typeDefinition;
+  }
+  /**
+   * Standard types
+   */
+
+
+  var Types = {
+    Number: createType({
+      name: "Number",
+      default: 0,
+      copy: copyValue,
+      clone: cloneValue
+    }),
+    Boolean: createType({
+      name: "Boolean",
+      default: false,
+      copy: copyValue,
+      clone: cloneValue
+    }),
+    String: createType({
+      name: "String",
+      default: "",
+      copy: copyValue,
+      clone: cloneValue
+    }),
+    Array: createType({
+      name: "Array",
+      default: [],
+      copy: copyArray,
+      clone: cloneArray
+    }),
+    Ref: createType({
+      name: "Ref",
+      default: undefined,
+      copy: copyValue,
+      clone: cloneValue
+    }),
+    JSON: createType({
+      name: "JSON",
+      default: null,
+      copy: copyJSON,
+      clone: cloneJSON
+    })
+  };
+  _exports.Types = Types;
+
+  function generateId(length) {
+    var result = "";
+    var characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    var charactersLength = characters.length;
+
+    for (var i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+
+    return result;
+  }
+
+  function injectScript(src, onLoad) {
+    var script = document.createElement("script"); // @todo Use link to the ecsy-devtools repo?
+
+    script.src = src;
+    script.onload = onLoad;
+    (document.head || document.documentElement).appendChild(script);
+  }
+  /* global Peer */
+
+
+  function hookConsoleAndErrors(connection) {
+    var wrapFunctions = ["error", "warning", "log"];
+    wrapFunctions.forEach(function (key) {
+      if (typeof console[key] === "function") {
+        var fn = console[key].bind(console);
+
+        console[key] = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+
+          connection.send({
+            method: "console",
+            type: key,
+            args: JSON.stringify(args)
+          });
+          return fn.apply(null, args);
+        };
+      }
+    });
+    window.addEventListener("error", function (error) {
+      connection.send({
+        method: "error",
+        error: JSON.stringify({
+          message: error.error.message,
+          stack: error.error.stack
+        })
+      });
+    });
+  }
+
+  function includeRemoteIdHTML(remoteId) {
+    var infoDiv = document.createElement("div");
+    infoDiv.style.cssText = "\n    align-items: center;\n    background-color: #333;\n    color: #aaa;\n    display:flex;\n    font-family: Arial;\n    font-size: 1.1em;\n    height: 40px;\n    justify-content: center;\n    left: 0;\n    opacity: 0.9;\n    position: absolute;\n    right: 0;\n    text-align: center;\n    top: 0;\n  ";
+    infoDiv.innerHTML = "Open ECSY devtools to connect to this page using the code:&nbsp;<b style=\"color: #fff\">".concat(remoteId, "</b>&nbsp;<button onClick=\"generateNewCode()\">Generate new code</button>");
+    document.body.appendChild(infoDiv);
+    return infoDiv;
+  }
+
+  function enableRemoteDevtools(remoteId) {
+    if (!hasWindow) {
+      console.warn("Remote devtools not available outside the browser");
+      return;
+    }
+
+    window.generateNewCode = function () {
+      window.localStorage.clear();
+      remoteId = generateId(6);
+      window.localStorage.setItem("ecsyRemoteId", remoteId);
+      window.location.reload(false);
+    };
+
+    remoteId = remoteId || window.localStorage.getItem("ecsyRemoteId");
+
+    if (!remoteId) {
+      remoteId = generateId(6);
+      window.localStorage.setItem("ecsyRemoteId", remoteId);
+    }
+
+    var infoDiv = includeRemoteIdHTML(remoteId);
+    window.__ECSY_REMOTE_DEVTOOLS_INJECTED = true;
+    window.__ECSY_REMOTE_DEVTOOLS = {};
+    var Version = ""; // This is used to collect the worlds created before the communication is being established
+
+    var worldsBeforeLoading = [];
+
+    var onWorldCreated = function onWorldCreated(e) {
+      var world = e.detail.world;
+      Version = e.detail.version;
+      worldsBeforeLoading.push(world);
+    };
+
+    window.addEventListener("ecsy-world-created", onWorldCreated);
+
+    var onLoaded = function onLoaded() {
+      // var peer = new Peer(remoteId);
+      var peer = new Peer(remoteId, {
+        host: "peerjs.ecsy.io",
+        secure: true,
+        port: 443,
+        config: {
+          iceServers: [{
+            url: "stun:stun.l.google.com:19302"
+          }, {
+            url: "stun:stun1.l.google.com:19302"
+          }, {
+            url: "stun:stun2.l.google.com:19302"
+          }, {
+            url: "stun:stun3.l.google.com:19302"
+          }, {
+            url: "stun:stun4.l.google.com:19302"
+          }]
+        },
+        debug: 3
+      });
+      peer.on("open", function
+        /* id */
+      () {
+        peer.on("connection", function (connection) {
+          window.__ECSY_REMOTE_DEVTOOLS.connection = connection;
+          connection.on("open", function () {
+            // infoDiv.style.visibility = "hidden";
+            infoDiv.innerHTML = "Connected"; // Receive messages
+
+            connection.on("data", function (data) {
+              if (data.type === "init") {
+                var script = document.createElement("script");
+                script.setAttribute("type", "text/javascript");
+
+                script.onload = function () {
+                  script.parentNode.removeChild(script); // Once the script is injected we don't need to listen
+
+                  window.removeEventListener("ecsy-world-created", onWorldCreated);
+                  worldsBeforeLoading.forEach(function (world) {
+                    var event = new CustomEvent("ecsy-world-created", {
+                      detail: {
+                        world: world,
+                        version: Version
+                      }
+                    });
+                    window.dispatchEvent(event);
+                  });
+                };
+
+                script.innerHTML = data.script;
+                (document.head || document.documentElement).appendChild(script);
+                script.onload();
+                hookConsoleAndErrors(connection);
+              } else if (data.type === "executeScript") {
+                var value = eval(data.script);
+
+                if (data.returnEval) {
+                  connection.send({
+                    method: "evalReturn",
+                    value: value
+                  });
+                }
+              }
+            });
+          });
+        });
+      });
+    }; // Inject PeerJS script
+
+
+    injectScript("https://cdn.jsdelivr.net/npm/peerjs@0.3.20/dist/peer.min.js", onLoaded);
+  }
+
+  if (hasWindow) {
+    var urlParams = new URLSearchParams(window.location.search); // @todo Provide a way to disable it if needed
+
+    if (urlParams.has("enable-remote-devtools")) {
+      enableRemoteDevtools();
+    }
+  }
+});