@aidc-toolkit/utility 0.9.0 → 0.9.2

package/test/character_set.test.ts

@@ -6,13 +6,12 @@ import {
     CharacterSetCreator,
     Exclusion,
     HEXADECIMAL_CREATOR,
-    IterationHelper,
-    NUMERIC_CREATOR
+    NUMERIC_CREATOR,
+    Sequencer
 } from "../src/index.js";
 
 await i18nInit(I18NEnvironment.CLI, true);
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testCharacterSetCreator(name: string, characterSetCreator: CharacterSetCreator, characterSetSize: number, length: number, excludeFirstZero: boolean, excludeAllNumeric: boolean): void {
     describe(name, () => {
         test("Character set", () => {
@@ -46,7 +45,6 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
             expect(characterSetCreator.exclusionSupport.includes(Exclusion.AllNumeric)).toBe(excludeAllNumeric);
         });
 
-        // eslint-disable-next-line jsdoc/require-jsdoc
         function testCreate(exclusion: Exclusion): void {
             let domain: number;
 
@@ -66,7 +64,7 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
                     break;
             }
 
-            const sequence = IterationHelper.from(characterSetCreator.createSequence(length, 0n, domain, exclusion));
+            const sequence = Iterator.from(characterSetCreator.create(length, new Sequencer(0n, domain), exclusion));
 
             let previousS = "";
 
@@ -78,26 +76,26 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
 
                 expect(s.length).toBe(length);
 
-                expect(characterSetCreator.value(s, exclusion)).toBe(BigInt(index));
+                expect(characterSetCreator.valueFor(s, exclusion)).toBe(BigInt(index));
 
                 sequenceCount++;
             });
 
             expect(sequenceCount).toBe(domain);
 
-            expect(() => characterSetCreator.create(length, domain, exclusion)).toThrow(RangeError);
+            expect(() => characterSetCreator.create(length, domain, exclusion)).toThrow(`Value ${domain} must be less than ${domain}`);
 
-            const sparseSequence = IterationHelper.from(characterSetCreator.createSequence(length, 0n, domain, exclusion, 123456n));
+            const sparseSequence = Iterator.from(characterSetCreator.create(length, new Sequencer(domain - 1, -domain), exclusion, 123456n));
 
             let sequential = true;
-            previousS = "";
+            previousS = "~";
 
             const sequenceSet = new Set<string>();
 
             sequenceCount = 0;
 
             sparseSequence.forEach((s, index) => {
-                sequential = sequential && s > previousS;
+                sequential = sequential && s < previousS;
                 previousS = s;
 
                 expect(s.length).toBe(length);
@@ -105,7 +103,7 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
                 expect(sequenceSet.has(s)).toBe(false);
                 sequenceSet.add(s);
 
-                expect(characterSetCreator.value(s, exclusion, 123456n)).toBe(BigInt(index));
+                expect(characterSetCreator.valueFor(s, exclusion, 123456n)).toBe(BigInt(domain - index - 1));
 
                 sequenceCount++;
             });
@@ -125,12 +123,19 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
                 sparseRandomValues.push(characterSetCreator.create(length, randomValue, exclusion, 123456n));
             }
 
-            expect(Array.from(characterSetCreator.createMultiple(length, randomValues, exclusion))).toStrictEqual(straightRandomValues);
-            expect(Array.from(characterSetCreator.createMultiple(length, randomValues, exclusion, 123456n))).toStrictEqual(sparseRandomValues);
+            expect(Array.from(characterSetCreator.create(length, randomValues, exclusion))).toStrictEqual(straightRandomValues);
+            expect(Array.from(characterSetCreator.create(length, randomValues, exclusion, 123456n))).toStrictEqual(sparseRandomValues);
 
-            expect(() => characterSetCreator.create(length, exclusion, domain, 123456n)).toThrow(RangeError);
+            expect(() => characterSetCreator.create(length, domain, exclusion, 123456n)).toThrow(`Value ${domain} must be less than ${domain}`);
         }
 
+        test("Length", () => {
+            expect(() => characterSetCreator.create(0, 0)).not.toThrow(RangeError);
+            expect(() => characterSetCreator.create(-1, 0)).toThrow("Length -1 must be greater than or equal to 0");
+            expect(() => characterSetCreator.create(40, 0)).not.toThrow(RangeError);
+            expect(() => characterSetCreator.create(41, 0)).toThrow("Length 41 must be less than or equal to 40");
+        });
+
         test("Create sequence", () => {
             testCreate(Exclusion.None);
         });
@@ -139,8 +144,8 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
             test("Create sequence, exclude first zero", () => {
                 testCreate(Exclusion.FirstZero);
 
-                expect(() => characterSetCreator.value("0000", Exclusion.FirstZero)).toThrow(RangeError);
-                expect(() => characterSetCreator.value("1000", Exclusion.FirstZero)).not.toThrow(RangeError);
+                expect(() => characterSetCreator.valueFor("0000", Exclusion.FirstZero)).toThrow("Invalid character '0' at position 1");
+                expect(() => characterSetCreator.valueFor("1000", Exclusion.FirstZero)).not.toThrow(RangeError);
             });
         }
 
@@ -148,17 +153,41 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
             test("Create sequence, exclude all numeric", () => {
                 testCreate(Exclusion.AllNumeric);
 
-                expect(() => characterSetCreator.value("0000", Exclusion.AllNumeric)).toThrow(RangeError);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                expect(() => characterSetCreator.value("000" + characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1), Exclusion.AllNumeric)).not.toThrow(RangeError);
-                expect(() => characterSetCreator.value("9999", Exclusion.AllNumeric)).toThrow(RangeError);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                expect(() => characterSetCreator.value("999" + characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1), Exclusion.AllNumeric)).not.toThrow(RangeError);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Nine is known to be present in the character set.
+                const afterNine = characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1);
+
+                expect(() => characterSetCreator.valueFor("0000", Exclusion.AllNumeric)).toThrow("String must not be all numeric");
+                expect(() => characterSetCreator.valueFor(`000${afterNine}`, Exclusion.AllNumeric)).not.toThrow(RangeError);
+                expect(() => characterSetCreator.valueFor("9999", Exclusion.AllNumeric)).toThrow("String must not be all numeric");
+                expect(() => characterSetCreator.valueFor(`999${afterNine}`, Exclusion.AllNumeric)).not.toThrow(RangeError);
             });
         }
     });
 }
 
+describe("Exclusion", () => {
+    test("First zero", () => {
+        expect(() => new CharacterSetCreator([
+            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
+        ], Exclusion.FirstZero)).not.toThrow(RangeError);
+        expect(() => new CharacterSetCreator([
+            "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"
+        ], Exclusion.FirstZero)).toThrow("Character set must support zero as first character");
+    });
+
+    test("All numeric", () => {
+        expect(() => new CharacterSetCreator([
+            "!", "#", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D"
+        ], Exclusion.AllNumeric)).not.toThrow(RangeError);
+        expect(() => new CharacterSetCreator([
+            "!", "#", "/", "0", "1", "2", "3", "A", "B", "C", "D"
+        ], Exclusion.AllNumeric)).toThrow("Character set must support all numeric characters in sequence");
+        expect(() => new CharacterSetCreator([
+            "!", "#", "/", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "A", "B", "C", "D"
+        ], Exclusion.AllNumeric)).toThrow("Character set must support all numeric characters in sequence");
+    });
+});
+
 testCharacterSetCreator("Numeric", NUMERIC_CREATOR, 10, 4, true, false);
 testCharacterSetCreator("Hexadecimal", HEXADECIMAL_CREATOR, 16, 4, true, true);
 testCharacterSetCreator("Alphabetic", ALPHABETIC_CREATOR, 26, 3, false, false);

package/test/record.test.ts

@@ -1,6 +1,6 @@
-import {I18NEnvironment, i18nInit} from "@aidc-toolkit/core";
-import {describe, expect, test} from "vitest";
-import {RecordValidator} from "../src/index.js";
+import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
+import { describe, expect, test } from "vitest";
+import { RecordValidator } from "../src/index.js";
 
 await i18nInit(I18NEnvironment.CLI, true);
 

package/test/reg_exp.test.ts

@@ -1,6 +1,6 @@
-import {I18NEnvironment, i18nInit} from "@aidc-toolkit/core";
-import {describe, expect, test} from "vitest";
-import {RegExpValidator} from "../src/index.js";
+import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
+import { describe, expect, test } from "vitest";
+import { RegExpValidator } from "../src/index.js";
 
 await i18nInit(I18NEnvironment.CLI, true);
 

package/test/sequencer.test.ts

@@ -0,0 +1,72 @@
+import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
+import { describe, expect, test } from "vitest";
+import { Sequencer } from "../src/index.js";
+
+await i18nInit(I18NEnvironment.CLI, true);
+
+describe("Sequence", () => {
+    const sequencer1 = new Sequencer(10, 20);
+    const sequencer2 = new Sequencer(29, -20);
+
+    test("Structure", () => {
+        expect(sequencer1.startValue).toBe(10n);
+        expect(sequencer1.endValue).toBe(30n);
+        expect(sequencer1.count).toBe(20);
+        expect(sequencer1.minValue).toBe(10n);
+        expect(sequencer1.maxValue).toBe(29n);
+
+        expect(sequencer2.startValue).toBe(29n);
+        expect(sequencer2.endValue).toBe(9n);
+        expect(sequencer2.count).toBe(-20);
+        expect(sequencer2.minValue).toBe(10n);
+        expect(sequencer2.maxValue).toBe(29n);
+    });
+
+    test("Iteration", () => {
+        let expectedValue: bigint;
+        let count: number;
+
+        expectedValue = 10n;
+        count = 0;
+
+        for (const value of Iterator.from(sequencer1)) {
+            expect(value).toBe(expectedValue);
+
+            expectedValue++;
+            count++;
+        }
+
+        expect(count).toBe(20);
+
+        expectedValue = 29n;
+        count = 0;
+
+        for (const value of Iterator.from(sequencer2)) {
+            expect(value).toBe(expectedValue);
+
+            expectedValue--;
+            count++;
+        }
+
+        expect(count).toBe(20);
+    });
+
+    test("Reset", () => {
+        let expectedValue: bigint;
+        let count: number;
+
+        expectedValue = 10n;
+        count = 0;
+
+        sequencer1.reset();
+
+        for (const value of Iterator.from(sequencer1)) {
+            expect(value).toBe(expectedValue);
+
+            expectedValue++;
+            count++;
+        }
+
+        expect(count).toBe(20);
+    });
+});

package/test/transformer.test.ts

@@ -1,6 +1,6 @@
-import {I18NEnvironment, i18nInit} from "@aidc-toolkit/core";
-import {describe, expect, test} from "vitest";
-import { EncryptionTransformer, IdentityTransformer, IterationHelper, Transformer } from "../src/index.js";
+import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
+import { describe, expect, test } from "vitest";
+import { Sequencer, EncryptionTransformer, IdentityTransformer, Transformer } from "../src/index.js";
 
 await i18nInit(I18NEnvironment.CLI, true);
 
@@ -11,7 +11,7 @@ function testTransformer(domain: number, tweak?: number, callback?: (value: bigi
 
     const transformedValuesSet = new Set<bigint>();
 
-    IterationHelper.from(transformer.forwardSequence(0n, domain)).forEach((transformedValue, index) => {
+    Iterator.from(transformer.forward(new Sequencer(0n, domain))).forEach((transformedValue, index) => {
         const indexN = BigInt(index);
 
         if (sequential && transformedValue !== indexN) {
@@ -40,12 +40,14 @@ function testTransformer(domain: number, tweak?: number, callback?: (value: bigi
         transformedRandomValues.push(transformer.forward(randomValue));
     }
 
-    expect(Array.from(transformer.forwardMultiple(randomValues))).toStrictEqual(transformedRandomValues);
+    expect(Array.from(transformer.forward(randomValues))).toStrictEqual(transformedRandomValues);
 
-    expect(() => transformer.forward(BigInt(domain))).toThrow(`Value ${domain} must be less than ${domain}`);
-    expect(() => transformer.forwardSequence(BigInt(domain), 0)).not.toThrow(RangeError);
-    expect(() => transformer.forwardSequence(BigInt(domain) - 1n, 1)).not.toThrow(RangeError);
-    expect(() => transformer.forwardSequence(BigInt(domain), 1)).toThrow(`End value (start value + count - 1) ${domain} must be less than ${domain}`);
+    expect(() => transformer.forward(domain)).toThrow(`Value ${domain} must be less than ${domain}`);
+    expect(() => transformer.forward(new Sequencer(domain, 0))).not.toThrow(RangeError);
+    expect(() => transformer.forward(new Sequencer(domain - 1, 1))).not.toThrow(RangeError);
+    expect(() => transformer.forward(new Sequencer(domain, 1))).toThrow(`Maximum value ${domain} must be less than ${domain}`);
+    expect(() => transformer.forward(new Sequencer(0, -1))).not.toThrow(RangeError);
+    expect(() => transformer.forward(new Sequencer(-1, -1))).toThrow("Minimum value -1 must be greater than or equal to 0");
 }
 
 describe("Identity", () => {
@@ -117,13 +119,9 @@ describe("Encryption", () => {
     });
 
     test("Byte boundary", () => {
-        // eslint-disable-next-line @typescript-eslint/dot-notation
         expect((Transformer.get(256n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(1);
-        // eslint-disable-next-line @typescript-eslint/dot-notation
         expect((Transformer.get(257n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(2);
-        // eslint-disable-next-line @typescript-eslint/dot-notation
         expect((Transformer.get(65536n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(2);
-        // eslint-disable-next-line @typescript-eslint/dot-notation
         expect((Transformer.get(65537n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(3);
 
         testTransformer(256, 1);
@@ -131,7 +129,7 @@ describe("Encryption", () => {
     });
 
     test("Tweak variation", () => {
-        expect(Array.from(Transformer.get(1000, 1235).forwardSequence(0n, 1000))).not.toStrictEqual(Array.from(Transformer.get(1000, 1234).forwardSequence(0n, 1000)));
+        expect(Array.from(Transformer.get(1000, 1235).forward(new Sequencer(0n, 1000)))).not.toStrictEqual(Array.from(Transformer.get(1000, 1234).forward(new Sequencer(0n, 1000))));
     });
 
     test("Consistency", () => {

package/typedoc.json

@@ -6,5 +6,6 @@
   "name": "Utility",
   "entryPoints": [
     "src/index.ts"
-  ]
+  ],
+  "gitRevision": "main"
 }

package/.idea/runConfigurations/Test_iteration.xml

@@ -1,12 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test iteration" type="JavaScriptTestRunnerVitest">
-    <node-interpreter value="project" />
-    <vitest-package value="$PROJECT_DIR$/node_modules/vitest" />
-    <working-dir value="$PROJECT_DIR$" />
-    <vitest-options value="--run" />
-    <envs />
-    <scope-kind value="TEST_FILE" />
-    <test-file value="$PROJECT_DIR$/test/iteration.test.ts" />
-    <method v="2" />
-  </configuration>
-</component>

package/src/iteration.ts

@@ -1,343 +0,0 @@
-/**
- * Iteration source type. The underlying source is an iterable or iterator or a callback to an iterable or iterator.
- */
-export type IterationSource<T> = Iterable<T> | Iterator<T> | (() => (Iterable<T> | Iterator<T>));
-
-/**
- * Iteration proxy class for applying a callback for mapping or filtering.
- */
-class IterationProxy<T, U, V> implements IterableIterator<V> {
-    /**
-     * Proxied iterable iterator.
-     */
-    private readonly _proxiedIterableIterator: IterableIterator<T>;
-
-    /**
-     * Callback for map or filter.
-     */
-    private readonly _callback: (element: T, index: number) => U;
-
-    /**
-     * If true, callback is a predicate for a filter.
-     */
-    private readonly _isPredicate: boolean;
-
-    /**
-     * Index into proxied iterable iterator.
-     */
-    private _index: number;
-
-    /**
-     * Constructor.
-     *
-     * @param proxiedIterableIterator
-     * Proxied iterable iterator.
-     *
-     * @param callback
-     * Callback for map or filter.
-     *
-     * @param isPredicate
-     * If true, callback is a predicate for a filter.
-     */
-    constructor(proxiedIterableIterator: IterableIterator<T>, callback: (element: T, index: number) => U, isPredicate: boolean) {
-        this._proxiedIterableIterator = proxiedIterableIterator;
-        this._callback = callback;
-        this._isPredicate = isPredicate;
-
-        this._index = 0;
-    }
-
-    /**
-     * {@link Iterable} interface implementation.
-     *
-     * @returns
-     * Iterable iterator.
-     */
-    [Symbol.iterator](): IterableIterator<V> {
-        return this;
-    }
-
-    /**
-     * {@link Iterator} interface implementation.
-     *
-     * @param args
-     * Arguments.
-     *
-     * @returns
-     * Next element or number or total number of elements if none.
-     */
-    next(...args: [] | [undefined]): IteratorResult<V, number> {
-        let done = false;
-        let value: V | undefined;
-
-        let callbackDone: boolean;
-
-        do {
-            const proxiedNext = this._proxiedIterableIterator.next(...args);
-
-            if (!(proxiedNext.done ?? false)) {
-                const proxiedValue = proxiedNext.value;
-                const callbackValue = this._callback(proxiedValue, this._index++);
-
-                if (!this._isPredicate) {
-                    // Types U and V are known to be identical.
-                    value = callbackValue as unknown as V;
-
-                    callbackDone = true;
-                } else {
-                    callbackDone = callbackValue as boolean;
-
-                    if (callbackDone) {
-                        // Types T and V are known to be identical.
-                        value = proxiedValue as unknown as V;
-                    }
-                }
-            } else {
-                done = true;
-                callbackDone = true;
-            }
-        } while (!callbackDone);
-
-        return done ?
-            {
-                done: true,
-                value: this._index
-            } :
-            {
-                done: false,
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                value: value!
-            };
-    }
-}
-
-/**
- * Iteration helper. Adds array-like functionality through {@link forEach}, {@link map}, {@link filter}, and
- * {@link reduce} methods. Likely to be refactored as {@link
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helpers | iterator
- * helpers} are more widely deployed.
- */
-export class IterationHelper<T> implements IterableIterator<T> {
-    /**
-     * Iteration source.
-     */
-    private readonly _iterationSource: IterationSource<T>;
-
-    /**
-     * Iterable extracted from iteration source.
-     */
-    private _iterable?: Iterable<T>;
-
-    /**
-     * Iterator extracted from iteration source.
-     */
-    private _iterator?: Iterator<T>;
-
-    /**
-     * Constructor.
-     *
-     * @param iterationSource
-     * Iteration source.
-     */
-    private constructor(iterationSource: IterationSource<T>) {
-        this._iterationSource = iterationSource;
-    }
-
-    /**
-     * Get an iteration helper from an iteration source. If the iteration source is itself an iteration helper, it is
-     * returned verbatim, otherwise a new iteration helper is constructed.
-     *
-     * @param iterationSource
-     * Iteration source.
-     *
-     * @returns
-     * Iteration helper.
-     */
-    static from<T>(iterationSource: IterationSource<T>): IterationHelper<T> {
-        return iterationSource instanceof IterationHelper ? iterationSource as IterationHelper<T> : new IterationHelper(iterationSource);
-    }
-
-    /**
-     * Get the iteration source.
-     */
-    get iterationSource(): IterationSource<T> {
-        return this._iterationSource;
-    }
-
-    /**
-     * Get the iteration source as an iterable.
-     *
-     * @returns
-     * Iterable.
-     */
-    asIterable(): Iterable<T> {
-        if (this._iterable === undefined) {
-            const resolvedIterationSource = typeof this.iterationSource === "function" ? this.iterationSource() : this.iterationSource;
-
-            this._iterable = Symbol.iterator in resolvedIterationSource ?
-                resolvedIterationSource :
-                {
-                    [Symbol.iterator](): Iterator<T> {
-                        return resolvedIterationSource;
-                    }
-                };
-        }
-
-        return this._iterable;
-    }
-
-    /**
-     * Get the iteration source as an array.
-     *
-     * @returns
-     * Array.
-     */
-    asArray(): readonly T[] {
-        const iterable = this.asIterable();
-
-        // Return iterable as array.
-        return Array.isArray(iterable) ? iterable as readonly T[] : Array.from(iterable);
-    }
-
-    /**
-     * Get the iteration source as an iterator.
-     *
-     * @returns
-     * Iterator.
-     */
-    asIterator(): Iterator<T> {
-        if (this._iterator === undefined) {
-            this._iterator = this.asIterable()[Symbol.iterator]();
-        }
-
-        return this._iterator;
-    }
-
-    /**
-     * Get the iteration source as a callback.
-     *
-     * @returns
-     * Callback.
-     */
-    asCallback(): () => IterationSource<T> {
-        return typeof this._iterationSource === "function" ? this._iterationSource : () => this._iterationSource;
-    }
-
-    /**
-     * {@link Iterable} interface implementation.
-     *
-     * @returns
-     * Iterable iterator.
-     */
-    [Symbol.iterator](): IterableIterator<T> {
-        return this;
-    }
-
-    /**
-     * {@link Iterator} interface implementation.
-     *
-     * @param args
-     * Arguments.
-     *
-     * @returns
-     * Next element.
-     */
-    next(...args: [] | [undefined]): IteratorResult<T, unknown> {
-        return this.asIterator().next(...args);
-    }
-
-    /**
-     * Perform an action for each element in the iteration helper.
-     *
-     * @param callback
-     * Callback that processes the element and its index in the iteration sequence.
-     */
-    forEach(callback: (element: T, index: number) => void): void {
-        let index = 0;
-
-        for (const element of this) {
-            callback(element, index++);
-        }
-    }
-
-    /**
-     * Map the iteration helper to another iteration helper by performing an action for each element in the iteration
-     * helper along the way.
-     *
-     * @param callback
-     * Callback that processes the element and its index in the iteration sequence.
-     *
-     * @returns
-     * Iterable iterator over callback results.
-     */
-    map<U>(callback: (element: T, index: number) => U): IterableIterator<U> {
-        return new IterationProxy(this, callback, false);
-    }
-
-    /**
-     * Filter the iteration helper based on the condition specified in a predicate. Each call to `.next()` will iterate
-     * as far as necessary until it reaches an element that satisfies the predicate. Care should be taken when working
-     * with large iterators and infrequently truthy predicates.
-     *
-     * @param predicate
-     * Predicate that processes the element and its index in the iteration sequence.
-     *
-     * @returns
-     * Iterator iterable over elements that satisfy the predicate.
-     */
-    filter(predicate: (element: T, index: number) => boolean): IterableIterator<T> {
-        return new IterationProxy(this, predicate, true);
-    }
-
-    /**
-     * Reduce the iterator to a single value by applying a callback.
-     *
-     * @param callback
-     * Callback that processes the previous return value of the callback, the current value of the iterator, and the
-     * current index. The initial value is considered to be the first element in the iteration helper.
-     *
-     * @returns
-     * Reduced value.
-     */
-    reduce(callback: (previousValue: T, currentValue: T, currentIndex: number) => T): T;
-
-    /**
-     * Reduce the iterator to a single value by applying a callback.
-     *
-     * @param callback
-     * Callback that processes the previous return value of the callback, the current value of the iterator, and the
-     * current index.
-     *
-     * @param initialValue
-     * Initial value, passed as the first previous return value of the callback.
-     *
-     * @returns
-     * Reduced value.
-     */
-    reduce(callback: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T;
-
-    reduce<U>(callback: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue?: U): U {
-        let index = 0;
-        let result = initialValue;
-
-        for (const value of this) {
-            if (index === 0 && initialValue === undefined) {
-                result = value as unknown as U;
-            } else {
-                // Iteration has occurred at least once so result is of the expected type.
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                result = callback(result!, value, index);
-            }
-
-            index++;
-        }
-
-        if (index === 0 && initialValue === undefined) {
-            throw new Error("reduce() of empty iterator with no initial value");
-        }
-
-        // Iteration has occurred at least once so result is of the expected type.
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return result!;
-    }
-}