@woosh/meep-engine 2.117.17 → 2.117.19

package/build/meep.cjs

@@ -59947,20 +59947,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
@@ -60110,62 +60096,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
@@ -60196,13 +60182,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;
     }
 
     /**
@@ -60210,7 +60196,7 @@ class HashMap {
      * @returns {number}
      */
     getCurrentLoad() {
-        return this.#size / this.#bin_count;
+        return this.__size / this.__bin_count;
     }
 
     /**
@@ -60219,33 +60205,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();
         }
@@ -60257,7 +60243,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;
@@ -60265,7 +60251,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;
     }
 
     /**
@@ -60311,15 +60297,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;
@@ -60329,7 +60315,7 @@ class HashMap {
 
             // entry slot is empty
 
-            this.#entries[i] = new HashMapEntry(k, v, hash);
+            this.__entries[i] = new HashMapEntry(k, v, hash);
 
         }
 
@@ -60350,11 +60336,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();
@@ -60373,18 +60359,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
@@ -60404,7 +60390,7 @@ class HashMap {
 
                 const bin_value = entry_index + ENTRY_BASE;
 
-                this.#bins[bin_index] = bin_value;
+                this.__bins[bin_index] = bin_value;
 
                 break;
 
@@ -60415,19 +60401,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();
         }
@@ -60441,16 +60427,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
@@ -60463,7 +60449,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);
 
         }
 
@@ -60512,22 +60498,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;
     }
 
     /**
@@ -60538,10 +60525,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];
@@ -60562,7 +60549,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);
 
@@ -60575,7 +60562,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);
 
         }
     }
@@ -60589,9 +60576,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
@@ -60601,7 +60588,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);
@@ -60618,7 +60605,7 @@ class HashMap {
     }
 
     #grow() {
-        this.#setBinCount(this.#entries_allocated_count * 2);
+        this.#setBinCount(this.__entries_allocated_count * 2);
     }
 
 
@@ -60626,17 +60613,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++
         ) {
@@ -60654,11 +60641,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];
 
@@ -60669,20 +60658,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++;
@@ -60694,10 +60683,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++) {
 
@@ -60733,8 +60722,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];
@@ -60745,7 +60734,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
@@ -60755,20 +60744,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++) {
 
@@ -106547,6 +106536,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 = [];
 
 /**