@woosh/meep-engine 3.41.0 → 3.43.0

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.js

@@ -1,113 +1,112 @@
-import { assert } from "../../../assert.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_ray_segment_entry_distance } from "../../../geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
-
-const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {BinaryUint32BVH} bvh
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @param {number} max_distance tMax for the ray, can set to Infinity if you don't care.
- * @returns {number}
- */
-export function bvh32_query_user_data_ray(
-    result, result_offset,
-    bvh,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    max_distance,
-) {
-
-    assert.isNumber(max_distance, "max_distance");
-
-    let hit_count = 0;
-
-    const binary_node_count = bvh.binary_node_count;
-
-    if (binary_node_count <= 0) {
-        // this should not happen
-        return 0;
-    }
-
-    /**
-     *
-     * @type {number}
-     */
-    const stack_top = stack.pointer++;
-
-    /**
-     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
-     * @type {number}
-     */
-    stack[stack_top] = 0;
-
-    const last_valid_index = binary_node_count + bvh.leaf_node_count;
-
-    const float32 = bvh.float32;
-    const uint32 = bvh.uint32;
-
-
-    const inv_direction_x = 1 / direction_x;
-    const inv_direction_y = 1 / direction_y;
-    const inv_direction_z = 1 / direction_z;
-
-    do {
-        stack.pointer--;
-
-        // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack[stack.pointer];
-
-        const node_address = bvh.getNodeAddress(node_index);
-
-        const t = aabb3_ray_segment_entry_distance(
-            float32[node_address], float32[node_address + 1], float32[node_address + 2],
-            float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
-            origin_x, origin_y, origin_z,
-            inv_direction_x, inv_direction_y, inv_direction_z,
-            0,
-            max_distance
-        );
-
-        if (t >= max_distance) {
-            continue;
-        }
-
-        const is_intermediate_node = node_index < binary_node_count;
-
-        if (is_intermediate_node) {
-            // is intermediate node
-
-            const left_index = (node_index << 1) + 1;
-            const right_index = left_index + 1;
-
-            // left node ends up on top of the stack, which aligns with the desired access sequence
-            if (right_index < last_valid_index) {
-                stack[stack.pointer++] = right_index;
-                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack[stack.pointer++] = left_index;
-            } else if (left_index < last_valid_index) {
-                stack[stack.pointer++] = left_index;
-            }
-
-
-        } else {
-            // leaf node
-
-            // write to output
-            result[result_offset + hit_count] = uint32[node_address + 6];
-
-            hit_count++;
-        }
-
-    } while (stack.pointer > stack_top)
-
-    return hit_count;
-}
+import { assert } from "../../../assert.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_ray_segment_entry_distance } from "../../../geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} max_distance tMax for the ray, can set to Infinity if you don't care.
+ * @returns {number}
+ */
+export function bvh32_query_user_data_ray(
+    result, result_offset,
+    bvh,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    max_distance,
+) {
+
+    assert.isNumber(max_distance, "max_distance");
+
+    let hit_count = 0;
+
+    const binary_node_count = bvh.binary_node_count;
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[stack_top] = 0;
+
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    const inv_direction_x = 1 / direction_x;
+    const inv_direction_y = 1 / direction_y;
+    const inv_direction_z = 1 / direction_z;
+
+    do {
+        stack.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stack.pointer];
+
+        const node_address = bvh.getNodeAddress(node_index);
+
+        const t = aabb3_ray_segment_entry_distance(
+            float32[node_address], float32[node_address + 1], float32[node_address + 2],
+            float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
+            origin_x, origin_y, origin_z,
+            inv_direction_x, inv_direction_y, inv_direction_z,
+            0,
+            max_distance
+        );
+
+        // Infinity means a miss; finite segment endpoints are included.
+        if (t === Infinity || t > max_distance) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
+            // is intermediate node
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            // left node ends up on top of the stack, which aligns with the desired access sequence
+            if (right_index < last_valid_index) {
+                stack[stack.pointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack[stack.pointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack[stack.pointer++] = left_index;
+            }
+
+        } else {
+            // leaf node
+
+            // write to output
+            result[result_offset + hit_count] = uint32[node_address + 6];
+
+            hit_count++;
+        }
+
+    } while (stack.pointer > stack_top)
+
+    return hit_count;
+}

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

@@ -19,7 +19,7 @@ export function ebvh_nodes_sort_sah_local4(
     assert.isNonNegativeInteger(offset, 'offset');
     assert.isNonNegativeInteger(count, 'count');
 
-    const swap_pair_limit = Math.floor((count - (distance + 2)) / 2);
+    const swap_pair_limit = Math.floor((count - distance) / 2);
     const end = offset + swap_pair_limit * 2;
 
     let swap_count = 0;
@@ -91,4 +91,4 @@ export function ebvh_nodes_sort_sah_local4(
     }
 
     return swap_count;
-}
+}

package/src/core/cache/wtinylfu/benchmark/CacheWTinylfu.bench.md

@@ -22,37 +22,37 @@ the cost of a miss in your system (a disk/network miss dwarfs a few hundred ns;
 
 ## Running
 
-Each benchmark is a **self-executing spec**: a single `<name>.spec.js` that is *both* a runnable Node
-benchmark and a Jest spec. The measurement **only ever runs under plain `node`** — never in-process under
+Each benchmark is a self-contained `<name>.spec.js` with a skipped test entry and an explicit manual Node
+entry. The measurement **only ever runs under plain `node`** — never in-process under
 Jest, because Jest's babel transform badly distorts the timings (see *Why not measure under Jest* below).
 The files are stripped from the published npm package by the `*.spec.js` rule.
 
-**To get numbers — run it directly with `node`, from the repo root:**
+**To get numbers — run it directly with `node`, from `packages/meep-engine`:**
 
 ```bash
-node src/core/cache/wtinylfu/benchmark/<name>.spec.js
+node src/core/cache/wtinylfu/benchmark/<name>.spec.js --benchmark
 ```
 
 where `<name>` is one of: `hitRate`, `fillDrain`, `readAll`, `continuousPut`, `mixed`, `latency`, `scaling`,
 `memory`.
 
-**Under Jest** each file is a `describe.skip`, so `npx jest` collects but skips them (zero CI cost). Un-skip
-one (flip `describe.skip` → `describe`) and Jest will **spawn a clean `node` child on the file** and check the
-output is sane — you get the same pristine numbers, never the transformed ones.
+The files remain `describe.skip` under the test runner. Vitest's `--mode all` includes them in collection;
+un-skipping one makes its test spawn a native Node child and check that the report contains finite
+measurements. Importing a file or invoking it without `--benchmark` performs no workload setup.
 
-Two flags (for the `node` invocation):
+Options for the manual `node` invocation:
 
 - **`--expose-gc`** (a Node flag, goes *before* the script path): lets a benchmark force GC between trials for
   cleaner numbers. Optional for most; **required** for `memory` (it refuses to run without it). *(When run via
   Jest, the child is always spawned with `--expose-gc`.)*
   ```bash
-  node --expose-gc src/core/cache/wtinylfu/benchmark/fillDrain.spec.js
+  node --expose-gc src/core/cache/wtinylfu/benchmark/fillDrain.spec.js --benchmark
   ```
 - **`HASH=int`** (an env var): the **isolated-hash toggle** — use integer keys + an identity hash instead of
   string keys + `computeStringHash`, to strip string-hashing cost and see pure-policy overhead. Works on
   **every** benchmark.
   ```bash
-  HASH=int node --expose-gc src/core/cache/wtinylfu/benchmark/readAll.spec.js
+  HASH=int node --expose-gc src/core/cache/wtinylfu/benchmark/readAll.spec.js --benchmark
   ```
 
 All workloads are **seeded**, so runs are reproducible. Both caches are always built at **matched capacity**
@@ -69,15 +69,15 @@ run it, read it without chasing imports). Every file follows the same skeleton:
 2. CONFIG       the knobs: CAPACITY / WARMUP / TRIALS / SEED
 3. SCAFFOLDING  inlined: clock, rng, matched-capacity factories, measureInterleaved, any workload
                 (top-level — pure definitions, safe when Jest imports the file)
-   if (under Jest) → spawn a clean `node` on this file + assert the output is sane
-   else            → the actual benchmark:
+   if (under tests) → skipped native Node child + finite report checks
+   if (manual entry with --benchmark) → runBenchmark():
 4. WORKLOAD       the setup + the timed body                       (the "arrange")
 5. MEASURE        measureInterleaved([LRU, W-TinyLFU], {...})      (the "act")
 6. REPORT         formatting + console.log                         (the "assert" analog — reports, no pass/fail)
 ```
 
-The `if (typeof describe === "function")` split is what keeps the measurement out of Jest's transform: under
-Jest only the spawn-branch runs; under `node` only the `else` (measurement) branch runs.
+The `if (typeof describe === "function")` split keeps measurements in the native child. Workload setup is
+inside `runBenchmark()`, called only by the explicit main-file `--benchmark` entry.
 
 A benchmark **reports** numbers; it does not **assert** pass/fail. That's why the measurement always runs
 under plain `node` — the Jest side only launches it and checks the output isn't empty.

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

@@ -1 +1 @@
-{"version":3,"file":"RingBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/RingBuffer.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAmBI;;OAEG;IACH,kBAFW,MAAM,EAkBhB;IArCD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,OAFU,MAAM,CAEN;IAUN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,CAAC,EAAE,CAEc;IAG/B;;;OAGG;IACH,iBAFW,MAAM,QAwBhB;IAED;;;OAGG;IACH,WAFY,CAAC,CAKZ;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,CAAC,CAYb;IAED,cAIC;IAED;;;OAGG;IACH,cAFW,CAAC,QAuBX;IAED;;;OAGG;IACH,SAFa,CAAC,GAAC,SAAS,CAcvB;IAED;;;OAGG;IACH,4BAFW,MAAM,QA8BhB;IAED;;;;;OAKG;IACH,2BAJoB,CAAC,KAAE,OAAO,kBAEjB,CAAC,GAAC,SAAS,CAsBvB;IAED;;;;OAIG;IACH,wBAHoB,CAAC,+BAmBpB;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACC,OAAO,CAgBnB;CACJ"}
+{"version":3,"file":"RingBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/RingBuffer.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAmBI;;OAEG;IACH,kBAFW,MAAM,EAkBhB;IArCD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,OAFU,MAAM,CAEN;IAUN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,CAAC,EAAE,CAEc;IAG/B;;;OAGG;IACH,iBAFW,MAAM,QAwBhB;IAED;;;OAGG;IACH,WAFY,CAAC,CAKZ;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,CAAC,CAgBb;IAED,cAIC;IAED;;;OAGG;IACH,cAFW,CAAC,QAuBX;IAED;;;OAGG;IACH,SAFa,CAAC,GAAC,SAAS,CAcvB;IAED;;;OAGG;IACH,4BAFW,MAAM,QA8BhB;IAED;;;;;OAKG;IACH,2BAJoB,CAAC,KAAE,OAAO,kBAEjB,CAAC,GAAC,SAAS,CAsBvB;IAED;;;;OAIG;IACH,wBAHoB,CAAC,+BAmBpB;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACC,OAAO,CAgBnB;CACJ"}

package/src/core/collection/RingBuffer.js

@@ -92,6 +92,10 @@ export class RingBuffer {
     getFromHead(offset) {
         assert.isNonNegativeInteger(offset, 'offset');
 
+        if (offset >= this.count) {
+            return undefined;
+        }
+
         let i = this.head - (offset + 1);
 
         while (i < 0) {

package/src/core/collection/array/array_contains_duplicates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array_contains_duplicates.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_contains_duplicates.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wEAJW,MAAM,cACN,MAAM,GACL,OAAO,CAuBlB"}
+{"version":3,"file":"array_contains_duplicates.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_contains_duplicates.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wEAJW,MAAM,cACN,MAAM,GACL,OAAO,CAwBlB"}

package/src/core/collection/array/array_contains_duplicates.js

@@ -19,7 +19,8 @@ export function array_contains_duplicates(
         const element = source[k];
 
         // look for future occurrences of the same element
-        if (source.indexOf(element, k + 1) !== -1) {
+        const match = source.indexOf(element, k + 1);
+        if (match !== -1 && match <= end_index) {
             return true;
         }
 

package/src/core/collection/array/array_copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array_copy.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_copy.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,4DALW,MAAM,0CAEN,MAAM,UACN,MAAM,QAqBhB"}
+{"version":3,"file":"array_copy.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_copy.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,4DALW,MAAM,0CAEN,MAAM,UACN,MAAM,QA4ChB"}

package/src/core/collection/array/array_copy.js

@@ -21,6 +21,29 @@ export function array_copy(
     assert.isNonNegativeInteger(destination_position, 'destination_position');
     assert.isNonNegativeInteger(length, 'length');
 
+    if (ArrayBuffer.isView(source)
+        && ArrayBuffer.isView(destination)
+        && source.buffer === destination.buffer
+        && source.BYTES_PER_ELEMENT !== undefined
+        && destination.BYTES_PER_ELEMENT !== undefined) {
+        const source_start = source.byteOffset + source_position * source.BYTES_PER_ELEMENT;
+        const destination_start = destination.byteOffset + destination_position * destination.BYTES_PER_ELEMENT;
+        if (source_start < destination_start + length * destination.BYTES_PER_ELEMENT
+            && destination_start < source_start + length * source.BYTES_PER_ELEMENT) {
+            destination.set(source.subarray(source_position, source_position + length), destination_position);
+            return;
+        }
+    }
+
+    if (source === destination
+        && destination_position > source_position
+        && destination_position < source_position + length) {
+        for (let k = length - 1; k >= 0; k--) {
+            destination[destination_position + k] = source[source_position + k];
+        }
+        return;
+    }
+
     let i, j, k;
 
     for (k = 0; k < length; k++) {

package/src/core/collection/array/typed/sparse_typed_array_hash.d.ts

@@ -1,8 +1,8 @@
 /**
  *
  * @param {Uint32Array} array
- * @param {number} offset
- * @param {number} length
+ * @param {number} offset first index to hash
+ * @param {number} length exclusive stopping index
  * @param {number} [sample_limit]
  * @returns {number}
  */

package/src/core/collection/array/typed/sparse_typed_array_hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sparse_typed_array_hash.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/sparse_typed_array_hash.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,+CANW,WAAW,UACX,MAAM,UACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAelB"}
+{"version":3,"file":"sparse_typed_array_hash.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/sparse_typed_array_hash.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,+CANW,WAAW,UACX,MAAM,UACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/collection/array/typed/sparse_typed_array_hash.js

@@ -5,22 +5,23 @@ import { computeStridedArrayHash } from "../computeStridedArrayHash.js";
 /**
  *
  * @param {Uint32Array} array
- * @param {number} offset
- * @param {number} length
+ * @param {number} offset first index to hash
+ * @param {number} length exclusive stopping index
  * @param {number} [sample_limit]
  * @returns {number}
  */
 export function sparse_typed_array_hash(array, offset, length, sample_limit = 31) {
-    // limit hash evaluation to first 1k of the data to random memory access and keep CPU cache usage more coherent
-    const hash_evaluation_length = min2(length, 1024);
+    // Limit evaluation to the first 1k elements of the selected range.
+    const hash_evaluation_span = min2(length - offset, 1024);
+    const hash_evaluation_end = offset + hash_evaluation_span;
 
-    // compute stride so that we don't have to iterate over the entire buffer, instead picking at most X(509) values to consider
-    const stride = Math.max(1, Math.ceil(hash_evaluation_length / sample_limit));
+    // Pick at most sample_limit values from that selected span.
+    const stride = Math.max(1, Math.ceil(hash_evaluation_span / sample_limit));
 
     // TODO implement fast dedicated float and int paths
 
     return computeStridedArrayHash(
-        array, 0, hash_evaluation_length, stride,
+        array, offset, hash_evaluation_end, stride,
         computeHashFloat
     );
-}
+}

package/src/core/collection/array/typed/uint16_array_hash.d.ts

@@ -1,8 +1,8 @@
 /**
  *
  * @param {Uint16Array|Int16Array} array
- * @param {number} offset
- * @param {number} length
+ * @param {number} offset first index to hash
+ * @param {number} length exclusive stopping index
  * @return {number}
  */
 export function uint16_array_hash(array: Uint16Array | Int16Array, offset: number, length: number): number;

package/src/core/collection/array/typed/uint16_array_hash.js

@@ -1,8 +1,8 @@
 /**
  *
  * @param {Uint16Array|Int16Array} array
- * @param {number} offset
- * @param {number} length
+ * @param {number} offset first index to hash
+ * @param {number} length exclusive stopping index
  * @return {number}
  */
 export function uint16_array_hash(array, offset, length) {
@@ -10,7 +10,7 @@ export function uint16_array_hash(array, offset, length) {
 
     let i = offset;
 
-    if ((length & 1) !== 0) {
+    if (((length - offset) & 1) !== 0) {
         hash = (hash << 5) - hash + array[i++];
     }
 
@@ -26,4 +26,4 @@ export function uint16_array_hash(array, offset, length) {
     }
 
     return hash;
-}
+}

package/src/core/collection/array/typed/uint8_array_hash.d.ts

@@ -1,8 +1,8 @@
 /**
  *
  * @param {Uint8Array|Int8Array} array
- * @param {number} offset
- * @param {number} length
+ * @param {number} offset first index to hash
+ * @param {number} length exclusive stopping index
  * @return {number}
  */
 export function uint8_array_hash(array: Uint8Array | Int8Array, offset: number, length: number): number;

package/src/core/collection/array/typed/uint8_array_hash.js

@@ -1,8 +1,8 @@
 /**
  *
  * @param {Uint8Array|Int8Array} array
- * @param {number} offset
- * @param {number} length
+ * @param {number} offset first index to hash
+ * @param {number} length exclusive stopping index
  * @return {number}
  */
 export function uint8_array_hash(array, offset, length) {
@@ -10,7 +10,7 @@ export function uint8_array_hash(array, offset, length) {
 
     let i = offset;
 
-    const overflow = length & 3;
+    const overflow = (length - offset) & 3;
 
     for (; i < offset + overflow; i++) {
         hash = (hash << 5) - hash + array[i];
@@ -33,4 +33,4 @@ export function uint8_array_hash(array, offset, length) {
     }
 
     return hash;
-}
+}

package/src/core/collection/array/weightedRandomFromArray.d.ts

@@ -5,6 +5,7 @@
  * @param {function(T):number} weight
  * @param {*} [weightContext]
  * @param {number} [length]
+ * @description Returns undefined when the selected prefix has no positive weight.
  * @returns {T|undefined}
  */
 export function weightedRandomFromArray<T>(array: T[], random: Function, weight: (arg0: T) => number, weightContext?: any, length?: number): T;

package/src/core/collection/array/weightedRandomFromArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weightedRandomFromArray.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/weightedRandomFromArray.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,8FALuB,MAAM,gCAElB,MAAM,KAiChB"}
+{"version":3,"file":"weightedRandomFromArray.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/weightedRandomFromArray.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,8FANuB,MAAM,gCAElB,MAAM,KAyChB"}

package/src/core/collection/array/weightedRandomFromArray.js

@@ -16,6 +16,7 @@ const scratch_weights = [];
  * @param {function(T):number} weight
  * @param {*} [weightContext]
  * @param {number} [length]
+ * @description Returns undefined when the selected prefix has no positive weight.
  * @returns {T|undefined}
  */
 export function weightedRandomFromArray(array, random, weight, weightContext, length = array.length) {
@@ -43,9 +44,16 @@ export function weightedRandomFromArray(array, random, weight, weightContext, le
         scratch_weights[i] = weight_total;
     }
 
+    if (weight_total === 0) {
+        return undefined;
+    }
+
     const target_weight = random() * weight_total;
 
-    const index = binarySearchHighIndex(scratch_weights, target_weight, number_compare_ascending, 0, length - 1);
+    let index = binarySearchHighIndex(scratch_weights, target_weight, number_compare_ascending, 0, length - 1);
+    while (index < length && scratch_weights[index] <= target_weight) {
+        index++;
+    }
 
     return array[index];
 }

package/src/core/collection/heap/BinaryHeap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,6CAHsB,MAAM,EAa3B;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAehB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAanB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}
+{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,6CAHsB,MAAM,EAa3B;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA8BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAehB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAanB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/core/collection/heap/BinaryHeap.js

@@ -159,6 +159,10 @@ class BinaryHeap {
      */
     pop() {
 
+        if (this.length === 0) {
+            return undefined;
+        }
+
         this.length--;
 
         const new_length = this.length;

package/src/core/collection/list/List.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}

package/src/core/collection/list/List.js

@@ -389,7 +389,7 @@ class List {
      * @return {boolean}
      */
     removeOneOf(value) {
-        if (typeof value === "object" && typeof value.equals === "function") {
+        if (value !== null && typeof value === "object" && typeof value.equals === "function") {
             return this.removeOneIf(conditionEqualsViaMethod, value);
         } else {
             return this.removeOneIf(conditionEqualsStrict, value);
@@ -973,7 +973,9 @@ class List {
                 continue;
             }
 
-            if (typeof a === "object" && typeof b === "object" && typeof a.equals === "function" && a.equals(b)) {
+            if (a !== null && b !== null
+                && typeof a === "object" && typeof b === "object"
+                && typeof a.equals === "function" && a.equals(b)) {
                 //test via "equals" method
                 continue;
             }

package/src/core/collection/set/ArraySet.js

@@ -109,7 +109,7 @@ class ArraySet {
      */
     clear() {
         while (!this.isEmpty()) {
-            this.remove(this.data[0]);
+            this.__removeByIndex(0, this.data[0]);
         }
     }
 

package/src/core/collection/set/HashSet.d.ts

@@ -40,7 +40,7 @@ export class HashSet<T> {
     has(value: T): boolean;
     keys(): Iterator<T_1, any, undefined>;
     values(): Iterator<T_1, any, undefined>;
-    entries(): void;
+    entries(): Generator<any[], void, unknown>;
     /**
      *
      * @param {T} value

package/src/core/collection/set/HashSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HashSet.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/set/HashSet.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACI;;OAEG;IACH;;;;OAgBC;IAVG;;;;OAIG;IACH,cAIE;IAGN,mBAEC;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAMhB;IAED,cAEC;IAED;;;;OAIG;IACH,cAHW,CAAC,GACC,OAAO,CAInB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,OAAO,CAInB;IAQD,sCAEC;IAED,wCAEC;IAED,gBAEC;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,yBAHoB,CAAC,QAAE,CAAC,0CAOvB;IAED;;;;OAIG;IACH,cAHW,CAAC,GACA,CAAC,CAWZ;IApDD,mDAIC;CAiDJ;iCAzHgC,wCAAwC;mCADtC,0CAA0C"}
+{"version":3,"file":"HashSet.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/set/HashSet.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACI;;OAEG;IACH;;;;OAgBC;IAVG;;;;OAIG;IACH,cAIE;IAGN,mBAEC;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAMhB;IAED,cAEC;IAED;;;;OAIG;IACH,cAHW,CAAC,GACC,OAAO,CAInB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,OAAO,CAInB;IAQD,sCAEC;IAED,wCAEC;IAED,2CAIC;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,yBAHoB,CAAC,QAAE,CAAC,0CAOvB;IAED;;;;OAIG;IACH,cAHW,CAAC,GACA,CAAC,CAWZ;IAtDD,mDAIC;CAmDJ;iCA3HgC,wCAAwC;mCADtC,0CAA0C"}