extra-iterator 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -3,6 +3,33 @@ interface ArrayIsh<T> {
     length: number;
 }
 export type ExtraIteratorSource<T> = Iterator<T, any, any> | Iterable<T, any, any> | ArrayIsh<T>;
+/**
+ * An extended iterator class that provides additional chainable utility methods for working with iterables.
+ *
+ * @template T The type of values yielded by this iterator.
+ *
+ * @example
+ * // Creating an iterator from an array
+ * const iter = ExtraIterator.from([1, 2, 3, 4, 5]);
+ *
+ * @example
+ * // Creating a sequence of ancestors of a given element
+ * ExtraIterator.from(function*() {
+ *
+ * }()).toArray();
+ * ExtraIterator.from([1, 2, 3, 4, 5])
+ *   .filter(n => n % 2 === 0)
+ *   .map(n => n * 2)
+ *   .toArray()
+ *   // returns [4, 8]
+ *
+ * @example
+ * // Using static factory methods
+ * ExtraIterator.range(1, 5)
+ *   .map(n => n * n)
+ *   .toArray()
+ *   // returns [1, 4, 9, 16]
+ */
 export declare class ExtraIterator<T> extends Iterator<T, any, any> {
     static from<T>(source: ExtraIteratorSource<T>): ExtraIterator<T>;
     static zip<A, B>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>): ExtraIterator<[A, B]>;
@@ -25,6 +52,12 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      * @example ExtraIterator.empty().toArray() // returns []
      */
     static empty<T = any>(): ExtraIterator<T>;
+    /**
+     * Creates an iterator that yields a single value.
+     *
+     * @example ExtraIterator.single(42).toArray() // returns [42]
+     */
+    static single<T>(value: T): ExtraIterator<T>;
     /**
      * Creates an iterator that yields incrementing numbers.
      *
@@ -70,14 +103,30 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      */
     static repeat<T>(value: T): ExtraIterator<T>;
     /**
-     * Generates an infinite sequence of cryptographically strong random bytes using `crypto.getRandomValues`. Each
-     * yielded value is a number in between 0 and 255 (inclusive).
+     * Generates an infinite sequence of random numbers between 0 and 1 (exclusive) using `Math.random` or another
+     * specified random number generator.
      *
      * > ⚠ This iterator is infinite. Use {@link take} method if you want a specific number of values.
      */
-    static random({ bufferSize }?: {
-        bufferSize?: number | undefined;
-    }): ExtraIterator<number>;
+    static random(rng?: () => number): ExtraIterator<number>;
+    /**
+     * Generates an infinite sequence of cryptographically strong random bytes using `crypto.getRandomValues`, in
+     * chunks of `chunkSize` bytes.
+     *
+     * By default, this method reuses the same `ArrayBuffer` instance for each chunk, refilling it with new random
+     * values at each iteration, so you should not keep references to the yielded buffers. Set `reuseBuffer` to `false`
+     * if you want this method to yield copies of the buffer instead.
+     *
+     * If you want a flat sequence of individual byte values instead of chunks, you can chain the iterator returned by
+     * this method with the {@link flatten} method. The resulting iterator will contain interger values from 0 to 255
+     * (inclusive).
+     *
+     * > ⚠ This iterator is infinite. Use {@link take} method if you want a specific number of values.
+     */
+    static randomBytes({ chunkSize, reuseBuffer }?: {
+        chunkSize?: number | undefined;
+        reuseBuffer?: boolean | undefined;
+    }): ExtraIterator<ArrayBuffer>;
     private constructor();
     private source;
     next(value?: any): IteratorResult<T, any>;
@@ -163,11 +212,11 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      * @example
      *
      * ExtraIterator.from([4, 5, 6])
-     *     .prependMany([1, 2, 3])
+     *     .prependAll([1, 2, 3])
      *     .toArray()
      *     // returns [1, 2, 3, 4, 5, 6]
      */
-    prependMany<U>(items: Iterable<U>): ExtraIterator<T | U>;
+    prependAll<U>(items: Iterable<U>): ExtraIterator<T | U>;
     /**
      * Creates a new iterator that invokes the provided callback function over each element of this iterator and yields
      * the elements for which the callback returns `true`, only for as long as the callback returns `true`.
@@ -213,9 +262,9 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
     /**
      * Groups the elements in this iterator into groups of variable size.
      *
-     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. It should
-     * return `true` if the elements should belong to the same group, or `false` if they should belong to different
-     * groups.
+     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. The
+     * function should return `true` if the elements should belong to the same group, or `false` if they should belong
+     * to different groups.
      *
      * The resulting iterator yields arrays of elements that belong to the same group.
      *
@@ -292,7 +341,8 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      */
     splice(startIndex: number, deleteCount: number, ...newItems: T[]): ExtraIterator<T>;
     /**
-     * Returns an iterator the provided element if this iterator is empty; otherwise, it returns this iterator.
+     * If this iterator is empty, returns an iterator with the provided element as its only element; otherwise, it
+     * returns a copy of this iterator.
      */
     defaultIfEmpty(provider: () => T): ExtraIterator<T>;
     /**
@@ -380,8 +430,8 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      *
      * @example
      *
-     * ExtraIterator.from([1, 2, 3]).uniqueness() // returns true
-     * ExtraIterator.from([1, 2, 3, 1]).uniqueness() // returns false
+     * ExtraIterator.from([1, 2, 3]).testUnique() // returns true
+     * ExtraIterator.from([1, 2, 3, 1]).testUnique() // returns false
      */
     testUnique(mapper?: (value: T) => unknown): boolean;
     /**

package/dist/index.js

@@ -1,8 +1,34 @@
+/**
+ * An extended iterator class that provides additional chainable utility methods for working with iterables.
+ *
+ * @template T The type of values yielded by this iterator.
+ *
+ * @example
+ * // Creating an iterator from an array
+ * const iter = ExtraIterator.from([1, 2, 3, 4, 5]);
+ *
+ * @example
+ * // Creating a sequence of ancestors of a given element
+ * ExtraIterator.from(function*() {
+ *
+ * }()).toArray();
+ * ExtraIterator.from([1, 2, 3, 4, 5])
+ *   .filter(n => n % 2 === 0)
+ *   .map(n => n * 2)
+ *   .toArray()
+ *   // returns [4, 8]
+ *
+ * @example
+ * // Using static factory methods
+ * ExtraIterator.range(1, 5)
+ *   .map(n => n * n)
+ *   .toArray()
+ *   // returns [1, 4, 9, 16]
+ */
 export class ExtraIterator extends Iterator {
     // =================================================================================================================
     // STATIC FUNCTIONS
     // =================================================================================================================
-    // TODO Consider using a lib like `make-iterator` to transform things into iterators
     static from(source) {
         if (!(Symbol.iterator in source) && 'length' in source) {
             return new ExtraIterator(function* () {
@@ -29,6 +55,14 @@ export class ExtraIterator extends Iterator {
     static empty() {
         return new ExtraIterator([]);
     }
+    /**
+     * Creates an iterator that yields a single value.
+     *
+     * @example ExtraIterator.single(42).toArray() // returns [42]
+     */
+    static single(value) {
+        return new ExtraIterator([value]);
+    }
     /**
      * Creates an iterator that yields incrementing numbers.
      *
@@ -98,16 +132,37 @@ export class ExtraIterator extends Iterator {
         }());
     }
     /**
-     * Generates an infinite sequence of cryptographically strong random bytes using `crypto.getRandomValues`. Each
-     * yielded value is a number in between 0 and 255 (inclusive).
+     * Generates an infinite sequence of random numbers between 0 and 1 (exclusive) using `Math.random` or another
+     * specified random number generator.
      *
      * > ⚠ This iterator is infinite. Use {@link take} method if you want a specific number of values.
      */
-    static random({ bufferSize = 1024 } = {}) {
-        const buffer = new Uint8Array(bufferSize);
+    static random(rng = Math.random) {
+        return ExtraIterator.from(function* () {
+            while (true) {
+                yield rng();
+            }
+        }());
+    }
+    /**
+     * Generates an infinite sequence of cryptographically strong random bytes using `crypto.getRandomValues`, in
+     * chunks of `chunkSize` bytes.
+     *
+     * By default, this method reuses the same `ArrayBuffer` instance for each chunk, refilling it with new random
+     * values at each iteration, so you should not keep references to the yielded buffers. Set `reuseBuffer` to `false`
+     * if you want this method to yield copies of the buffer instead.
+     *
+     * If you want a flat sequence of individual byte values instead of chunks, you can chain the iterator returned by
+     * this method with the {@link flatten} method. The resulting iterator will contain interger values from 0 to 255
+     * (inclusive).
+     *
+     * > ⚠ This iterator is infinite. Use {@link take} method if you want a specific number of values.
+     */
+    static randomBytes({ chunkSize = 1024, reuseBuffer = true } = {}) {
+        const bytes = new Uint8Array(chunkSize);
         return new ExtraIterator(function* () {
-            globalThis.crypto.getRandomValues(buffer);
-            yield* new Uint8Array(buffer);
+            globalThis.crypto.getRandomValues(bytes);
+            yield reuseBuffer ? bytes.buffer : new Uint8Array(bytes).buffer;
         }())
             .loop();
     }
@@ -140,17 +195,19 @@ export class ExtraIterator extends Iterator {
     take(limit) {
         return limit >= 0
             ? ExtraIterator.from(super.take(limit))
-            : ExtraIterator.from(this.takeLast(-limit));
+            : this.takeLast(-limit);
     }
     takeLast(count) {
-        const result = [];
-        for (let item; item = this.next(), !item.done;) {
-            result.push(item.value);
-            if (result.length > count) {
-                result.shift();
-            }
+        const ringbuffer = new Array(count);
+        let index = 0;
+        for (let item; item = this.next(), !item.done; index = (index + 1) % count) {
+            ringbuffer[index] = item.value;
         }
-        return result;
+        return ExtraIterator.from(function* () {
+            for (let i = index; i < count + index; i++) {
+                yield ringbuffer[i % count];
+            }
+        }());
     }
     drop(count) {
         return count >= 0
@@ -174,7 +231,11 @@ export class ExtraIterator extends Iterator {
      * @example ExtraIterator.from([[1, 2], [3, 4]]).flatten().toArray() // returns [1, 2, 3, 4]
      */
     flatten() {
-        return this.flatMap(value => Array.isArray(value) ? new ExtraIterator(value).flatten() : [value]);
+        return this.flatMap(value => typeof value === 'object'
+            && value !== null
+            && Symbol.iterator in value
+            ? new ExtraIterator(value).flatten()
+            : [value]);
     }
     /**
      * Creates a new iterator that yields the values of this iterator, but won't yield any duplicates.
@@ -271,11 +332,11 @@ export class ExtraIterator extends Iterator {
      * @example
      *
      * ExtraIterator.from([4, 5, 6])
-     *     .prependMany([1, 2, 3])
+     *     .prependAll([1, 2, 3])
      *     .toArray()
      *     // returns [1, 2, 3, 4, 5, 6]
      */
-    prependMany(items) {
+    prependAll(items) {
         return ExtraIterator.from(function* () {
             yield* items;
             yield* this;
@@ -351,9 +412,9 @@ export class ExtraIterator extends Iterator {
     /**
      * Groups the elements in this iterator into groups of variable size.
      *
-     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. It should
-     * return `true` if the elements should belong to the same group, or `false` if they should belong to different
-     * groups.
+     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. The
+     * function should return `true` if the elements should belong to the same group, or `false` if they should belong
+     * to different groups.
      *
      * The resulting iterator yields arrays of elements that belong to the same group.
      *
@@ -373,7 +434,7 @@ export class ExtraIterator extends Iterator {
             let chunk = [first.value];
             for (let left = first, right, index = 0; right = this.next(), !right.done; left = right, index++) {
                 if (predicate(left.value, right.value, index, chunk)) {
-                    chunk.push(left.value);
+                    chunk.push(right.value);
                 }
                 else {
                     yield chunk;
@@ -489,8 +550,7 @@ export class ExtraIterator extends Iterator {
      */
     splice(startIndex, deleteCount, ...newItems) {
         if (startIndex < 0) {
-            return ExtraIterator.from(this.toArray()
-                .toSpliced(startIndex, deleteCount, ...newItems));
+            return ExtraIterator.from(this.toArray().toSpliced(startIndex, deleteCount, ...newItems));
         }
         return ExtraIterator.from(function* () {
             for (let index = 0, next; next = this.next(), !next.done; index++) {
@@ -504,7 +564,8 @@ export class ExtraIterator extends Iterator {
         }.call(this));
     }
     /**
-     * Returns an iterator the provided element if this iterator is empty; otherwise, it returns this iterator.
+     * If this iterator is empty, returns an iterator with the provided element as its only element; otherwise, it
+     * returns a copy of this iterator.
      */
     defaultIfEmpty(provider) {
         return ExtraIterator.from(function* () {
@@ -528,9 +589,6 @@ export class ExtraIterator extends Iterator {
     loop(times = Infinity) {
         return ExtraIterator.from(function* () {
             const values = this.toArray();
-            if (values.length === 0) {
-                return;
-            }
             for (let i = 0; i < times; i++) {
                 yield* values;
             }
@@ -663,8 +721,8 @@ export class ExtraIterator extends Iterator {
      *
      * @example
      *
-     * ExtraIterator.from([1, 2, 3]).uniqueness() // returns true
-     * ExtraIterator.from([1, 2, 3, 1]).uniqueness() // returns false
+     * ExtraIterator.from([1, 2, 3]).testUnique() // returns true
+     * ExtraIterator.from([1, 2, 3, 1]).testUnique() // returns false
      */
     testUnique(mapper) {
         const seen = new Set();

package/dist/index.test.js

@@ -7,12 +7,24 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from(array);
         expect(iterator.toArray()).toEqual(array);
     });
+    it('should create an ExtraIterator from an "array-like" object', () => {
+        const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
+        const iterator = ExtraIterator.from(arrayLike);
+        expect(iterator.toArray()).toEqual(['a', 'b', 'c']);
+    });
     it('should zip two iterators', () => {
         const a = ExtraIterator.from([1, 2, 3]);
         const b = ExtraIterator.from(['a', 'b', 'c']);
-        const zipped = ExtraIterator.zip(a, b);
+        const zipped = a.zip(b);
         expect(zipped.toArray()).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
     });
+    it('should zip three iterators', () => {
+        const a = ExtraIterator.from([1, 2, 3]);
+        const b = ExtraIterator.from(['a', 'b', 'c']);
+        const c = ExtraIterator.from([true, false, true]);
+        const zipped = ExtraIterator.zip(a, b, c);
+        expect(zipped.toArray()).toEqual([[1, 'a', true], [2, 'b', false], [3, 'c', true]]);
+    });
     it('should count from 0 to a given number', () => {
         const iterator = ExtraIterator.count().take(5);
         expect(iterator.toArray()).toEqual([0, 1, 2, 3, 4]);
@@ -25,10 +37,15 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.repeat('x').take(3);
         expect(iterator.toArray()).toEqual(['x', 'x', 'x']);
     });
-    it('should yield random values', () => {
+    it('should yield random numbers', () => {
         const values = ExtraIterator.random().take(10000).toArray();
         expect(values.length).toBe(10000);
-        expect(values.every(value => typeof value === 'number' && value >= 0 && value < 256)).toBe(true);
+        expect(values.every(value => typeof value === 'number' && value >= 0 && value < 1)).toBe(true);
+    });
+    it('should yield random bytes', () => {
+        const values = ExtraIterator.randomBytes({ chunkSize: 1024 }).take(1).map(chunk => new Uint8Array(chunk)).flatten().toArray();
+        expect(values.length).toBe(1024);
+        expect(values.every(value => typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 255)).toBe(true);
     });
     it('should filter values based on a predicate', () => {
         const iterator = ExtraIterator.from([1, 2, 3, 4]).filter(x => x % 2 === 0);
@@ -42,6 +59,10 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from([1, 2, 3, 4]).take(2);
         expect(iterator.toArray()).toEqual([1, 2]);
     });
+    it('should take the last values of the sequence', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).take(-2);
+        expect(iterator.toArray()).toEqual([3, 4]);
+    });
     it('should drop a given number of values', () => {
         const iterator = ExtraIterator.from([1, 2, 3, 4]).drop(2);
         expect(iterator.toArray()).toEqual([3, 4]);
@@ -54,9 +75,19 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from([1, 2, 3]);
         expect(iterator.first()).toBe(1);
     });
-    it('should return the last value', () => {
-        const iterator = ExtraIterator.from([1, 2, 3]);
-        expect(iterator.last()).toBe(3);
+    it('should have a single value', () => {
+        const iterator = ExtraIterator.single(42);
+        expect(iterator.first()).toBe(42);
+    });
+    describe(ExtraIterator.prototype.last.name, () => {
+        it('should return the last value if the iterator is not empty', () => {
+            const iterator = ExtraIterator.from([1, 2, 3]);
+            expect(iterator.last()).toBe(3);
+        });
+        it('should return undefined if the iterator is empty', () => {
+            const iterator = ExtraIterator.empty();
+            expect(iterator.last()).toBeUndefined();
+        });
     });
     it('should return a value at a specific index', () => {
         const iterator = ExtraIterator.from([1, 2, 3]);
@@ -92,6 +123,10 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from([2, 3]).prepend(1);
         expect(iterator.toArray()).toEqual([1, 2, 3]);
     });
+    it('should prepend multiple values to the iterator', () => {
+        const iterator = ExtraIterator.from([4, 5, 6]).prependAll([1, 2, 3]);
+        expect(iterator.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+    });
     it('should append a value to the iterator', () => {
         const iterator = ExtraIterator.from([1, 2]).append(3);
         expect(iterator.toArray()).toEqual([1, 2, 3]);
@@ -114,9 +149,19 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from([1, 2, 3, 4]).splice(1, 2, 5, 6);
         expect(iterator.toArray()).toEqual([1, 5, 6, 4]);
     });
-    it('should provide a default value if the iterator is empty', () => {
-        const iterator = ExtraIterator.empty().defaultIfEmpty(() => 42);
-        expect(iterator.toArray()).toEqual([42]);
+    it('should splice values from the end of the iterator', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).splice(-3, 2, 5, 6);
+        expect(iterator.toArray()).toEqual([1, 5, 6, 4]);
+    });
+    describe('defaultIfEmpty', () => {
+        it('should provide a default value if the iterator is empty', () => {
+            const iterator = ExtraIterator.empty().defaultIfEmpty(() => 42);
+            expect(iterator.toArray()).toEqual([42]);
+        });
+        it('should relay the iterator itself if it is not empty', () => {
+            const iterator = ExtraIterator.from([1, 2, 3]).defaultIfEmpty(() => 42);
+            expect(iterator.toArray()).toEqual([1, 2, 3]);
+        });
     });
     it('should group values by a key', () => {
         const iterator = ExtraIterator.from(['apple', 'banana', 'apricot']);
@@ -171,6 +216,16 @@ describe(ExtraIterator.name, () => {
                 .toArray();
             expect(result).toEqual([[1, 1], [2], [3, 3, 3], [2, 2]]);
         });
+        it('should chunk using a key selector function', () => {
+            const result = ExtraIterator.from(['apple', 'apricot', 'banana', 'avocado'])
+                .chunkWith((lhs, rhs) => lhs[0] === rhs[0])
+                .toArray();
+            expect(result).toEqual([['apple', 'apricot'], ['banana'], ['avocado']]);
+        });
+        it('should build an empty iterator for an empty iterator', () => {
+            const result = ExtraIterator.from([]).chunkWith((lhs, rhs) => lhs === rhs).toArray();
+            expect(result).toEqual([]);
+        });
     });
     it('should create a chain of responsibility function', () => {
         const humanizeDuration = ExtraIterator.from([
@@ -191,9 +246,18 @@ describe(ExtraIterator.name, () => {
         const chain = handlers.toChainOfResponsibilityFunction(next => next());
         expect(() => chain()).toThrow();
     });
-    it('should repeat values', () => {
-        const iterator = ExtraIterator.from([1, 2, 3]).loop(3);
-        expect(iterator.toArray()).toEqual([1, 2, 3, 1, 2, 3, 1, 2, 3]);
+    describe(ExtraIterator.prototype.loop.name, () => {
+        it('should repeat values', () => {
+            const iterator = ExtraIterator.from([1, 2, 3]).loop(3);
+            expect(iterator.toArray()).toEqual([1, 2, 3, 1, 2, 3, 1, 2, 3]);
+        });
+        it('should yield an empty iterator if the count is equal to or lower than 0', () => {
+            expect(ExtraIterator.from([1, 2, 3]).loop(0).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-1).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-3).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-4).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-99999).toArray()).toEqual([]);
+        });
     });
     describe(ExtraIterator.range.name, () => {
         it('should iterate over ranges', () => {
@@ -216,4 +280,42 @@ describe(ExtraIterator.name, () => {
             expect(() => ExtraIterator.range(0, 10, { step: 0 }).toArray()).toThrow();
         });
     });
+    it('should count the number of elements in the iterator', () => {
+        expect(ExtraIterator.from([1, 2, 3]).count()).toBe(3);
+        expect(ExtraIterator.empty().count()).toBe(0);
+    });
+    describe(ExtraIterator.prototype.testUnique.name, () => {
+        it('should return true if all values are unique', () => {
+            expect(ExtraIterator.from([1, 2, 3]).testUnique()).toBe(true);
+        });
+        it('should return false if there are duplicate values', () => {
+            expect(ExtraIterator.from([1, 2, 2, 3]).testUnique()).toBe(false);
+        });
+        it('should return true for an empty iterator', () => {
+            expect(ExtraIterator.empty().testUnique()).toBe(true);
+        });
+    });
+    describe(ExtraIterator.prototype.withEach.name, () => {
+        it('should perform a side effect for each value', () => {
+            const sideEffects = [];
+            const iterator = ExtraIterator.from([1, 2, 3]).withEach(x => void sideEffects.push(x));
+            expect(iterator.toArray()).toEqual([1, 2, 3]);
+            expect(sideEffects).toEqual([1, 2, 3]);
+        });
+        it('should not perform side effects if the iterator is not consumed', () => {
+            const sideEffects = [];
+            ExtraIterator.from([1, 2, 3]).withEach(x => void sideEffects.push(x));
+            expect(sideEffects).toEqual([]);
+        });
+        it('should perform side effects even if the iterator is only partially consumed', () => {
+            const sideEffects = [];
+            const iterator = ExtraIterator.from([1, 2, 3]).withEach(x => void sideEffects.push(x));
+            iterator.next();
+            expect(sideEffects).toEqual([1]);
+        });
+        it('should perform side effects on objects', () => {
+            const iterator = ExtraIterator.from([{ value: 1 }, { value: 2 }, { value: 3 }]).withEach(obj => obj.value *= 2);
+            expect(iterator.toArray()).toEqual([{ value: 2 }, { value: 4 }, { value: 6 }]);
+        });
+    });
 });

package/package.json

@@ -3,7 +3,7 @@
   "description": "An extension of the Iterator class with additional utility helper functions.",
   "author": "Leonardo Raele <leonardoraele@gmail.com>",
   "license": "MIT",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -13,9 +13,11 @@
     "dist"
   ],
   "scripts": {
-    "test": "run-s test:types test:unit",
+    "test": "run-p test:*",
     "test:types": "tsc --noEmit",
     "test:unit": "node --import=tsx --test **/*.test.ts",
+    "coverage": "run-s build coverage:test",
+    "coverage:test": "node --import=tsx --test --experimental-test-coverage",
     "build": "tsc",
     "prebuild": "rimraf dist",
     "prepack": "run-s test build"