@woosh/meep-engine 2.117.18 → 2.117.19

package/build/meep.module.js

@@ -59945,20 +59945,6 @@ function invokeObjectHash(object) {
     return object.hash();
 }
 
-/**
- * @template T
- * @param {T[]} array
- * @param {number} index0
- * @param {number} index1
- */
-function array_swap_one(array, index0, index1) {
-
-    const t = array[index0];
-
-    array[index0] = array[index1];
-    array[index1] = t;
-}
-
 /**
  * @example `const my_array = new ( UintArrayForCount(x) )(length);`
  * @param {number} max_value maximum value to be contained in the array
@@ -60108,62 +60094,62 @@ class HashMap {
      * number of bins is always power or two
      * @type {Uint32Array}
      */
-    #bins = EMPTY_BINS;
+    __bins = EMPTY_BINS;
 
     /**
      * Note that dead entries are marked as such with a special reserved hash values, so records can be reused for new entries
      * @type {Array<HashMapEntry<K,V>>}
      */
-    #entries = new Array(0);
+    __entries = new Array(0);
 
     /**
      * Pointer to the end of allocated entries segment
      * @type {number}
      */
-    #entries_bound = 0;
+    __entries_bound = 0;
 
     /**
      *
      * @type {number}
      */
-    #entries_start = 0;
+    __entries_start = 0;
 
     /**
      * number of records in the map
      * @type {number}
      */
-    #size = 0;
+    __size = 0;
 
-    #bin_count = 0;
+    __bin_count = 0;
 
     /**
      * Always exactly half of the number of bins
      * @type {number}
      */
-    #entries_allocated_count = 0;
+    __entries_allocated_count = 0;
 
-    #bin_count_power_of_two = 0;
+    __bin_count_power_of_two = 0;
 
-    #entries_count_power_of_two = 0;
+    __entries_count_power_of_two = 0;
 
     /**
      * Mask used to map from hash to a bin index
      * @type {number}
      */
-    #bin_count_mask = 0;
+    __bin_count_mask = 0;
 
     /**
      * How full the table can get before number of buckets is increased
      * @type {number}
      * @private
      */
-    #load_factor = DEFAULT_LOAD_FACTOR;
+    __load_factor = DEFAULT_LOAD_FACTOR;
 
     /**
      * Used to track modifications to prevent concurrent changes during iteration
      * @type {number}
      */
-    #version = 0;
+    __version = 0;
 
     /**
      * @template K, V
@@ -60194,13 +60180,13 @@ class HashMap {
          */
         this.keyEqualityFunction = keyEqualityFunction;
 
-        this.#load_factor = loadFactor;
+        this.__load_factor = loadFactor;
 
         this.#setBinCount(ceilPowerOfTwo(capacity));
     }
 
     get size() {
-        return this.#size;
+        return this.__size;
     }
 
     /**
@@ -60208,7 +60194,7 @@ class HashMap {
      * @returns {number}
      */
     getCurrentLoad() {
-        return this.#size / this.#bin_count;
+        return this.__size / this.__bin_count;
     }
 
     /**
@@ -60217,33 +60203,33 @@ class HashMap {
      */
     #setBinCount(count) {
 
-        if (count < this.#size) {
-            throw new Error(`count must be at least equal to must of records in the map (=${this.#size}), instead was ${count}`);
+        if (count < this.__size) {
+            throw new Error(`count must be at least equal to must of records in the map (=${this.__size}), instead was ${count}`);
         }
 
 
-        this.#entries_count_power_of_two = ctz32(count);
-        this.#bin_count_power_of_two = this.#entries_count_power_of_two + 1;
+        this.__entries_count_power_of_two = ctz32(count);
+        this.__bin_count_power_of_two = this.__entries_count_power_of_two + 1;
 
-        this.#bin_count = 2 ** this.#bin_count_power_of_two;
-        this.#bin_count_mask = this.#bin_count - 1;
+        this.__bin_count = 2 ** this.__bin_count_power_of_two;
+        this.__bin_count_mask = this.__bin_count - 1;
 
-        const old_entry_allocation_count = this.#entries_allocated_count;
+        const old_entry_allocation_count = this.__entries_allocated_count;
 
-        this.#entries_allocated_count = 2 ** this.#entries_count_power_of_two;
+        this.__entries_allocated_count = 2 ** this.__entries_count_power_of_two;
 
-        const BinsArray = UintArrayForCount(this.#entries_allocated_count + ENTRY_BASE);
+        const BinsArray = UintArrayForCount(this.__entries_allocated_count + ENTRY_BASE);
 
-        this.#bins = new BinsArray(this.#bin_count);
+        this.__bins = new BinsArray(this.__bin_count);
 
-        const new_entries = new Array(this.#entries_allocated_count);
-        const old_entries = this.#entries;
+        const new_entries = new Array(this.__entries_allocated_count);
+        const old_entries = this.__entries;
 
-        this.#entries = new_entries;
+        this.__entries = new_entries;
 
-        array_copy(old_entries, 0, new_entries, 0, min2(old_entry_allocation_count, this.#entries_allocated_count));
+        array_copy(old_entries, 0, new_entries, 0, min2(old_entry_allocation_count, this.__entries_allocated_count));
 
-        if (this.#size > 0) {
+        if (this.__size > 0) {
             // re-hash
             this.rebuild();
         }
@@ -60255,7 +60241,7 @@ class HashMap {
      * @returns {number}
      * @private
      */
-    #compute_bin_index(hash) {
+    compute_bin_index(hash) {
 
         // mix the input hash to minimize potential impact of poor hash function spread
         const mixed_hash = (hash >>> 16) ^ hash;
@@ -60263,7 +60249,7 @@ class HashMap {
         // force index to unsigned integer
         const index = mixed_hash >>> 0;
 
-        return index & this.#bin_count_mask;
+        return index & this.__bin_count_mask;
     }
 
     /**
@@ -60309,15 +60295,15 @@ class HashMap {
      */
     #allocate_entry(k, v, hash) {
 
-        const i = this.#entries_bound;
+        const i = this.__entries_bound;
 
-        this.#entries_bound++;
+        this.__entries_bound++;
 
-        if (this.#entries[i] !== undefined) {
+        if (this.__entries[i] !== undefined) {
 
             // entry exists, let's reuse it
 
-            const entry = this.#entries[i];
+            const entry = this.__entries[i];
 
             entry.hash = hash;
             entry.key = k;
@@ -60327,7 +60313,7 @@ class HashMap {
 
             // entry slot is empty
 
-            this.#entries[i] = new HashMapEntry(k, v, hash);
+            this.__entries[i] = new HashMapEntry(k, v, hash);
 
         }
 
@@ -60348,11 +60334,11 @@ class HashMap {
     }
 
     #rebuild_if_necessary() {
-        if (this.#entries_bound !== this.#entries_allocated_count) {
+        if (this.__entries_bound !== this.__entries_allocated_count) {
             return;
         }
 
-        if (this.#size === this.#entries_allocated_count) {
+        if (this.__size === this.__entries_allocated_count) {
             // used up all allocated entries
             // bin count must always be larger than end of the entries table
             this.#grow();
@@ -60371,18 +60357,18 @@ class HashMap {
         this.#rebuild_if_necessary();
 
         const raw_hash = this.#build_key_hash(key);
-        let bin_index = this.#compute_bin_index(raw_hash);
+        let bin_index = this.compute_bin_index(raw_hash);
 
         let first_deleted_bin_index = UNDEFINED_BIN_INDEX;
 
         for (; ;) {
-            const bin = this.#bins[bin_index];
+            const bin = this.__bins[bin_index];
 
             if (bin > BIN_RESERVED_VALUE_DELETED) {
                 // bin is occupied
 
                 // check if it's the entry that we're looking for
-                const entry = this.#entries[bin - ENTRY_BASE];
+                const entry = this.__entries[bin - ENTRY_BASE];
 
                 if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
@@ -60402,7 +60388,7 @@ class HashMap {
 
                 const bin_value = entry_index + ENTRY_BASE;
 
-                this.#bins[bin_index] = bin_value;
+                this.__bins[bin_index] = bin_value;
 
                 break;
 
@@ -60413,19 +60399,19 @@ class HashMap {
             }
 
             // perform secondary hashing
-            bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+            bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
         }
 
-        const old_size = this.#size;
+        const old_size = this.__size;
         const new_size = old_size + 1;
-        this.#size = new_size;
+        this.__size = new_size;
 
         // compute actual current load
-        const bucket_count = this.#bin_count;
+        const bucket_count = this.__bin_count;
         const load = new_size / bucket_count;
 
-        if (load > this.#load_factor) {
+        if (load > this.__load_factor) {
             // current load is too high, increase table size
             this.#grow();
         }
@@ -60439,16 +60425,16 @@ class HashMap {
     get(key) {
         const raw_hash = this.#build_key_hash(key);
 
-        let bin_index = this.#compute_bin_index(raw_hash);
+        let bin_index = this.compute_bin_index(raw_hash);
 
         for (; ;) {
-            const bin = this.#bins[bin_index];
+            const bin = this.__bins[bin_index];
 
             if (bin > BIN_RESERVED_VALUE_DELETED) {
                 // bin is occupied
 
                 // check if the entry is what we're looking for
-                const entry = this.#entries[bin - ENTRY_BASE];
+                const entry = this.__entries[bin - ENTRY_BASE];
 
                 if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
@@ -60461,7 +60447,7 @@ class HashMap {
             }
 
             // perform secondary hashing
-            bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+            bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
         }
 
@@ -60510,22 +60496,23 @@ class HashMap {
     }
 
     /**
-     *
-     * @param {number} bin
+     * Update the entries start of table TAB after removing an entry with index N in the array entries.
+     * @param {number} bin index of deleted entry
      */
     #update_range_for_deleted(bin) {
-        if (this.#entries_start === bin) {
-            let start = bin + 1;
-            let bound = this.#entries_bound;
-
-            const entries = this.#entries;
+        if (this.__entries_start !== bin) {
+            return;
+        }
 
-            while (start < bound && entries[start].hash === RESERVED_HASH) {
-                start++;
-            }
+        let start = bin + 1;
+        let bound = this.__entries_bound;
+        const entries = this.__entries;
 
-            this.#entries_start = start;
+        while (start < bound && entries[start].hash === RESERVED_HASH) {
+            start++;
         }
+
+        this.__entries_start = start;
     }
 
     /**
@@ -60536,10 +60523,10 @@ class HashMap {
     delete(key) {
 
         const raw_hash = this.#build_key_hash(key);
-        let bin_index = this.#compute_bin_index(raw_hash);
+        let bin_index = this.compute_bin_index(raw_hash);
 
-        const bins = this.#bins;
-        const entries = this.#entries;
+        const bins = this.__bins;
+        const entries = this.__entries;
 
         for (; ;) {
             const bin = bins[bin_index];
@@ -60560,7 +60547,7 @@ class HashMap {
                     // mark slot as removed
                     bins[bin_index] = BIN_RESERVED_VALUE_DELETED;
 
-                    this.#size--;
+                    this.__size--;
 
                     this.#update_range_for_deleted(entry_index);
 
@@ -60573,7 +60560,7 @@ class HashMap {
             }
 
             // perform secondary hashing
-            bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+            bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
         }
     }
@@ -60587,9 +60574,9 @@ class HashMap {
     verifyHashes(callback, thisArg) {
         let all_hashes_valid = true;
 
-        const count = this.#bin_count;
+        const count = this.__bin_count;
         for (let j = 0; j < count; j++) {
-            const bin = this.#bins[j];
+            const bin = this.__bins[j];
 
             if (bin <= BIN_RESERVED_VALUE_DELETED) {
                 // unoccupied
@@ -60599,7 +60586,7 @@ class HashMap {
             /**
              * @type {HashMapEntry<K,V>}
              */
-            const entry = this.#entries[bin - ENTRY_BASE];
+            const entry = this.__entries[bin - ENTRY_BASE];
 
             //check hash
             const raw_hash = this.#build_key_hash(entry.key);
@@ -60616,7 +60603,7 @@ class HashMap {
     }
 
     #grow() {
-        this.#setBinCount(this.#entries_allocated_count * 2);
+        this.#setBinCount(this.__entries_allocated_count * 2);
     }
 
 
@@ -60624,17 +60611,17 @@ class HashMap {
      * Rebuild table, useful for when table is resized
      */
     rebuild() {
-        const entries_bound = this.#entries_bound;
-        const entries = this.#entries;
+        const entries_bound = this.__entries_bound;
+        const entries = this.__entries;
 
         // reset all bins
-        const bins = this.#bins;
+        const bins = this.__bins;
         bins.fill(BIN_RESERVED_VALUE_EMPTY);
 
         let written_entries = 0;
 
         for (
-            let existing_entry_index = this.#entries_start;
+            let existing_entry_index = this.__entries_start;
             existing_entry_index < entries_bound;
             existing_entry_index++
         ) {
@@ -60652,11 +60639,13 @@ class HashMap {
 
             if (new_index !== existing_entry_index) {
                 // move entries to the new position, compacting holes
-                array_swap_one(entries, new_index, existing_entry_index);
+
+                entries[new_index] = entries[existing_entry_index];
             }
 
-            let bin_index = this.#compute_bin_index(hash);
+            let bin_index = this.compute_bin_index(hash);
 
+            // search for place for the entry
             for (; ;) {
                 const bin = bins[bin_index];
 
@@ -60667,20 +60656,20 @@ class HashMap {
                 }
 
                 // perform secondary hashing
-                bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+                bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
             }
         }
 
-        this.#entries_start = 0;
-        this.#entries_bound = this.#size;
-        this.#version++;
+        this.__entries_start = 0;
+        this.__entries_bound = this.__size;
+        this.__version++;
     }
 
     #count_live_entities() {
         let count = 0;
-        for (let i = this.#entries_start; i < this.#entries_bound; i++) {
-            const entry = this.#entries[i];
+        for (let i = this.__entries_start; i < this.__entries_bound; i++) {
+            const entry = this.__entries[i];
 
             if (entry.hash !== RESERVED_HASH) {
                 count++;
@@ -60692,10 +60681,10 @@ class HashMap {
 
     forEach(callback, thisArg) {
 
-        const count = this.#bin_count;
-        const entries = this.#entries;
-        const bins = this.#bins;
-        this.#version;
+        const count = this.__bin_count;
+        const entries = this.__entries;
+        const bins = this.__bins;
+        this.__version;
 
         for (let j = 0; j < count; j++) {
 
@@ -60731,8 +60720,8 @@ class HashMap {
     clear() {
 
         // clear out all
-        const bins = this.#bins;
-        const count = this.#bin_count;
+        const bins = this.__bins;
+        const count = this.__bin_count;
 
         for (let i = 0; i < count; i++) {
             const bin = bins[i];
@@ -60743,7 +60732,7 @@ class HashMap {
                     // occupied, move to deleted
                     const entry_index = bin - ENTRY_BASE;
 
-                    this.#deallocate(this.#entries[entry_index]);
+                    this.#deallocate(this.__entries[entry_index]);
                 }
 
                 // mark as empty
@@ -60753,20 +60742,20 @@ class HashMap {
 
         }
 
-        this.#size = 0;
+        this.__size = 0;
 
-        this.#entries_start = 0;
-        this.#entries_bound = 0;
+        this.__entries_start = 0;
+        this.__entries_bound = 0;
     }
 
     * [Symbol.iterator]() {
 
-        const count = this.#bin_count;
+        const count = this.__bin_count;
 
-        const bins = this.#bins;
-        const entries = this.#entries;
+        const bins = this.__bins;
+        const entries = this.__entries;
 
-        this.#version;
+        this.__version;
 
         for (let j = 0; j < count; j++) {
 
@@ -106545,6 +106534,20 @@ function computeBinaryDataTypeByPrecision(type, precision) {
     throw new Error(`Unsupported numeric type(=${type}) and precision(=${precision}) combination`);
 }
 
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {number} index0
+ * @param {number} index1
+ */
+function array_swap_one(array, index0, index1) {
+
+    const t = array[index0];
+
+    array[index0] = array[index1];
+    array[index1] = t;
+}
+
 const stack$1 = [];
 
 /**

package/package.json

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

package/src/core/collection/map/HashMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AA8FD;;;;;;;GAOG;AACH;IA+DI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IAlBG;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAiKD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAYZ;IAuBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBAsDC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IAhDD,yDA2BC;;CAsBJ"}
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AA8FD;;;;;;;GAOG;AACH;IA+DI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IAtGD;;;;OAIG;IACH,QAFU,WAAW,CAED;IAEpB;;;OAGG;IACH,WAFU,MAAM,aAAa,CAAC,EAAC,CAAC,CAAC,CAAC,CAET;IAEzB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,oBAAgB;IAEhB;;;OAGG;IACH,2BAFU,MAAM,CAEc;IAE9B,iCAA6B;IAE7B,qCAAiC;IAEjC;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,WAFU,MAAM,CAEF;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAsGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAYZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBAwDC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IAhDD,yDA2BC;;CAsBJ;AA/0BD;;GAEG;AACH;IACI;;;;;OAKG;IACH,iBAJW,CAAC,SACD,CAAC,QACD,MAAM,EAsBhB;IAlBG;;;OAGG;IACH,KAFU,CAAC,CAEG;IAEd;;;OAGG;IACH,OAFU,CAAC,CAEO;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEA;CAGvB"}