@aidc-toolkit/utility 0.9.0 → 0.9.1

package/src/transformer.ts

@@ -1,5 +1,5 @@
-import { IterationHelper, type IterationSource } from "./iteration.js";
 import i18next, { utilityNS } from "./locale/i18n.js";
+import { Sequencer } from "./sequencer.js";
 
 /**
  * Transformation callback, used to convert transformed value to its final value.
@@ -52,15 +52,15 @@ export abstract class Transformer {
      * @param domain
      * Domain.
      */
-    constructor(domain: bigint) {
-        if (domain <= 0n) {
+    constructor(domain: number | bigint) {
+        this._domain = BigInt(domain);
+
+        if (this._domain <= 0n) {
             throw new RangeError(i18next.t("Transformer.domainMustBeGreaterThanZero", {
                 ns: utilityNS,
                 domain
             }));
         }
-
-        this._domain = BigInt(domain);
     }
 
     /**
@@ -108,30 +108,23 @@ export abstract class Transformer {
     }
 
     /**
-     * Validate that a start value and count are within the domain.
+     * Validate that a value is within the domain.
      *
-     * @param startValue
-     * Start value of range to validate.
-     *
-     * @param count
-     * Number of entries in the range to validate or 1 if undefined.
-     *
-     * @throws RangeError
+     * @param value
+     * Value.
      */
-    private validate(startValue: bigint, count?: number): void {
-        if (startValue < 0n) {
-            throw new RangeError(i18next.t(count === undefined ? "Transformer.valueMustBeGreaterThanOrEqualToZero" : "Transformer.startValueMustBeGreaterThanOrEqualToZero", {
+    private validate(value: bigint): void {
+        if (value < 0n) {
+            throw new RangeError(i18next.t("Transformer.valueMustBeGreaterThanOrEqualToZero", {
                 ns: utilityNS,
-                startValue
+                value
             }));
         }
 
-        const endValue = count === undefined ? startValue : startValue + BigInt(count - 1);
-
-        if (endValue >= this.domain) {
-            throw new RangeError(i18next.t(count === undefined ? "Transformer.valueMustBeLessThan" : "Transformer.endValueMustBeLessThan", {
+        if (value >= this.domain) {
+            throw new RangeError(i18next.t("Transformer.valueMustBeLessThan", {
                 ns: utilityNS,
-                endValue,
+                value,
                 domain: this.domain
             }));
         }
@@ -157,13 +150,13 @@ export abstract class Transformer {
      * @returns
      * Transformed value.
      */
-    forward(value: bigint): bigint;
+    forward(value: number | bigint): bigint;
 
     /**
      * Transform a value forward.
      *
      * @template T
-     * Type returned by transformation callback or bigint if none.
+     * Type returned by transformation callback.
      *
      * @param value
      * Value.
@@ -174,118 +167,126 @@ export abstract class Transformer {
      * @returns
      * Value transformed into object.
      */
-    forward<T>(value: bigint, transformationCallback: TransformationCallback<T>): T;
-
-    forward<T>(value: bigint, transformationCallback?: TransformationCallback<T>): bigint | T {
-        this.validate(value);
+    forward<T>(value: number | bigint, transformationCallback: TransformationCallback<T>): T;
 
-        const transformedValue = this.doForward(value);
-
-        return transformationCallback === undefined ? transformedValue : transformationCallback(transformedValue, 0);
-    }
+    /**
+     * Transform values forward.
+     *
+     * @param values
+     * Values. If this is an instance of {@link Sequencer}, the minimum and maximum values are validated prior to
+     * transformation. Otherwise, the individual values are validated at the time of transformation.
+     *
+     * @returns
+     * Transformed values.
+     */
+    forward(values: Iterable<number | bigint>): IterableIterator<bigint>;
 
     /**
-     * Do the work for the forward sequence method. Parameters are as defined in the public methods.
+     * Transform values forward.
      *
      * @template T
-     * See public methods.
+     * Type returned by transformation callback.
      *
-     * @param startValue
-     * See public methods.
-     *
-     * @param count
-     * See public methods.
+     * @param values
+     * Values. If this is an instance of {@link Sequencer}, the minimum and maximum values are validated prior to
+     * transformation. Otherwise, the individual values are validated at the time of transformation.
      *
      * @param transformationCallback
-     * See public methods.
+     * Called after each value is transformed to convert it to its final value.
      *
-     * @yields
-     * Transformed value optionally defined by transformation callback.
+     * @returns
+     * Values transformed into objects.
      */
-    private * doForwardSequence<T>(startValue: bigint, count: number, transformationCallback?: TransformationCallback<T>): Generator<bigint | T> {
-        for (let index = 0, value = startValue; index < count; index++, value++) {
-            const transformedValue = this.doForward(value);
-
-            yield transformationCallback !== undefined ? transformationCallback(transformedValue, index) : transformedValue;
-        }
-    }
+    forward<T>(values: Iterable<number | bigint>, transformationCallback: TransformationCallback<T>): IterableIterator<T>;
 
     /**
-     * Transform a sequence of values forward.
+     * Transform a value or values forward. This signature exists to allow similar overloaded methods in other classes
+     * to call this method correctly.
      *
-     * @param startValue
-     * Numerical value of the first object. Objects are created from `startValue` to `startValue + count - 1`.
+     * @param valueOrValues
      *
-     * @param count
-     * Number of objects to create.
-     *
-     * @yields
-     * Transformed value.
+     * @returns
      */
-    forwardSequence(startValue: bigint, count: number): IterableIterator<bigint>;
+    forward(valueOrValues: number | bigint | Iterable<number | bigint>): bigint | IterableIterator<bigint>;
 
     /**
-     * Transform a sequence of values forward.
+     * Transform a value or values forward. This signature exists to allow similar overloaded methods in other classes
+     * to call this method correctly.
      *
      * @template T
-     * Type returned by transformation callback or bigint if none.
-     *
-     * @param startValue
-     * Numerical value of the first object. Objects are created from `startValue` to `startValue + count - 1`.
      *
-     * @param count
-     * Number of objects to create.
+     * @param valueOrValues
      *
      * @param transformationCallback
-     * Transformation callback called after the value is transformed to convert it to its final value.
      *
      * @returns
-     * Iterable iterator over transformed values as defined by transformation callback.
      */
-    forwardSequence<T>(startValue: bigint, count: number, transformationCallback: TransformationCallback<T>): IterableIterator<T>;
-
-    forwardSequence<T>(startValue: bigint, count: number, transformationCallback?: TransformationCallback<T>): IterableIterator<bigint | T> {
-        this.validate(startValue, count);
-
-        return this.doForwardSequence(startValue, count, transformationCallback);
-    }
+    forward<T>(valueOrValues: number | bigint | Iterable<number | bigint>, transformationCallback: TransformationCallback<T>): T | IterableIterator<T>;
 
     /**
-     * Transform multiple values forward.
-     *
-     * @param valuesSource
-     * Source of values.
-     *
-     * @returns
-     * Iterable iterator over transformed values.
-     */
-    forwardMultiple(valuesSource: IterationSource<bigint>): IterableIterator<bigint>;
-
-    /**
-     * Transform multiple values forward.
+     * Transform a value or values forward.
      *
      * @template T
-     * Type returned by transformation callback or bigint if none.
+     * Type returned by transformation callback.
      *
-     * @param valuesSource
-     * Source of values.
+     * @param valueOrValues
+     * Value(s).
      *
      * @param transformationCallback
-     * Transformation callback called after the value is transformed to convert it to its final value.
+     * Called after value(s) is/are transformed to convert it/them to its/their final value(s).
      *
      * @returns
-     * Iterable iterator over transformed values as defined by transformation callback.
+     * Value(s) transformed into object(s).
      */
-    forwardMultiple<T>(valuesSource: IterationSource<bigint>, transformationCallback: TransformationCallback<T>): IterableIterator<T>;
+    forward<T>(valueOrValues: number | bigint | Iterable<number | bigint>, transformationCallback?: TransformationCallback<T>): bigint | T | IterableIterator<bigint> | IterableIterator<T> {
+        let result: bigint | T | IterableIterator<bigint> | IterableIterator<T>;
 
-    forwardMultiple<T>(valuesSource: IterationSource<bigint>, transformationCallback?: TransformationCallback<T>): IterableIterator<bigint | T> {
-        return IterationHelper.from(valuesSource).map((value, index) => {
-            this.validate(value);
+        if (typeof valueOrValues !== "object") {
+            const valueN = BigInt(valueOrValues);
 
-            const transformedValue = this.doForward(value);
+            this.validate(valueN);
 
-            return transformationCallback !== undefined ? transformationCallback(transformedValue, index) : transformedValue;
-        });
+            const transformedValue = this.doForward(valueN);
+
+            result = transformationCallback === undefined ? transformedValue : transformationCallback(transformedValue, 0);
+        } else if (valueOrValues instanceof Sequencer) {
+            if (valueOrValues.minValue < 0n) {
+                throw new RangeError(i18next.t("Transformer.minValueMustBeGreaterThanOrEqualToZero", {
+                    ns: utilityNS,
+                    minValue: valueOrValues.minValue
+                }));
+            }
+
+            if (valueOrValues.maxValue >= this.domain) {
+                throw new RangeError(i18next.t("Transformer.maxValueMustBeLessThan", {
+                    ns: utilityNS,
+                    maxValue: valueOrValues.maxValue,
+                    domain: this.domain
+                }));
+            }
+
+            result = transformationCallback === undefined ?
+                Iterator.from(valueOrValues).map(value => this.doForward(value)) :
+                Iterator.from(valueOrValues).map((value, index) => transformationCallback(this.doForward(value), index));
+        } else {
+            result = transformationCallback === undefined ?
+                Iterator.from(valueOrValues).map((value) => {
+                    const valueN = BigInt(value);
+
+                    this.validate(valueN);
+
+                    return this.doForward(valueN);
+                }) :
+                Iterator.from(valueOrValues).map((value, index) => {
+                    const valueN = BigInt(value);
+
+                    this.validate(valueN);
+
+                    return transformationCallback(this.doForward(valueN), index);
+                });
+        }
+
+        return result;
     }
 
     /**
@@ -308,10 +309,12 @@ export abstract class Transformer {
      * @returns
      * Value.
      */
-    reverse(transformedValue: bigint): bigint {
-        this.validate(transformedValue);
+    reverse(transformedValue: number | bigint): bigint {
+        const transformedValueN = BigInt(transformedValue);
+
+        this.validate(transformedValueN);
 
-        return this.doReverse(transformedValue);
+        return this.doReverse(transformedValueN);
     }
 }
 
@@ -319,10 +322,16 @@ export abstract class Transformer {
  * Identity transformer. Values are transformed to themselves.
  */
 export class IdentityTransformer extends Transformer {
+    /**
+     * @inheritDoc
+     */
     protected doForward(value: bigint): bigint {
         return value;
     }
 
+    /**
+     * @inheritDoc
+     */
     protected doReverse(transformedValue: bigint): bigint {
         return transformedValue;
     }
@@ -402,7 +411,7 @@ export class EncryptionTransformer extends Transformer {
      * @param tweak
      * Tweak.
      */
-    constructor(domain: bigint, tweak: bigint) {
+    constructor(domain: number | bigint, tweak: number | bigint) {
         super(domain);
 
         if (tweak < 0n) {
@@ -415,19 +424,19 @@ export class EncryptionTransformer extends Transformer {
         let domainBytes = 0;
 
         // The number of bytes in the domain determines the size of the shuffle and xor operations.
-        for (let reducedDomainMinusOne = domain - 1n; reducedDomainMinusOne !== 0n; reducedDomainMinusOne = reducedDomainMinusOne >> 8n) {
+        for (let reducedDomainMinusOne = this.domain - 1n; reducedDomainMinusOne !== 0n; reducedDomainMinusOne = reducedDomainMinusOne >> 8n) {
             domainBytes++;
         }
 
         this._domainBytes = domainBytes;
-        this._tweak = tweak;
+        this._tweak = BigInt(tweak);
 
         const xorBytes = new Array<number>();
         const bits = new Array<number>();
         const inverseBits = new Array<number>();
 
         // Key is the product of domain, tweak, and an 8-digit prime to force at least four rounds.
-        for (let reducedKey = domain * tweak * 603868999n; reducedKey !== 0n; reducedKey = reducedKey >> 8n) {
+        for (let reducedKey = this.domain * this.tweak * 603868999n; reducedKey !== 0n; reducedKey = reducedKey >> 8n) {
             // Extract least-significant byte.
             const keyByte = Number(reducedKey & 0xFFn);
 
@@ -618,6 +627,9 @@ export class EncryptionTransformer extends Transformer {
         });
     }
 
+    /**
+     * @inheritDoc
+     */
     protected doForward(value: bigint): bigint {
         let bytes = this.valueToBytes(value);
         let transformedValue: bigint;
@@ -635,6 +647,9 @@ export class EncryptionTransformer extends Transformer {
         return transformedValue;
     }
 
+    /**
+     * @inheritDoc
+     */
     protected doReverse(transformedValue: bigint): bigint {
         let bytes = this.valueToBytes(transformedValue);
         let value: bigint;

package/test/character_set.test.ts

@@ -2,11 +2,10 @@ import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import {
     ALPHABETIC_CREATOR,
-    ALPHANUMERIC_CREATOR,
+    ALPHANUMERIC_CREATOR, Sequencer,
     CharacterSetCreator,
     Exclusion,
     HEXADECIMAL_CREATOR,
-    IterationHelper,
     NUMERIC_CREATOR
 } from "../src/index.js";
 
@@ -66,7 +65,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 +77,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 +104,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 +124,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 +145,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,12 +154,12 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
             test("Create sequence, exclude all numeric", () => {
                 testCreate(Exclusion.AllNumeric);
 
-                expect(() => characterSetCreator.value("0000", Exclusion.AllNumeric)).toThrow(RangeError);
+                expect(() => characterSetCreator.valueFor("0000", Exclusion.AllNumeric)).toThrow("String must not be all numeric");
                 // 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);
+                expect(() => characterSetCreator.valueFor("000" + characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1), Exclusion.AllNumeric)).not.toThrow(RangeError);
+                expect(() => characterSetCreator.valueFor("9999", Exclusion.AllNumeric)).toThrow("String must not be all numeric");
                 // 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);
+                expect(() => characterSetCreator.valueFor("999" + characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1), Exclusion.AllNumeric)).not.toThrow(RangeError);
             });
         }
     });

package/test/record.test.ts

@@ -1,10 +1,11 @@
-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);
 
 describe("Record validator", () => {
+    // eslint-disable-next-line jsdoc/require-jsdoc
     enum StringEnum {
         ValueA = "A",
         ValueB = "B",

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);
 
@@ -34,6 +34,7 @@ describe("Regular expression validator", () => {
     test("Error message", () => {
         expect(() => {
             new class extends RegExpValidator {
+                // eslint-disable-next-line jsdoc/require-jsdoc
                 protected override createErrorMessage(s: string): string {
                     return `Failed to validate "${s}"`;
                 }

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,9 +1,10 @@
-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);
 
+// eslint-disable-next-line jsdoc/require-jsdoc
 function testTransformer(domain: number, tweak?: number, callback?: (value: bigint, forwardValue: bigint) => void): void {
     const transformer = Transformer.get(domain, tweak);
 
@@ -11,7 +12,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 +41,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", () => {
@@ -131,7 +134,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>