@woosh/meep-engine 2.123.6 → 2.123.7

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.123.6",
+  "version": "2.123.7",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/clz32.d.ts

@@ -1,7 +1,6 @@
 /**
  * Count leading zeroes in a 32bit integer
- * @param {number} x
- * @returns {number}
+ * @deprecated use Math.clz32 directly
  */
-export function clz32(x: number): number;
+export const clz32: (x: number) => number;
 //# sourceMappingURL=clz32.d.ts.map

package/src/core/binary/clz32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clz32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/clz32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yBAHW,MAAM,GACJ,MAAM,CAiClB"}
+{"version":3,"file":"clz32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/clz32.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,0CAAgC"}

package/src/core/binary/clz32.js

@@ -1,37 +1,5 @@
 /**
  * Count leading zeroes in a 32bit integer
- * @param {number} x
- * @returns {number}
+ * @deprecated use Math.clz32 directly
  */
-export function clz32(x) {
-    if (x === 0) {
-        return 32;
-    }
-
-    let v = x >>> 0;
-    let result = 0;
-
-    // Binary search.
-    if ((v & 0xFFFF0000) === 0) {
-        v <<= 16;
-        result += 16;
-    }
-    if ((v & 0xFF000000) === 0) {
-        v <<= 8;
-        result += 8;
-    }
-    if ((v & 0xF0000000) === 0) {
-        v <<= 4;
-        result += 4;
-    }
-    if ((v & 0xC0000000) === 0) {
-        v <<= 2;
-        result += 2;
-    }
-
-    if ((v & 0x80000000) === 0) {
-        result += 1;
-    }
-
-    return result;
-}
+export const clz32 = Math.clz32;

package/src/core/binary/msb_32.d.ts

@@ -1,6 +1,5 @@
 /**
  * get most significant set bit
- * @see https://graphics.stanford.edu/~seander/bithacks.html
  * @param {number} x 32 bit integer
  * @returns {number} integer position of most significant bit
  */

package/src/core/binary/msb_32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,0BAHW,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0BAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/binary/msb_32.js

@@ -1,11 +1,8 @@
-import { clz32 } from "./clz32.js";
-
 /**
  * get most significant set bit
- * @see https://graphics.stanford.edu/~seander/bithacks.html
  * @param {number} x 32 bit integer
  * @returns {number} integer position of most significant bit
  */
 export function msb_32(x) {
-    return 31 - clz32(x);
+    return 31 - Math.clz32(x);
 }

package/src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_hierarchy_radix.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.js"],"names":[],"mappings":"AA4MA;;;;;;;;GAQG;AACH,gDAPW,GAAG,cACH,MAAM,EAAE,GAAC,WAAW,uBACpB,MAAM,EAAE,cACR,MAAM,kBACN,MAAM,EAAE,GACN,MAAM,CAqElB"}
+{"version":3,"file":"ebvh_build_hierarchy_radix.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.js"],"names":[],"mappings":"AA2MA;;;;;;;;GAQG;AACH,gDAPW,GAAG,cACH,MAAM,EAAE,GAAC,WAAW,uBACpB,MAAM,EAAE,cACR,MAAM,kBACN,MAAM,EAAE,GACN,MAAM,CAqElB"}

package/src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.js

@@ -1,5 +1,4 @@
 import { assert } from "../../assert.js";
-import { clz32 } from "../../binary/clz32.js";
 import { clamp } from "../../math/clamp.js";
 import { NULL_NODE } from "./BVH.js";
 import { ebvh_update_hierarchy_bounds } from "./ebvh_update_hierarchy_bounds.js";
@@ -30,7 +29,7 @@ function find_split(
     // Calculate the number of highest bits that are the same
     // for all objects, using the count-leading-zeros intrinsic.
 
-    const commonPrefix = clz32(firstCode ^ lastCode);
+    const commonPrefix = Math.clz32(firstCode ^ lastCode);
 
     // Use binary search to find where the next bit differs.
     // Specifically, we are looking for the highest object that
@@ -45,7 +44,7 @@ function find_split(
 
         if (newSplit < last) {
             const splitCode = sortedMortonCodes[newSplit];
-            const splitPrefix = clz32(firstCode ^ splitCode);
+            const splitPrefix = Math.clz32(firstCode ^ splitCode);
             if (splitPrefix > commonPrefix) {
                 split = newSplit; // accept proposal
             }
@@ -75,10 +74,10 @@ function GetLongestCommonPrefix(indexA, indexB, elementCount, mortonCodes) {
         const mortonCodeA = mortonCodes[indexA];
         const mortonCodeB = mortonCodes[indexB];
         if (mortonCodeA !== mortonCodeB) {
-            return clz32(mortonCodeA ^ mortonCodeB);
+            return Math.clz32(mortonCodeA ^ mortonCodeB);
         } else {
             // TODO: Technically this should be primitive ID
-            return clz32(indexA ^ indexB) + 31;
+            return Math.clz32(indexA ^ indexB) + 31;
         }
     }
 }
@@ -140,12 +139,12 @@ function determineRange(output, sortedMortonCodes, numTriangles, idx) {
     let common_prefix_with_left = 0;
     let common_prefix_with_right = 0;
 
-    common_prefix_with_right = clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx + 1]);
+    common_prefix_with_right = Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx + 1]);
 
     if (idx === 0) {
         common_prefix_with_left = -1;
     } else {
-        common_prefix_with_left = clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - 1]);
+        common_prefix_with_left = Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - 1]);
 
     }
 
@@ -157,13 +156,13 @@ function determineRange(output, sortedMortonCodes, numTriangles, idx) {
         min_prefix_range = -1;
 
     } else {
-        min_prefix_range = clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - direction]);
+        min_prefix_range = Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - direction]);
     }
 
     let lmax = 2;
     let next_key = idx + lmax * direction;
 
-    while ((next_key >= 0) && (next_key < numTriangles) && (clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[next_key]) > min_prefix_range)) {
+    while ((next_key >= 0) && (next_key < numTriangles) && (Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[next_key]) > min_prefix_range)) {
         lmax *= 2;
         next_key = idx + lmax * direction;
     }
@@ -176,7 +175,7 @@ function determineRange(output, sortedMortonCodes, numTriangles, idx) {
 
         if (new_val >= 0 && new_val < numTriangles) {
             const Code = sortedMortonCodes[new_val];
-            const Prefix = clz32(sortedMortonCodes[idx] ^ Code);
+            const Prefix = Math.clz32(sortedMortonCodes[idx] ^ Code);
             if (Prefix > min_prefix_range) {
                 l = l + lmax;
             }

package/src/core/collection/queue/Deque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,mBAFa,CAAC;IAkCV;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IAuFD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAeC;IAED;;;OAGG;IACH,QAFa,MAAM,CAalB;IA6BD;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAYnB;IA4BD;;;;OAIG;IACH,OAHW,CAAC,GACC,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;OAGG;IACH,WAFW,CAAC,QAOX;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAmBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL;;OAEG;IACH,gBAAoB;IACpB;;OAEG;IACH,uBAAoB;IACpB;;OAEG;IACH,eAAmB;IAEnB;;OAEG;IACH,sBAAmB;IAlCf;;;OAGG;IACH,qBAFa,SAAS,CAAC,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}
+{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,mBAFa,CAAC;IAkCV;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IAuFD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAiBhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAalB;IA6BD;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAYnB;IA4BD;;;;OAIG;IACH,OAHW,CAAC,GACC,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAOhB;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAmBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL;;OAEG;IACH,gBAAoB;IACpB;;OAEG;IACH,uBAAoB;IACpB;;OAEG;IACH,eAAmB;IAEnB;;OAEG;IACH,iBA1GiB,IAAI,CA0GF;IAlCf;;;OAGG;IACH,qBAFa,SAAS,CAAC,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}

package/src/core/collection/queue/Deque.js

@@ -20,7 +20,9 @@ const GROWTH_FACTOR = 2;
 const EMPTY_ARRAY = new Array(0);
 
 /**
- * Double-ended queue backed by an array
+ * Queue data structure, first-in-first-out (FIFO).
+ * Double-ended queue backed by an array.
+ * The fact that it's double-ended means you can add and remove from both ends.
  * @template T
  */
 export class Deque {
@@ -162,6 +164,11 @@ export class Deque {
         return this.#status === STATUS_EMPTY;
     }
 
+    /**
+     * Clear data from the queue.
+     * Makes the queue empty.
+     * @returns {void}
+     */
     clear() {
         if (this.#status !== STATUS_EMPTY) {
             let cursor = this.#head;
@@ -309,6 +316,7 @@ export class Deque {
     /**
      * Add element at the end of the queue
      * @param {T} e
+     * @returns {void}
      */
     addLast(e) {
         this.#check_and_expand();
@@ -374,7 +382,7 @@ export class Deque {
         const size = this.size();
 
         for (let i = 0; i < size; i++) {
-            result[i] = this.getElementByIndex(i);
+            result[result_offset + i] = this.getElementByIndex(i);
         }
 
         return result;

package/src/core/collection/queue/Queue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Alias
+ * @type {Deque}
+ */
+export const Queue: Deque<any>;
+import { Deque } from "./Deque.js";
+//# sourceMappingURL=Queue.d.ts.map

package/src/core/collection/queue/Queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queue.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Queue.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,+BAA2B;sBANL,YAAY"}

package/src/core/collection/queue/Queue.js

@@ -0,0 +1,7 @@
+import { Deque } from "./Deque.js";
+
+/**
+ * Alias
+ * @type {Deque}
+ */
+export const Queue = Deque;

package/src/engine/ecs/Entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/Entity.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA2aI;;;;;OAKG;IACH,+BAJW,MAAM,WACN,sBAAsB,GACpB,MAAM,CAgBlB;IA7bD;;;OAGG;IACH,oBAFU,eAAe,CAES;IAWlC;;;OAGG;IACH,UAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,UAFa,MAAM,CAIlB;IAmBD;;;OAGG;IACH,kBAFW,MAAM,EAIhB;IAfD;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAWD;;;;OAIG;IACH,2BAAgB;IAQhB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;OAGG;IACH,OAFU,WAAW,GAAC,MAAM,CAEN;IAEtB;;;;OAIG;IACH,yBAAgB;IAEhB;;OAEG;IACH;QACI;;WAEG;;MAEL;IAUF;;;OAGG;IACH,eAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,WAAW,GAChB,OAAO,CAMnB;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;OAEG;IACH,4BAQC;IAED;;;OAGG;IACH,aAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,IAJa,CAAC,qBACH,CAAC,GACC,MAAM,CAuBlB;IAED;;;;OAIG;IACH,aAJa,CAAC,SACH,CAAC,GACC,OAAO,CAInB;IAED;;;;OAIG;IACH,aAJa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,GAAC,IAAI,CAclB;IAED;;;;;OAKG;IACH,iBAJa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,CAUb;IAED;;;;OAIG;IACH,kCAFa,GAAC,GAAC,IAAI,CA0BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,UACN,GAAC,QAQX;IAED;;;OAGG;IACH,wBAFW,MAAM,gBAiBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,gCAEN,GAAC,GACC,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,gCAEN,GAAC,GACC,MAAM,CAyBlB;IAED;;;OAGG;IACH,WAFa,OAAO,CAwBnB;IAED;;;;OAIG;IACH,eAFW,sBAAsB,GADpB,MAAM,CAyDlB;IAyBL;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;;gCA1f+B,sBAAsB;4BAD1B,kBAAkB;mBAF3B,oCAAoC"}
+{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/Entity.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IA2aI;;;;;OAKG;IACH,+BAJW,MAAM,WACN,sBAAsB,GACpB,MAAM,CAgBlB;IA7bD;;;OAGG;IACH,oBAFU,eAAe,CAES;IAWlC;;;OAGG;IACH,UAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,UAFa,MAAM,CAIlB;IAmBD;;;OAGG;IACH,kBAFW,MAAM,EAIhB;IAfD;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAWD;;;;OAIG;IACH,2BAAgB;IAQhB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;OAGG;IACH,OAFU,WAAW,GAAC,MAAM,CAEN;IAEtB;;;;OAIG;IACH,yBAAgB;IAEhB;;OAEG;IACH;QACI;;WAEG;;MAEL;IAUF;;;OAGG;IACH,eAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,WAAW,GAChB,OAAO,CAMnB;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;OAEG;IACH,4BAQC;IAED;;;OAGG;IACH,aAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,IAJa,CAAC,qBACH,CAAC,GACC,MAAM,CAuBlB;IAED;;;;OAIG;IACH,aAJa,CAAC,SACH,CAAC,GACC,OAAO,CAInB;IAED;;;;OAIG;IACH,aAJa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,GAAC,IAAI,CAclB;IAED;;;;;OAKG;IACH,iBAJa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,CAUb;IAED;;;;OAIG;IACH,kCAFa,GAAC,GAAC,IAAI,CA0BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,UACN,GAAC,QAQX;IAED;;;OAGG;IACH,wBAFW,MAAM,gBAiBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,gCAEN,GAAC,GACC,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,gCAEN,GAAC,GACC,MAAM,CAyBlB;IAED;;;OAGG;IACH,WAFa,OAAO,CAwBnB;IAED;;;;OAIG;IACH,eAFW,sBAAsB,GADpB,MAAM,CAyDlB;IAyBL;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;;gCAxe+B,sBAAsB;4BAD1B,kBAAkB;mBAF3B,oCAAoC"}

package/src/engine/ecs/Entity.js

@@ -19,42 +19,24 @@ const DEFAULT_FLAGS =
  *
  *
  * @example
- * // Create a new entity (initially has no components).
  * const entity = new Entity();
  *
- * // Define some components (simple data containers).
- * class PositionComponent {
- *   constructor(x, y) {
- *     this.x = x;
- *     this.y = y;
- *   }
- * }
- *
- * class VelocityComponent {
- *   constructor(x, y) {
- *     this.x = x;
- *     this.y = y;
- *   }
- * }
- *
  * // Add components to the entity.
- * entity.add(new PositionComponent(10, 20));
- * entity.add(new VelocityComponent(1, 2));
-
+ * entity.add(new Position(10, 20));
+ * entity.add(new Velocity(1, 2));
  *
  * // Get a component (would return null if the entity doesn't have it).
- * const position = entity.getComponent(PositionComponent); // { x:10, y:20 }
+ * const position = entity.getComponent(Position); // { x:10, y:20 }
  *
  * // Remove a component.
- * entity.removeComponent(VelocityComponent);
+ * entity.removeComponent(Velocity);
  *
  * // To actually use the entity in a game, you need to build it using an EntityComponentDataset.
  * const dataset = new EntityComponentDataset(); // You would typically have one already
  *
- * entity.build(dataset);
- * // Now the entity and its components are managed by the ECS.
+ * entity.build(dataset); // add entity with the components to the scene
  *
- * // later, you can destroy the entity:
+ * // ... Once entity is no longer needed, we destroy it
  * entity.destroy();
  *
  * @author Alex Goldring

package/src/engine/ecs/EntityComponentDataset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityComponentDataset.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityComponentDataset.js"],"names":[],"mappings":"AAyHA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAEI;;;;OAIG;IACH,wBAA+B;IAE/B;;;;;OAKG;IACH,yBAAsC;IAEtC;;;;;;;;;OASG;IACH,2BAAkC;IAElC;;;;;OAKG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAgC;IAEhC;;;;OAIG;IACH,2BAAuB;IAEvB;;;OAGG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgB;IAEhB;;;;;;;OAOG;IACH,mBAAe;IAEf;;;OAGG;IACH,0BAFU,MAAM,CAAC,MAAM,CAAC,CAEO;IAE/B;;;OAGG;IACH,0BAFU,MAAM,CAEe;IAG/B;;;;OAIG;IACH,+BAA4B;IAE5B;;;;OAIG;IACH,kCAA+B;IAE/B;;;OAGG;IACH,kBAAe;IAGf;;;;;;OAMG;IACH,iBALa,CAAC,EAAE,CAAC,UACN,GAAG,iBACH,CAAC,GACC,OAAO,CAAC,CAAC,CAAC,CAoCtB;IAED;;;;;OAKG;IACH,sBAJW,cAAc,cACd,OAAO,GACL,OAAO,CAqDnB;IAED;;;;;OAKG;IACH,yBAJW,cAAc,cACd,OAAO,GACL,OAAO,CAuDnB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,yBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,oBACN,EAAE,SAmCZ;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,EAAE,CAyBd;IAED;;;;;OAKG;IACH,yBAJW,KAAK,EAAE,GACL,IAAI,CA0LhB;IAED;;;;OAIG;IACH,mCAHW,KAAK,EAAE,GACL,OAAO,CAenB;IAED;;;;;OAKG;IACH,gCAHW,KAAK,WAAS,GACb,OAAO,CASlB;IAED;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAInB;IAED;;;;OAIG;IACH,kCAHW,KAAK,EAAE,GACL,OAAO,CAgBnB;IAED;;;;OAIG;IACH,4BAHW,KAAK,WAAS,GACZ,OAAO,CAanB;IAED;;;;OAIG;IACH,8BAHW,KAAK,GACH,OAAO,CAkBnB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAiBhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;OAGG;IACH,2BAiBC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,gCAHW,MAAM,QAShB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,qCAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;OAIG;IACH,8BAFW,MAAM,EAAE,QAQlB;IAED;;;;OAIG;IACH,uCAHW,MAAM,SACN,KAAK,QAUf;IAED;;;;OAIG;IACH,8CAHW,MAAM,kBACN,MAAM,QAiBhB;IAED;;;;;;OAMG;IACH,mDAgBC;IAED;;;;OAIG;IACH,iCAHW,WAAS,KAAK,GACZ,MAAM,CAalB;IAED;;;;OAIG;IACH,sBAJa,CAAC,SACH,CAAC,GACC,MAAM,CAUlB;IAED;;;;OAIG;IACH,gBAJa,CAAC,iBACH,KAAK,CAAC,CAAC,CAAC,GACN;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,CAAC,CAAA;KAAC,CAiBxC;IAED;;;;;;OAMG;IACH,qBAJa,CAAC,aACH,MAAM,qBACN,CAAC,QAuBX;IAED;;;;;OAKG;IACH,4BALa,CAAC,eACH,MAAM,kBACN,MAAM,qBACN,CAAC,QA4BX;IAED;;;;;OAKG;IACH,oBALa,CAAC,eACH,MAAM,kBACN,MAAM,GACJ,CAAC,GAAC,SAAS,CASvB;IAED;;;;;;OAMG;IACH,aALa,CAAC,eACH,MAAM,SACN,KAAK,CAAC,CAAC,CAAC,GACN,OAAO,CAInB;IAED;;;;;OAKG;IACH,aALa,CAAC,aACH,MAAM,SACN,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,GAAC,SAAS,CAevB;IAED;;;;;;;OAOG;IACH,iBANa,CAAC,eACH,MAAM,SACN,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,CAWb;IAED;;;;;;OAMG;IACH,oDAJW,KAAK,gCAEL,GAAC,QAiBX;IAED;;;;;;;;;;;;OAYG;IACH,0CAHW,IAAS,IAAO,EAAP,OAAO,KAAE,OAAO,YACzB,MAAM,QAyEhB;IAED;;;;;;OAMG;IACH,4EAwDC;IAED;;;OAGG;IACH,wBAFa,SAAS,CAAC,MAAM,CAAC,CAU7B;IAED;;;;;OAKG;IACH,mBALa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,0BAER,GAAC,QAaX;IAED;;;;;OAKG;IACH,8CAJW,MAAM,+BAEN,GAAC,QASX;IAED;;;;;;OAMG;IACH,+CAyBC;IAED;;;;;OAKG;IACH,iDAsBC;IAED;;;;OAIG;IACH,wCAgCC;IAED;;;;OAIG;IACH,0CA2BC;IAED;;;;;OAKG;IACH,kCAJW,MAAM,gCAEN,GAAC,QAoBX;IAED;;;;;;OAMG;IACH,+BALW,MAAM,gCAEN,GAAC,GACC,OAAO,CA+BnB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,aACN,MAAM,YACN,SAAU,YACV,GAAC,QA8BX;IAED;;;;;;;;OAQG;IACH,kCAPW,MAAM,aACN,MAAM,gCAEN,GAAC,GAEC,OAAO,CAwCnB;IAED;;;;;OAKG;IACH,2DAeC;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,OAAO,CAenB;IAED;;OAEG;IACH,cAMC;IAED;;;OAGG;IACH,iBAYC;IAED;;;;OAIG;IACH,wBAJa,CAAC,aACH,MAAM,GACJ,IAAI,cAAU,KAAK,CAAC,CAAC,CAAC,CAYlC;IAED;;;;OAIG;IACH,mBAFW,sBAAsB,iCA6DhC;IAED;;;;OAIG;IACH,+EAiDC;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,8CAFW,GAAC,QAgBX;IAGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CANxD;mBA15DkB,oCAAoC"}
+{"version":3,"file":"EntityComponentDataset.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityComponentDataset.js"],"names":[],"mappings":"AAyHA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAEI;;;;OAIG;IACH,wBAA+B;IAE/B;;;;;OAKG;IACH,yBAAsC;IAEtC;;;;;;;;;OASG;IACH,2BAAkC;IAElC;;;;;OAKG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAgC;IAEhC;;;;OAIG;IACH,2BAAuB;IAEvB;;;OAGG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgB;IAEhB;;;;;;;OAOG;IACH,mBAAe;IAEf;;;OAGG;IACH,0BAFU,MAAM,CAAC,MAAM,CAAC,CAEO;IAE/B;;;OAGG;IACH,0BAFU,MAAM,CAEe;IAG/B;;;;OAIG;IACH,+BAA4B;IAE5B;;;;OAIG;IACH,kCAA+B;IAE/B;;;OAGG;IACH,kBAAe;IAGf;;;;;;OAMG;IACH,iBALa,CAAC,EAAE,CAAC,UACN,GAAG,kBACH,CAAC,GACC,OAAO,CAAC,CAAC,CAAC,CAoCtB;IAED;;;;;OAKG;IACH,sBAJW,cAAc,cACd,OAAO,GACL,OAAO,CAqDnB;IAED;;;;;OAKG;IACH,yBAJW,cAAc,cACd,OAAO,GACL,OAAO,CAuDnB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,yBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,qBACN,EAAE,SAmCZ;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,EAAE,CAyBd;IAED;;;;;OAKG;IACH,yBAJW,KAAK,EAAE,GACL,IAAI,CA0LhB;IAED;;;;OAIG;IACH,mCAHW,KAAK,EAAE,GACL,OAAO,CAenB;IAED;;;;;OAKG;IACH,gCAHW,KAAK,WAAS,GACb,OAAO,CASlB;IAED;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAInB;IAED;;;;OAIG;IACH,kCAHW,KAAK,EAAE,GACL,OAAO,CAgBnB;IAED;;;;OAIG;IACH,4BAHW,KAAK,WAAS,GACZ,OAAO,CAanB;IAED;;;;OAIG;IACH,8BAHW,KAAK,GACH,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,2BAiBC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAEJ,IAAI,CAQhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,qCAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAQhB;IAED;;;;;OAKG;IACH,qCAJW,MAAM,SACN,KAAK,GACH,IAAI,CAUhB;IAED;;;;;OAKG;IACH,4CAJW,MAAM,mBACN,MAAM,GACJ,IAAI,CAiBhB;IAED;;;;;;;OAOG;IACH,mDAgBC;IAED;;;;OAIG;IACH,iCAHW,WAAS,KAAK,GACZ,MAAM,CAalB;IAED;;;;OAIG;IACH,sBAJa,CAAC,SACH,CAAC,GACC,MAAM,CAUlB;IAED;;;;OAIG;IACH,gBAJa,CAAC,kBACH,KAAK,CAAC,CAAC,CAAC,GACN;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,CAAC,CAAA;KAAC,CAiBxC;IAED;;;;;;;OAOG;IACH,qBALa,CAAC,aACH,MAAM,sBACN,CAAC,GACC,IAAI,CAqBhB;IAED;;;;;;OAMG;IACH,4BANa,CAAC,aACH,MAAM,mBACN,MAAM,sBACN,CAAC,GACC,IAAI,CA4BhB;IAED;;;;;OAKG;IACH,oBALa,CAAC,aACH,MAAM,mBACN,MAAM,GACJ,CAAC,GAAC,SAAS,CASvB;IAED;;;;;;OAMG;IACH,aALa,CAAC,aACH,MAAM,SACN,KAAK,CAAC,CAAC,CAAC,GACN,OAAO,CAInB;IAED;;;;;OAKG;IACH,aALa,CAAC,aACH,MAAM,SACN,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,GAAC,SAAS,CAevB;IAED;;;;;;;OAOG;IACH,iBANa,CAAC,aACH,MAAM,SACN,KAAK,CAAC,CAAC,CAAC,GACN,CAAC,CAWb;IAED;;;;;;;OAOG;IACH,sDALW,KAAK,gCAEL,GAAC,GACC,IAAI,CAiBhB;IAED;;;;;;;;;;;;;OAaG;IACH,0CAJW,IAAS,IAAO,EAAP,OAAO,KAAE,OAAO,YACzB,MAAM,GACJ,IAAI,CAyEhB;IAED;;;;;;;OAOG;IACH,uEAFa,IAAI,CA0DhB;IAkBD;;;;;;OAMG;IACH,mBANa,CAAC,SACH,KAAK,CAAC,CAAC,CAAC,0BAER,GAAC,GACC,IAAI,CAahB;IAED;;;;;;OAMG;IACH,2CALW,MAAM,+BAEN,GAAC,GACC,IAAI,CAShB;IAED;;;;;;;OAOG;IACH,+CAyBC;IAED;;;;;;OAMG;IACH,iDAsBC;IAED;;;;;OAKG;IACH,wCAgCC;IAED;;;;;OAKG;IACH,0CA2BC;IAED;;;;;;OAMG;IACH,kCALW,MAAM,gCAEN,GAAC,GACC,IAAI,CAoBhB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,gCAEN,GAAC,GACC,OAAO,CA+BnB;IAED;;;;;;;OAOG;IACH,+BANW,MAAM,cACN,MAAM,YACN,SAAU,YACV,GAAC,GACC,IAAI,CA8BhB;IAED;;;;;;;;OAQG;IACH,kCAPW,MAAM,cACN,MAAM,gCAEN,GAAC,GAEC,OAAO,CAwCnB;IAED;;;;;;OAMG;IACH,sDAFa,IAAI,CAiBhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,OAAO,CAenB;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,YAFa,IAAI,CAchB;IAED;;;;OAIG;IACH,wBAJa,CAAC,cACH,MAAM,GACJ,IAAI,cAAU,KAAK,CAAC,CAAC,CAAC,CAiBlC;IAED;;;;;OAKG;IACH,mBAHW,sBAAsB,6BACpB,IAAI,CA6DhB;IAED;;;;;OAKG;IACH,2EAFa,IAAI,CAgDhB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,8CAHW,GAAC,GACC,IAAI,CAgBhB;IAGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;IAGzD,4BAvlBgB,SAAS,CAAC,MAAM,CAAC,CAulBoB;IAzlBjD;;;OAGG;IACH,qBAFY,SAAS,CAAC,MAAM,CAAC,CAY5B;CAkkBJ;mBAv7DkB,oCAAoC"}

package/src/engine/ecs/EntityComponentDataset.js

@@ -130,13 +130,12 @@ const scratch_args = [];
  *
  * @example
  *   const ecd = new EntityComponentDataset();
- *   // create an entity
- *   const entityId = ecd.createEntity();
  *
- *   // add a component to your entity
- *   ecd.addComponentToEntity(entityId, myComponentInstance);
+ *   const entityId = ecd.createEntity(); // create an entity
  *
- *   // destroy the entity
+ *   ecd.addComponentToEntity(entityId, myComponentInstance); // add a component to your entity
+ *
+ *   // ... once no longer needed, destroy the entity
  *   ecd.removeEntity(entityId);
  *
  * @see https://en.wikipedia.org/wiki/Entity_component_system
@@ -255,16 +254,16 @@ export class EntityComponentDataset {
      * returns a promise of a component instance based on a given type
      * @template T, R
      * @param {int} entity
-     * @param {T} componentType
+     * @param {T} component_type
      * @returns {Promise<R>}
      */
-    promiseComponent(entity, componentType) {
+    promiseComponent(entity, component_type) {
 
         assert.ok(this.entityExists(entity), `Entity ${entity} doesn't exist`);
 
         const self = this;
         return new Promise(function (resolve, reject) {
-            const component = self.getComponent(entity, componentType);
+            const component = self.getComponent(entity, component_type);
 
             if (component !== undefined) {
                 resolve(component);
@@ -274,7 +273,7 @@ export class EntityComponentDataset {
             function handler(event, entity) {
                 const componentClass = event.klass;
 
-                if (componentClass === componentType) {
+                if (componentClass === component_type) {
                     //found the right one
 
                     const instance = event.instance;
@@ -433,18 +432,18 @@ export class EntityComponentDataset {
     /**
      * Convenience method for retrieving a collection of components for a given entity
      * @param {number} entity ID of the entity
-     * @param {[]} componentClasses Classes of components to extract
+     * @param {[]} component_classes Classes of components to extract
      * @returns {Array}
      */
-    getComponents(entity, componentClasses) {
+    getComponents(entity, component_classes) {
         assert.ok(this.entityExists(entity), `Entity ${entity} doesn't exist`);
 
-        assert.notEqual(componentClasses, null, "componentClasses is null");
-        assert.notEqual(componentClasses, undefined, "componentClasses is undefined");
-        assert.isArray(componentClasses, "componentClasses");
+        assert.notNull(component_classes, "component_classes");
+        assert.defined(component_classes, "component_classes");
+        assert.isArray(component_classes, "component_classes");
         //assert.notOk(componentClasses.some((c, i) => componentClasses.indexOf(c) !== i), 'componentClasses contains duplicates');
 
-        const resultLength = componentClasses.length;
+        const resultLength = component_classes.length;
 
         const result = new Array(resultLength);
 
@@ -457,7 +456,7 @@ export class EntityComponentDataset {
 
             const componentType = this.componentTypeMap[componentIndex];
 
-            const resultIndex = componentClasses.indexOf(componentType);
+            const resultIndex = component_classes.indexOf(componentType);
 
             if (resultIndex === -1) {
                 // not requested, skip
@@ -799,8 +798,11 @@ export class EntityComponentDataset {
     /**
      *
      * @param {number} min_size
+     * @returns {void}
      */
     enlargeGenerationTable(min_size) {
+        assert.isNonNegativeInteger(min_size, 'min_size');
+
         const old_generation_table_size = this.entityGeneration.length;
 
         const new_size = max3(
@@ -832,6 +834,7 @@ export class EntityComponentDataset {
     /**
      * @private
      * @param {number} entity_id
+     * @returns {void}
      */
     createEntityUnsafe(entity_id) {
         this.entityOccupancy.set(entity_id, true);
@@ -868,6 +871,7 @@ export class EntityComponentDataset {
      *
      * @param {number} entity_id
      * @throws {Error} if entity index is already in use
+     * @returns {void}
      */
     createEntitySpecific(entity_id) {
         if (this.entityExists(entity_id)) {
@@ -947,76 +951,80 @@ export class EntityComponentDataset {
     /**
      * Convenience method for removal of multiple entities
      * Works the same as {@link removeEntity} but for multiple elements
-     * @param {number[]} entityIndices
+     * @param {number[]} entity_ids
+     * @returns {void}
      */
-    removeEntities(entityIndices) {
-        const length = entityIndices.length;
+    removeEntities(entity_ids) {
+        const length = entity_ids.length;
         for (let i = 0; i < length; i++) {
-            const entityIndex = entityIndices[i];
+            const entityIndex = entity_ids[i];
             this.removeEntity(entityIndex);
         }
     }
 
     /**
      *
-     * @param {number} entityIndex
+     * @param {number} entity_id
      * @param {Class} klass
+     * @returns {void}
      */
-    removeComponentFromEntity(entityIndex, klass) {
-        const componentTypeIndex = this.componentTypeMap.indexOf(klass);
+    removeComponentFromEntity(entity_id, klass) {
+        const component_index = this.componentTypeMap.indexOf(klass);
 
-        if (componentTypeIndex === -1) {
+        if (component_index === -1) {
             throw new Error(`Component class not found in this dataset`);
         }
 
-        this.removeComponentFromEntityByIndex(entityIndex, componentTypeIndex);
+        this.removeComponentFromEntityByIndex(entity_id, component_index);
     }
 
     /**
      *
-     * @param {number} entityIndex
-     * @param {number} componentIndex
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {void}
      */
-    removeComponentFromEntityByIndex(entityIndex, componentIndex) {
-        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+    removeComponentFromEntityByIndex(entity_id, component_index) {
+        assert.ok(this.entityExists(entity_id), `entity ${entity_id} does not exist`);
+        assert.ok(this.componentIndexExists(component_index), `componentIndex ${component_index} is out of bounds`);
 
         //check if component exists
-        const componentOccupancyIndex = entityIndex * this.componentTypeCount + componentIndex;
+        const componentOccupancyIndex = entity_id * this.componentTypeCount + component_index;
         const exists = this.componentOccupancy.get(componentOccupancyIndex);
 
         if (!exists) {
             //nothing to remove
-            console.warn(`Entity ${entityIndex} does't have a component with index ${componentIndex}`);
+            console.warn(`Entity ${entity_id} doesn't have a component with index ${component_index}`);
             return;
         }
 
-        this.removeComponentFromEntityByIndex_Unchecked(entityIndex, componentIndex, componentOccupancyIndex);
+        this.removeComponentFromEntityByIndex_Unchecked(entity_id, component_index, componentOccupancyIndex);
     }
 
     /**
      * This method doesn't perform any checks, make sure you understand what you are doing when using it
      * @private
-     * @param {number} entityIndex
-     * @param {number} componentIndex
-     * @param {number} componentOccupancyIndex
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @param {number} component_occupancy_index
+     * @returns {void}
      */
-    removeComponentFromEntityByIndex_Unchecked(entityIndex, componentIndex, componentOccupancyIndex) {
-        this.processObservers_ComponentRemoved(entityIndex, componentIndex);
+    removeComponentFromEntityByIndex_Unchecked(entity_id, component_index, component_occupancy_index) {
+        this.processObservers_ComponentRemoved(entity_id, component_index);
 
-        const componentInstance = this.components[componentIndex][entityIndex];
+        const componentInstance = this.components[component_index][entity_id];
 
         //remove component from record
-        delete this.components[componentIndex][entityIndex];
+        delete this.components[component_index][entity_id];
 
         //clear occupancy bit
-        this.componentOccupancy.clear(componentOccupancyIndex);
+        this.componentOccupancy.clear(component_occupancy_index);
 
         //dispatch events
-        const componentClass = this.componentTypeMap[componentIndex];
+        const componentClass = this.componentTypeMap[component_index];
 
         //dispatch event to components
-        this.sendEvent(entityIndex, EventType.ComponentRemoved, { klass: componentClass, instance: componentInstance });
+        this.sendEvent(entity_id, EventType.ComponentRemoved, { klass: componentClass, instance: componentInstance });
     }
 
     /**
@@ -1054,14 +1062,14 @@ export class EntityComponentDataset {
 
     /**
      * @template T
-     * @param {Class<T>} componentType
+     * @param {Class<T>} component_type
      * @returns {{entity:number, component:T}}
      */
-    getAnyComponent(componentType) {
+    getAnyComponent(component_type) {
         let entity = -1;
         let component = null;
 
-        this.traverseComponents(componentType, (c, i) => {
+        this.traverseComponents(component_type, (c, i) => {
             entity = i;
             component = c;
 
@@ -1079,89 +1087,89 @@ export class EntityComponentDataset {
      * Associate a component with a particular entity
      * @template C
      * @param {number} entity_id
-     * @param {C} componentInstance
+     * @param {C} component_instance
+     * @returns {void}
      */
-    addComponentToEntity(entity_id, componentInstance) {
+    addComponentToEntity(entity_id, component_instance) {
 
-        assert.notNull(componentInstance, "componentInstance");
+        assert.notNull(component_instance, "componentInstance");
 
-        assert.defined(componentInstance, "componentInstance");
+        assert.defined(component_instance, "componentInstance");
 
         /**
          *
          * @type {Class<C>}
          */
-        const klass = componentInstance.constructor;
+        const klass = component_instance.constructor;
 
         const componentTypeIndex = this.__type_to_index_map.get(klass);
 
         if (typeof componentTypeIndex !== "number") {
-
-
-            throw new Error(`Component class not found in this dataset for componentInstance ${stringifyComponent(componentInstance)}`);
+            throw new Error(`Component class not found in this dataset for component_instance ${stringifyComponent(component_instance)}`);
         }
 
-        this.addComponentToEntityByIndex(entity_id, componentTypeIndex, componentInstance);
+        this.addComponentToEntityByIndex(entity_id, componentTypeIndex, component_instance);
     }
 
     /**
      * @template C
-     * @param {number} entityIndex
-     * @param {number} componentIndex
-     * @param {C} componentInstance
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @param {C} component_instance
+     * @returns {void}
      */
-    addComponentToEntityByIndex(entityIndex, componentIndex, componentInstance) {
+    addComponentToEntityByIndex(entity_id, component_index, component_instance) {
 
-        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+        assert.ok(this.entityExists(entity_id), `entity ${entity_id} does not exist`);
+        assert.ok(this.componentIndexExists(component_index), `component_index ${component_index} is out of bounds`);
 
-        assert.notEqual(componentInstance, undefined, "componentInstance is undefined");
+        assert.defined(component_instance, "component_instance");
 
-        assert.equal(this.getComponentByIndex(entityIndex, componentIndex), undefined, `entity ${entityIndex} already has component ${componentIndex}`);
+        assert.equal(this.getComponentByIndex(entity_id, component_index), undefined, `entity ${entity_id} already has component ${component_index}`);
 
 
-        const componentOccupancyIndex = entityIndex * this.componentTypeCount + componentIndex;
+        const componentOccupancyIndex = entity_id * this.componentTypeCount + component_index;
 
         //record component occupancy
         this.componentOccupancy.set(componentOccupancyIndex, true);
 
         //inset component instance into component dataset
-        this.components[componentIndex][entityIndex] = componentInstance;
+        this.components[component_index][entity_id] = component_instance;
 
         //process observers
-        this.processObservers_ComponentAdded(entityIndex, componentIndex);
+        this.processObservers_ComponentAdded(entity_id, component_index);
 
         //dispatch events
-        const componentClass = this.componentTypeMap[componentIndex];
+        const componentClass = this.componentTypeMap[component_index];
 
         //dispatch event to components
-        this.sendEvent(entityIndex, EventType.ComponentAdded, { klass: componentClass, instance: componentInstance });
+        this.sendEvent(entity_id, EventType.ComponentAdded, { klass: componentClass, instance: component_instance });
     }
 
     /**
      * @template C
-     * @param {number} entityIndex
-     * @param {number} componentIndex
+     * @param {number} entity_id
+     * @param {number} component_index
      * @returns {C|undefined}
      */
-    getComponentByIndex(entityIndex, componentIndex) {
+    getComponentByIndex(entity_id, component_index) {
 
-        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+        assert.ok(this.entityExists(entity_id), `entity ${entity_id} does not exist`);
+        assert.ok(this.componentIndexExists(component_index), `component_index ${component_index} is out of bounds`);
 
 
-        return this.components[componentIndex][entityIndex];
+        return this.components[component_index][entity_id];
     }
 
     /**
-     * Whether or not a given entity has a component of the specified class attached
+     * Whether a given entity has a component of the specified class attached
      * @template C
-     * @param {number} entityIndex
+     * @param {number} entity_id
      * @param {Class<C>} klass
      * @returns {boolean}
      */
-    hasComponent(entityIndex, klass) {
-        return this.getComponent(entityIndex, klass) !== undefined;
+    hasComponent(entity_id, klass) {
+        return this.getComponent(entity_id, klass) !== undefined;
     }
 
     /**
@@ -1188,13 +1196,13 @@ export class EntityComponentDataset {
     /**
      * Always returns non-null value, if the component is not found - an error is thrown instead
      * @template C
-     * @param {number} entityIndex
+     * @param {number} entity_id
      * @param {Class<C>} klass
      * @returns {C}
      * @throws {Error} when component not found
      */
-    getComponentSafe(entityIndex, klass) {
-        const component = this.getComponent(entityIndex, klass);
+    getComponentSafe(entity_id, klass) {
+        const component = this.getComponent(entity_id, klass);
 
         if (component === undefined) {
             throw new Error("Component not found");
@@ -1205,23 +1213,24 @@ export class EntityComponentDataset {
 
     /**
      * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
-     * @param {Number} entityId
-     * @param {Class} componentClass
+     * @param {Number} entity_id
+     * @param {Class} component_class
      * @param {function} callback
      * @param {*} [thisArg]
+     * @returns {void}
      */
-    getComponentAsync(entityId, componentClass, callback, thisArg) {
-        const component = this.getComponent(entityId, componentClass);
+    getComponentAsync(entity_id, component_class, callback, thisArg) {
+        const component = this.getComponent(entity_id, component_class);
 
         const handler = (options) => {
-            if (options.klass === componentClass) {
-                this.removeEntityEventListener(entityId, EventType.ComponentAdded, handler);
+            if (options.klass === component_class) {
+                this.removeEntityEventListener(entity_id, EventType.ComponentAdded, handler);
                 callback.call(thisArg, options.instance);
             }
         }
 
         if (component === undefined) {
-            this.addEntityEventListener(entityId, EventType.ComponentAdded, handler);
+            this.addEntityEventListener(entity_id, EventType.ComponentAdded, handler);
         } else {
             callback.call(thisArg, component);
         }
@@ -1239,6 +1248,7 @@ export class EntityComponentDataset {
      * @param {Array} classes
      * @param {function(...args):boolean} visitor Visitor can return optional "false" to terminate traversal earlier
      * @param {object} [thisArg] specifies context object on which callbacks are to be called, optional
+     * @returns {void}
      */
     traverseEntities(classes, visitor, thisArg) {
 
@@ -1319,6 +1329,7 @@ export class EntityComponentDataset {
      * @param {Array.<class>} classes
      * @param {Function} visitor
      * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
+     * @returns {void}
      */
     traverseEntitiesExact(classes, visitor, thisArg) {
         let entityIndex, i;
@@ -1379,17 +1390,19 @@ export class EntityComponentDataset {
     }
 
     /**
-     *
-     * @returns {Generator<number>}
+     * Iterate over all entities
+     * @return {Generator<number>}
      */
-    * createEntityIterator() {
-
+    * [Symbol.iterator]() {
         const eo = this.entityOccupancy;
 
-        for (let i = eo.nextSetBit(0); i !== -1; i = eo.nextSetBit(i + 1)) {
+        for (
+            let i = eo.nextSetBit(0);
+            i !== -1;
+            i = eo.nextSetBit(i + 1)
+        ) {
             yield i;
         }
-
     }
 
     /**
@@ -1397,6 +1410,7 @@ export class EntityComponentDataset {
      * @param {Class<T>} klass
      * @param {function(instance:T, entity:number)} visitor
      * @param {*} [thisArg=undefined]
+     * @returns {void}
      */
     traverseComponents(klass, visitor, thisArg) {
         const componentTypeIndex = this.computeComponentTypeIndex(klass);
@@ -1413,29 +1427,31 @@ export class EntityComponentDataset {
 
     /**
      *
-     * @param {number} componentTypeIndex
+     * @param {number} component_index
      * @param {function} visitor
      * @param {*} [thisArg]
+     * @returns {void}
      */
-    traverseComponentsByIndex(componentTypeIndex, visitor, thisArg) {
+    traverseComponentsByIndex(component_index, visitor, thisArg) {
 
-        assert.isNumber(componentTypeIndex, "componentTypeIndex");
-        assert.isNonNegativeInteger(componentTypeIndex, "componentTypeIndex");
+        assert.isNumber(component_index, "component_index");
+        assert.isNonNegativeInteger(component_index, "component_index");
         assert.isFunction(visitor, "visitor");
 
-        this.__traverseComponentsByIndex_via_property(componentTypeIndex, visitor, thisArg);
+        this.__traverseComponentsByIndex_via_property(component_index, visitor, thisArg);
     }
 
     /**
      * Alternative to {@link __traverseComponentsByIndex_via_property} as of 2020, appears to be significantly slower on Chrome with larger datasets
      * @private
-     * @param {number} componentTypeIndex
+     * @param {number} component_index
      * @param {function} visitor
      * @param {*} [thisArg]
+     * @returns {void}
      */
-    __traverseComponentsByIndex_via_bitset(componentTypeIndex, visitor, thisArg) {
+    __traverseComponentsByIndex_via_bitset(component_index, visitor, thisArg) {
 
-        const componentDataset = this.components[componentTypeIndex];
+        const componentDataset = this.components[component_index];
         const componentTypeCount = this.componentTypeCount;
 
         const entityOccupancy = this.entityOccupancy;
@@ -1443,7 +1459,7 @@ export class EntityComponentDataset {
 
         for (let entityIndex = entityOccupancy.nextSetBit(0); entityIndex !== -1; entityIndex = entityOccupancy.nextSetBit(entityIndex + 1)) {
 
-            const componentOccupancyIndex = entityIndex * componentTypeCount + componentTypeIndex;
+            const componentOccupancyIndex = entityIndex * componentTypeCount + component_index;
 
             if (componentOccupancy.get(componentOccupancyIndex)) {
 
@@ -1462,13 +1478,14 @@ export class EntityComponentDataset {
 
     /**
      * @private
-     * @param {number} componentTypeIndex
+     * @param {number} component_index
      * @param {function} visitor
      * @param {*} [thisArg]
+     * @returns {void}
      */
-    __traverseComponentsByIndex_via_property(componentTypeIndex, visitor, thisArg) {
+    __traverseComponentsByIndex_via_property(component_index, visitor, thisArg) {
 
-        const componentDataset = this.components[componentTypeIndex];
+        const componentDataset = this.components[component_index];
 
         for (const entity_key in componentDataset) {
 
@@ -1492,13 +1509,14 @@ export class EntityComponentDataset {
 
     /**
      * @private
-     * @param {number} entityIndex
-     * @param {number} componentIndex
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {void}
      */
-    processObservers_ComponentAdded(entityIndex, componentIndex) {
+    processObservers_ComponentAdded(entity_id, component_index) {
         const observers = this.observers;
 
-        const observersStore = observers[componentIndex];
+        const observersStore = observers[component_index];
 
         const numObservers = observersStore.length;
 
@@ -1514,14 +1532,14 @@ export class EntityComponentDataset {
         for (; i < numObservers; i++) {
             const observer = observersStore[i];
 
-            const match = matchComponentMask(this.componentOccupancy, entityIndex, this.componentTypeCount, observer.componentMask);
+            const match = matchComponentMask(this.componentOccupancy, entity_id, this.componentTypeCount, observer.componentMask);
 
             if (match) {
                 //match completing addition
-                buildObserverCallbackArgs(entityIndex, observer.componentMask, observer.componentIndexMapping, this.components, args);
+                buildObserverCallbackArgs(entity_id, observer.componentMask, observer.componentIndexMapping, this.components, args);
 
                 //write entityId argument
-                args[observer.componentTypeCount] = entityIndex;
+                args[observer.componentTypeCount] = entity_id;
 
                 //invoke callback
                 observer.callbackComplete.apply(observer.thisArg, args);
@@ -1531,13 +1549,14 @@ export class EntityComponentDataset {
 
     /**
      * @private
-     * @param {number} entityIndex
-     * @param {number} componentIndex
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {void}
      */
-    processObservers_ComponentRemoved(entityIndex, componentIndex) {
+    processObservers_ComponentRemoved(entity_id, component_index) {
         const observers = this.observers;
 
-        const observersStore = observers[componentIndex];
+        const observersStore = observers[component_index];
 
         const numObservers = observersStore.length;
 
@@ -1548,14 +1567,14 @@ export class EntityComponentDataset {
         for (i = 0; i < numObservers; i++) {
             const observer = observersStore[i];
 
-            const match = matchComponentMask(this.componentOccupancy, entityIndex, this.componentTypeCount, observer.componentMask);
+            const match = matchComponentMask(this.componentOccupancy, entity_id, this.componentTypeCount, observer.componentMask);
 
             if (match) {
                 //match breaking removal
-                buildObserverCallbackArgs(entityIndex, observer.componentMask, observer.componentIndexMapping, this.components, args);
+                buildObserverCallbackArgs(entity_id, observer.componentMask, observer.componentIndexMapping, this.components, args);
 
                 //write entityId argument
-                args[observer.componentTypeCount] = entityIndex;
+                args[observer.componentTypeCount] = entity_id;
 
                 //invoke callback
                 observer.callbackBroken.apply(observer.thisArg, args);
@@ -1568,6 +1587,7 @@ export class EntityComponentDataset {
      * @param {number} entity
      * @param {function} listener
      * @param {*} [thisArg]
+     * @returns {void}
      */
     addEntityAnyEventListener(entity, listener, thisArg) {
 
@@ -1628,15 +1648,16 @@ export class EntityComponentDataset {
     }
 
     /**
-     * Registers an event listener to a specific entity and event type, specified by eventName string.
+     * Registers an event listener to a specific entity and event type, specified by event_name string.
      * @param {number} entity
-     * @param {string} eventName
+     * @param {string} event_name
      * @param {function()} listener
      * @param {*} [thisArg]
+     * @returns {void}
      */
-    addEntityEventListener(entity, eventName, listener, thisArg) {
+    addEntityEventListener(entity, event_name, listener, thisArg) {
         assert.isNonNegativeInteger(entity, "entity");
-        assert.isString(eventName, "eventName");
+        assert.isString(event_name, "event_name");
         assert.isFunction(listener, "listener");
 
         if (!this.entityExists(entity)) {
@@ -1652,11 +1673,11 @@ export class EntityComponentDataset {
             evl[entity] = hash;
         }
 
-        let listeners = hash[eventName];
+        let listeners = hash[event_name];
 
         if (listeners === void 0) {
             listeners = [];
-            hash[eventName] = listeners;
+            hash[event_name] = listeners;
         }
 
         const handler = new SignalHandler(listener, thisArg);
@@ -1667,15 +1688,15 @@ export class EntityComponentDataset {
     /**
      * Remove existing event listener associated with a specific entity. Does nothing if listener isn't registered.
      * @param {number} entity
-     * @param {string} eventName
+     * @param {string} event_name
      * @param {function} listener
      * @param {*} [thisArg]
      *
      * @returns {boolean}
      */
-    removeEntityEventListener(entity, eventName, listener, thisArg) {
+    removeEntityEventListener(entity, event_name, listener, thisArg) {
         assert.isNonNegativeInteger(entity, "entity");
-        assert.isString(eventName, "eventName");
+        assert.isString(event_name, "event_name");
         assert.isFunction(listener, "listener");
 
         const evl = this.__entityEventListeners;
@@ -1687,7 +1708,7 @@ export class EntityComponentDataset {
             return false;
         }
 
-        const listeners = hash[eventName];
+        const listeners = hash[event_name];
 
         if (listeners === undefined) {
             //no event listeners exist for this event
@@ -1718,6 +1739,7 @@ export class EntityComponentDataset {
      * @param {Number} entity
      * @param {String} name event name
      * @param {Object} [event=undefined]
+     * @returns {void}
      */
     sendEvent(entity, name, event) {
         // console.log("sendEvent", entity, name, event);
@@ -1738,11 +1760,11 @@ export class EntityComponentDataset {
 
     /**
      *
-     * @param {number} entityIndex
+     * @param {number} entity_id
      * @returns {boolean}
      */
-    entityHasComponents(entityIndex) {
-        const components = this.getAllComponents(entityIndex);
+    entityHasComponents(entity_id) {
+        const components = this.getAllComponents(entity_id);
         const n = components.length;
 
         for (let i = 0; i < n; i++) {
@@ -1758,6 +1780,7 @@ export class EntityComponentDataset {
 
     /**
      * Remove all entities, triggers all relevant removal events for each entity/component
+     * @returns {void}
      */
     clear() {
         const entityOccupancy = this.entityOccupancy;
@@ -1769,7 +1792,8 @@ export class EntityComponentDataset {
 
     /**
      * Drops all data, bypassing standard workflow, no events are dispatched. Data is simply ejected.
-     * This method is very efficient but is intended to be used only when associated data is no needed as it may produce unintended consequences if the data is re-used
+     * This method is very efficient but is intended to be used only when associated data is not needed as it may produce unintended consequences if the data is re-used
+     * @returns {void}
      */
     dropData() {
         //drop components
@@ -1787,37 +1811,43 @@ export class EntityComponentDataset {
 
     /**
      * @template T
-     * @param {string} className
+     * @param {string} class_name
      * @returns {null|function|Class<T>}
      */
-    getComponentClassByName(className) {
+    getComponentClassByName(class_name) {
         let i = 0;
+
         for (; i < this.componentTypeCount; i++) {
+
             const componentClass = this.componentTypeMap[i];
             const name = componentClass.typeName;
-            if (name === className) {
+
+            if (name === class_name) {
                 return componentClass;
             }
+
         }
+
         return null;
     }
 
     /**
      * Copy entities from a supplied input dataset. Only components present in the mask are copied
-     * @param {Array} componentClasses
+     * @param {Array} component_classes
      * @param {EntityComponentDataset} source
+     * @returns {void}
      */
-    maskedCopy(source, componentClasses) {
+    maskedCopy(source, component_classes) {
 
         let i;
 
-        const componentCount = componentClasses.length;
+        const componentCount = component_classes.length;
 
         const sourceComponentIndices = [];
         const thisComponentIndices = [];
 
         for (i = 0; i < componentCount; i++) {
-            const componentClass = componentClasses[i];
+            const componentClass = component_classes[i];
 
             const sourceComponentIndex = source.computeComponentTypeIndex(componentClass);
 
@@ -1870,12 +1900,13 @@ export class EntityComponentDataset {
 
     /**
      * Main utility of this method is to facilitate serialization.
-     * @param {Array} componentClasses
+     * @param {Array} component_classes
      * @param {function(componentIndex:number,components:Array, componentCount:number)} visitor
+     * @returns {void}
      */
-    traverseEntitiesCompactedFiltered(componentClasses, visitor) {
+    traverseEntitiesCompactedFiltered(component_classes, visitor) {
 
-        const inputClassCount = componentClasses.length;
+        const inputClassCount = component_classes.length;
 
         const componentIndices = new Array(inputClassCount);
 
@@ -1884,9 +1915,8 @@ export class EntityComponentDataset {
         let i, j;
 
         for (i = 0; i < inputClassCount; i++) {
-            const componentClass = componentClasses[i];
-            const componentIndex = this.computeComponentTypeIndex(componentClass);
-            componentIndices[i] = componentIndex;
+            const klass = component_classes[i];
+            componentIndices[i] = this.computeComponentTypeIndex(klass);
         }
 
         //sort component indices array for faster traversal
@@ -1911,9 +1941,7 @@ export class EntityComponentDataset {
                 const componentIndex = componentIndices[j];
                 if (componentOccupancy.get(entityOccupancyAddress + componentIndex)) {
                     //component exists
-                    const componentInstance = this.components[componentIndex][i];
-
-                    components[componentCount] = componentInstance;
+                    components[componentCount] = this.components[componentIndex][i];
 
                     componentCount++;
                 }
@@ -1936,19 +1964,20 @@ export class EntityComponentDataset {
      *
      * @param {function(entityIndex:number)} visitor
      * @param {*} [thisArg]
+     * @returns {void}
      */
     traverseEntityIndices(visitor, thisArg) {
-        let entityIndex;
+        let entity_id;
 
         const occupancy = this.entityOccupancy;
 
         for (
-            entityIndex = occupancy.nextSetBit(0);
-            entityIndex !== -1;
-            entityIndex = occupancy.nextSetBit(entityIndex + 1)
+            entity_id = occupancy.nextSetBit(0);
+            entity_id !== -1;
+            entity_id = occupancy.nextSetBit(entity_id + 1)
         ) {
 
-            visitor.call(thisArg, entityIndex);
+            visitor.call(thisArg, entity_id);
 
         }
     }
@@ -1960,6 +1989,9 @@ export class EntityComponentDataset {
  */
 EntityComponentDataset.prototype.isEntityComponentDataset = true;
 
+// aliases
+EntityComponentDataset.prototype.createEntityIterator = EntityComponentDataset.prototype[Symbol.iterator];
+
 
 function stringifyComponent(c) {
     if (typeof c === "object") {