@woosh/meep-engine 3.41.0 → 3.42.0

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"}

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

@@ -81,8 +81,10 @@ export class HashSet {
         return this.__map.keys();
     }
 
-    entries() {
-        throw new Error('Not implemented');
+    * entries() {
+        for (const value of this.values()) {
+            yield [value, value];
+        }
     }
 
     /**

package/src/core/debug/matchers/IsEqual.js

@@ -32,7 +32,7 @@ export class IsEqual extends BaseMatcher {
             return Array.isArray(expected) && isArrayEqualStrict(actual, expected);
         }
 
-        if (typeof actual === "object" && typeof expected === "object" && typeof actual.equals === "function") {
+        if (expected !== null && typeof actual === "object" && typeof expected === "object" && typeof actual.equals === "function") {
 
             return actual.equals(expected);
 

package/src/core/debug/matchers/IsIterableContaining.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IsIterableContaining.d.ts","sourceRoot":"","sources":["../../../../../src/core/debug/matchers/IsIterableContaining.js"],"names":[],"mappings":"AAGA;IAMI;;;OAGG;IACH,8BAIC;IAED,oEA+BC;IAgBD,mCAMC;;CACJ;4BAzE2B,mBAAmB;gCACf,uBAAuB"}
+{"version":3,"file":"IsIterableContaining.d.ts","sourceRoot":"","sources":["../../../../../src/core/debug/matchers/IsIterableContaining.js"],"names":[],"mappings":"AAGA;IAMI;;;OAGG;IACH,8BAIC;IAED,oEAgCC;IAED,mCAMC;;CACJ;4BA5D2B,mBAAmB;gCACf,uBAAuB"}

package/src/core/debug/matchers/IsIterableContaining.js

@@ -1,74 +1,61 @@
-import { BaseMatcher } from "../BaseMatcher.js";
-import { NullDescription } from "../NullDescription.js";
-
-export class IsIterableContaining extends BaseMatcher {
-    /**
-     * @type {Matcher}
-     */
-    #element_matcher
-
-    /**
-     *
-     * @param {Matcher} matcher
-     */
-    constructor(matcher) {
-        super();
-
-        this.#element_matcher = matcher;
-    }
-
-    matches(item, mismatch_description = NullDescription.INSTANCE) {
-        if (this.#isEmpty(item)) {
-            mismatch_description.appendText("was empty");
-            return false;
-        }
-
-        for (const itemElement of item) {
-            if (this.#element_matcher.matches(itemElement, NullDescription.INSTANCE)) {
-                return true;
-            }
-        }
-
-        mismatch_description.appendText("mismatches were: [");
-
-        let is_past_first = false;
-
-        for (const itemElement of item) {
-            if (is_past_first) {
-                mismatch_description.appendText(", ");
-            }
-
-            this.#element_matcher.describeMismatch(item, mismatch_description);
-
-            is_past_first = true;
-        }
-
-
-        mismatch_description.appendText("]");
-
-        return false;
-
-    }
-
-    /**
-     *
-     * @param {Iterable} iterable
-     * @return {boolean}
-     */
-    #isEmpty(iterable) {
-        const iterator = iterable[Symbol.iterator]();
-
-        const el = iterator.next();
-
-        return el.done === true;
-    }
-
-
-    describeTo(description) {
-
-        description
-            .appendText("a collection containing ")
-            .appendDescriptionOf(this.#element_matcher);
-
-    }
-}
+import { BaseMatcher } from "../BaseMatcher.js";
+import { NullDescription } from "../NullDescription.js";
+
+export class IsIterableContaining extends BaseMatcher {
+    /**
+     * @type {Matcher}
+     */
+    #element_matcher
+
+    /**
+     *
+     * @param {Matcher} matcher
+     */
+    constructor(matcher) {
+        super();
+
+        this.#element_matcher = matcher;
+    }
+
+    matches(item, mismatch_description = NullDescription.INSTANCE) {
+        const mismatches = [];
+
+        for (const itemElement of item) {
+            if (this.#element_matcher.matches(itemElement, NullDescription.INSTANCE)) {
+                return true;
+            }
+
+            mismatches.push(itemElement);
+        }
+
+        if (mismatches.length === 0) {
+            mismatch_description.appendText("was empty");
+            return false;
+        }
+
+        mismatch_description.appendText("mismatches were: [");
+
+        let is_past_first = false;
+
+        for (const itemElement of mismatches) {
+            if (is_past_first) {
+                mismatch_description.appendText(", ");
+            }
+
+            this.#element_matcher.describeMismatch(itemElement, mismatch_description);
+            is_past_first = true;
+        }
+
+        mismatch_description.appendText("]");
+
+        return false;
+    }
+
+    describeTo(description) {
+
+        description
+            .appendText("a collection containing ")
+            .appendDescriptionOf(this.#element_matcher);
+
+    }
+}