@aidc-toolkit/utility 0.9.18-beta → 0.9.20-beta

package/README.md

@@ -2,25 +2,169 @@
 
 **Copyright © 2024-2025 Dolphin Data Development Ltd. and AIDC Toolkit contributors**
 
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
-License. You may obtain a copy of the License at
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
 
-    https://www.apache.org/licenses/LICENSE-2.0
+https://www.apache.org/licenses/LICENSE-2.0
 
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 
 ## Overview
 
-⚠️ **This software is in beta**, with production release is scheduled for 2024Q4. To follow the status of that and other
-projects, go to the AIDC Toolkit [projects](https://github.com/orgs/aidc-toolkit/projects) page.
+> [!WARNING]
+> 
+> **This software is in beta**, with production release is scheduled for 2025Q4. To follow the status of this and other projects, go to the AIDC Toolkit [projects](https://github.com/orgs/aidc-toolkit/projects) page.
 
-The AIDC Toolkit `utility` package provides functionality that is not specific to AIDC but is nevertheless required by
-other AIDC Toolkit packages:
+The AIDC Toolkit `utility` package provides classes to manipulate integers and strings, independently of any AIDC problem domain. The package has been designed to maximize performance and minimize memory by reducing many of the typical AIDC requirements, such as serial number generation, to on-demand generation using the JavaScript [`Generator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator) type.
 
-- Number transformation
-- String validation
-- String creation
+To provide the most flexibility and to handle the most significant demands of the AIDC problem domain, the AIDC Toolkit uses the JavaScript `bigint` type, with many functions converting from the lower-range `number` type if provided. This gives applications significant flexibility at a small performance cost inherent in `bigint` operations.
 
-A comprehensive overview of this package may be found in the [AIDC Toolkit
-documentation](https://aidc-toolkit.github.io).
+## Integers
+
+### Sequence
+
+Many of AIDC processes can be reduced to a simple statement about sequences:
+
+* "Give me a million serial numbers for manufacturing."
+* "Generate a handful of GTINs for my new product line."
+* "Label the containers in the shipping area with SSCCs."
+
+Each statement has a quantity and an output. Implicit in them is the requirement that the generated output be unique, not only within itself, but also within any previous outputs generated. A [`Sequence`](https://aidc-toolkit.com/api/Utility/classes/Sequence.html) is simply a utility to generate a sequence of integers given a start value and a count.
+
+> [!TIP]
+> 
+> The AIDC Toolkit is not responsible for maintaining the history of any sequence. It is up to the application to ensure that the start value and count don't overlap with any other start value and count for a sequence used for the same purpose.
+
+#### Creating and using a sequence
+
+1. Create a sequence with a start value and a count. The count is typically positive, which means that the sequence runs from the start value up. If negative, the sequence runs from the start value down.
+    ```typescript
+    // Sequence starts at 33,000 and will iterate 1,000 times.
+    const sequence = new Sequence(33000, 1000);
+    ```
+1. Use the sequence.
+    * Use it in a for loop.
+        ```typescript
+        for (const value of sequence) {
+            console.log(value);
+        }
+        ```
+    * Transform it using an `Iterator` helper method.
+        ```typescript
+        const sum = Iterator.from(sequence).reduce((accumulator, value) => accumulator + value, 0);
+        ```
+    * Pass it to a function.
+        ```typescript
+        // Crate a sequence of 10-character hexadecimal strings.
+        const stringSequence = HEXADECIMAL_STRING_CREATOR.create(10, sequence);
+        ```
+
+### Transformer
+
+A transformer transforms values in a numeric domain to values in a range equal to the domain or to another range defined by a callback function.
+
+There are two types of transformers defined in the AIDC Toolkit: the identity transformer and the encryption transformer. Regardless of the type, before any input value is transformed, it is validated against the domain provided when constructing the transformer; if the input value is less than zero or greater than or equal to the domain, an error is thrown.
+
+The identity transformer simply maps any input value to itself as the output value.
+
+The encryption transformer maps an input value to an output value resulting from repeated shuffle and xor operations defined by a tweak. In cryptography, a tweak is a value that alters an operation to change or "tweak" the output in a predictable and unique way that is hard to reverse engineer. Normally, a tweak works side by side with a password to generate a cryptographic key to ensure that no two systems can produce the same output from the same input and password; each system defines its own tweak and the password is kept by the user. Because the tweak is applied to every encryption operation, it is inherently less secure (e.g., a system administrator may know the tweak but that's not enough to compromise any user's encryption), but for the purposes of the AIDC Toolkit, it is secure enough.
+
+Suppose that you're manufacturing a product that is valuable enough to be of interest to counterfeiters. To protect the product, you want to generate a unique serial number for each one you put on the market. If anyone submits a warranty claim, the serial number will tell you whether the product is legitimate.
+
+You expect that you will manufacture at most 1,000,000 units of the product before releasing an upgrade, so your serial numbers are going to be numeric only and 6 digits long. If you generate the serial numbers in sequence, then generating 10 of them starting from unit 200,000 results in the following: 200000, 200001, 200002, 200003, 200004, 200005, 200006, 200007, 200008, 200009.
+
+```typescript
+// Transformer has a domain of 1,000,000; no tweak means that the identity transformer is used.
+for (const value of Transformer.get(1000000).forward(new Sequence(200000, 10))) {
+    console.log(value);
+}
+```
+
+The sequence is predictable and a counterfeiter can easily guess at valid serial numbers, which will cause problems for distributors and retailers when they see duplicates in the supply chain, problems for your customers who believe they are buying a legitimate product, and problems for you when you can't easily distinguish legitimate from counterfeit.
+
+The first thing you need to do is put some space between your serial numbers, to make guessing difficult. Let's say that in this case you make serial numbers 8 digits long, which means you have 100 times the capacity of serial numbers as of your expected manufacturing run. Next, you use the encryption transformer, with the tweak set to some random value (which you have to save and reuse to ensure that you don't generate any duplicates). Generating 10 serial numbers starting from unit 200,000 results in the following: 14608575, 00118914, 14609085, 00250498, 07625339, 85755635, 41179259, 67532896, 02000912, 19087354.
+
+```typescript
+// Transformer has a domain of 100,000,000; tweak means that the encryption transformer is used.
+for (const value of Transformer.get(100000000, 8675309).forward(new Sequence(200000, 10))) {
+    console.log(value);
+}
+```
+
+The sequence is statistically random and a counterfeiter is highly unlikely to guess at valid serial numbers, which will make detection of illegitimate serial numbers significantly easier for all parties.
+
+### Sequence and Transformer
+
+The [`Transformer`](https://aidc-toolkit.com/api/Utility/classes/Transformer.html) class underlies most AIDC Toolkit operations involved in string creation. The [`forward()`](https://aidc-toolkit.com/api/Utility/classes/Transformer.html#forward) method takes either a single `number` or `bigint` value or an `Iterable<number | bigint>` of values. This provides maximum flexibility, but it comes at a cost. All inputs are validated prior to transformation, which can add to the system load when transforming a large number of values.
+
+When dealing with `Iterable` inputs, transformers will recognize [`Sequence`](https://aidc-toolkit.com/api/Utility/classes/Sequence.html) objects and validate the start value and count at the beginning rather than each value individually as it is transformed. This reduces the number of validations from however many entries there are in an `Iterable` object to two. It also ensures that the client code deals with errors at the very beginning rather than in the middle of its processing.
+
+```mermaid
+flowchart TD
+    ValueOrValuesType{"Value(s) type"}
+        ValueOrValuesType -->|Single value| ValidateSingleValue{{Validate value}}
+            ValidateSingleValue --> ProcessSingleValue[[Process value]]
+            ProcessSingleValue --> Return["Return result(s)"]
+        ValueOrValuesType -->|Iterable| IterableType{Iterable type}
+            IterableType -->|Sequence| ValidateMinimumValue{{Validate minimum value}}
+                ValidateMinimumValue --> ValidateMaximumValue{{Validate maximum value}}
+                ValidateMaximumValue --> ForEachSequenceValue[/For each value\]
+                ForEachSequenceValue --> ProcessSequenceValue[[Process value]]
+                    ProcessSequenceValue --> NextSequenceValue[\Next/]
+                NextSequenceValue -->|Not done| ProcessSequenceValue
+                NextSequenceValue -->|Done| Return
+            IterableType -->|Not Sequence| ForEachIterableValue[/For each value\]
+                ForEachIterableValue --> ValidateIterableValue{{Validate value}}
+                    ValidateIterableValue --> ProcessIterableValue[[Process value]]
+                    ProcessIterableValue --> NextIterableValue[\Next/]
+                NextIterableValue -->|Not done| ValidateIterableValue
+                NextIterableValue -->|Done| Return
+```
+
+## Strings
+
+### String validation
+
+Validation is a requirement for any application. The AIDC Toolkit provides a simple but extensible validation framework built on two interfaces: [`StringValidation`](https://aidc-toolkit.com/api/Utility/interfaces/StringValidation.html) and [`StringValidator`](https://aidc-toolkit.com/api/Utility/interfaces/StringValidator.html). The two are related in that an interface extending `StringValidation` may be passed as a parameter to the [`validate()`](https://aidc-toolkit.com/api/Utility/interfaces/StringValidator#validate.html) method of a class implementing `StringValidator` to restrict validation further than the default. For example, [`CharacterSetValidator`](https://aidc-toolkit.com/api/Utility/classes/CharacterSetValidator.html) accepts a [`CharacterSetValidation`](https://aidc-toolkit.com/api/Utility/interfaces/CharacterSetValidation.html) object that can constrain the length and limit the way numeric values are expressed (e.g., exclude zero as the first character or exclude strings that are all numeric).
+
+The `StringValidation` interface is a placeholder only; it's empty, which, in a structurally typed language like TypeScript, matches any object, so it's up to `StringValidator` implementations to decide what the implementation type should be.
+
+If a string passed to a `validate()` method is valid, the method returns; if not, a [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) is thrown.
+
+#### Predefined validators
+
+The following validator types are predefined:
+
+* [Regular expression](https://aidc-toolkit.com/api/Utility/classes/RegExpValidator.html)
+    * Validates a string against a [regular expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions).
+* [Record](https://aidc-toolkit.com/api/Utility/classes/RecordValidator.html)
+    * Validates a string by looking it up in a [`Record`](https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type) object.
+* [Character set](https://aidc-toolkit.com/api/Utility/classes/CharacterSetValidator.html)
+    * Validates a string by ensuring that each character is within a defined character set, with additional validation parameters optionally constraining the length and limiting the way numeric values are expressed. Predefined character set validators are:
+        * [Numeric (0-9)](https://aidc-toolkit.com/api/Utility/variables/NUMERIC_VALIDATOR.html)
+        * [Hexadecimal (0-9, A-F)](https://aidc-toolkit.com/api/Utility/variables/HEXADECIMAL_VALIDATOR.html)
+        * [Alphabetic (A-Z)](https://aidc-toolkit.com/api/Utility/variables/ALPHABETIC_VALIDATOR.html)
+        * [Alphanumeric (0-9, A-Z)](https://aidc-toolkit.com/api/Utility/variables/ALPHANUMERIC_VALIDATOR.html)
+
+### String creation
+
+String creation varies depending on the type of string being created, so there's no single interface that can be implemented. There is a pattern, however:
+
+* Creation is done via a `create()` method. If the class can create more than one type of string, it can define additional `create*NNN*()` methods as appropriate.
+* The `create()` (or `create*NNN*()`) method is overloaded, with a parameter accepting either a single value to create a single string or multiple values (as `Iterable`) to create multiple strings.
+* If the value to create a string is numeric (`number` or `bigint`), the method uses a [`Transformer`](https://aidc-toolkit.com/api/Utility/classes/Transformer.html) and supports sparse creation.
+    * Because of this, passing in a [`Sequence`](https://aidc-toolkit.com/api/Utility/classes/Sequence.html) is strongly recommended when creating multiple strings.
+
+#### Predefined creators
+
+The following creator types are predefined:
+
+* [Character set](https://aidc-toolkit.com/api/Utility/classes/CharacterSetCreator.html)
+    * Creates strings by mapping numeric (`number` and `bigint`) values to fixed-length string representations using the character set as the "digits" of the string. Predefined character set creators are:
+        * [Numeric (0-9)](https://aidc-toolkit.com/api/Utility/variables/NUMERIC_CREATOR.html)
+        * [Hexadecimal (0-9, A-F)](https://aidc-toolkit.com/api/Utility/variables/HEXADECIMAL_CREATOR.html)
+        * [Alphabetic (A-Z)](https://aidc-toolkit.com/api/Utility/variables/ALPHABETIC_CREATOR.html)
+        * [Alphanumeric (0-9, A-Z)](https://aidc-toolkit.com/api/Utility/variables/ALPHANUMERIC_CREATOR.html)
+
+#### Output restriction
+
+As with string validators, string creators can restrict their output to meet the needs of certain use cases. For example, when creating serial numbers, it may be necessary to generate values that either don't start with a zero (to prevent leading zeros from being dropped by other applications) or that aren't composed entirely of digits (to prevent strings from being interpreted as numbers).

package/dist/character-set.d.ts

@@ -1,4 +1,4 @@
-import type { IndexedCallback } from "./iterable-utility";
+import type { IndexedCallback } from "./iterable-utility.js";
 import type { StringValidation, StringValidator } from "./string.js";
 import { type TransformerInput, type TransformerOutput } from "./transformer.js";
 /**

package/dist/character-set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"character-set.d.ts","sourceRoot":"","sources":["../src/character-set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAe,KAAK,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE9F;;GAEG;AACH,oBAAY,SAAS;IACjB;;OAEG;IACH,IAAI,IAAA;IAEJ;;OAEG;IACH,SAAS,IAAA;IAET;;OAEG;IACH,UAAU,IAAA;CACb;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAElC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEpC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CACnD;AAED;;GAEG;AACH,qBAAa,qBAAsB,YAAW,eAAe,CAAC,sBAAsB,CAAC;IACjF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAazC;IAER;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IAElD;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA8B;IAE/D;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuB;IAEzD;;;;;;;;;OASG;gBACS,YAAY,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,gBAAgB,EAAE,SAAS,SAAS,EAAE;IActF;;OAEG;IACH,IAAI,YAAY,IAAI,SAAS,MAAM,EAAE,CAEpC;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,MAAM,CAE7B;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,SAAS,SAAS,EAAE,CAE3C;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIhC;;;;;;;;OAQG;IACH,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7C;;;;;;;;OAQG;IACH,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC;IAI9D;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAIhC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAQvD;;;;;;;;;OASG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,sBAAsB,GAAG,IAAI;CAoEjE;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,qBAAqB;IAC1D;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,qBAAqB,MAAM;IAE3C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAA6D;IAEhG;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAY7B;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIvC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAE5C;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAS;IAEpD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmC;IAErE;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoB;IAEpD;;;;;;;;;OASG;gBACS,YAAY,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,gBAAgB,EAAE,SAAS,SAAS,EAAE;IAmFtF;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,eAAe;IAiCvB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,iBAAiB,SAAS,gBAAgB,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,SAAS,GAAE,SAA0B,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,eAAe,CAAC,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAuCtR;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,GAAE,SAA0B,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;CA+C9F;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,qBAEL,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAsB,qBAAqB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,mBAAmB,qBAGa,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAA0B,qBAAqB,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,kBAAkB,qBAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAyB,qBAAqB,CAAC;AAEhF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,qBAIY,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAA2B,qBAAqB,CAAC"}
+{"version":3,"file":"character-set.d.ts","sourceRoot":"","sources":["../src/character-set.ts"],"names":[],"mappings":"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"}

package/dist/locale/i18n.d.ts

@@ -1,4 +1,4 @@
-import { type I18NEnvironment } from "@aidc-toolkit/core";
+import { type I18nEnvironment } from "@aidc-toolkit/core";
 import { type i18n, type Resource } from "i18next";
 import { localeStrings as enLocaleStrings } from "./en/locale-strings.js";
 export declare const utilityNS = "aidct_utility";
@@ -23,5 +23,5 @@ export declare const i18nextUtility: i18n;
  * @returns
  * Void promise.
  */
-export declare function i18nUtilityInit(environment: I18NEnvironment, debug?: boolean): Promise<void>;
+export declare function i18nUtilityInit(environment: I18nEnvironment, debug?: boolean): Promise<void>;
 //# sourceMappingURL=i18n.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aidc-toolkit/utility",
-  "version": "0.9.18-beta",
+  "version": "0.9.20-beta",
   "description": "Foundational utilities for AIDC Toolkit",
   "type": "module",
   "main": "dist/index.js",
@@ -27,11 +27,11 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@aidc-toolkit/dev": "^0.9.18-beta",
-    "vitest": "^3.2.2"
+    "@aidc-toolkit/dev": "beta",
+    "vitest": "^4.0.13"
   },
   "dependencies": {
-    "@aidc-toolkit/core": "^0.9.18-beta",
-    "i18next": "^25.2.1"
+    "@aidc-toolkit/core": "beta",
+    "i18next": "^25.6.3"
   }
 }

package/src/character-set.ts

@@ -1,4 +1,4 @@
-import type { IndexedCallback } from "./iterable-utility";
+import type { IndexedCallback } from "./iterable-utility.js";
 import { i18nextUtility } from "./locale/i18n.js";
 import { RegExpValidator } from "./reg-exp.js";
 import type { StringValidation, StringValidator } from "./string.js";

package/src/locale/i18n.ts

@@ -1,4 +1,4 @@
-import { i18nAssertValidResources, i18nCoreInit, type I18NEnvironment } from "@aidc-toolkit/core";
+import { i18nAssertValidResources, i18nCoreInit, type I18nEnvironment } from "@aidc-toolkit/core";
 import i18next, { type i18n, type Resource } from "i18next";
 import { localeStrings as enLocaleStrings } from "./en/locale-strings.js";
 import { localeStrings as frLocaleStrings } from "./fr/locale-strings.js";
@@ -39,6 +39,6 @@ export const i18nextUtility: i18n = i18next.createInstance();
  * @returns
  * Void promise.
  */
-export async function i18nUtilityInit(environment: I18NEnvironment, debug = false): Promise<void> {
+export async function i18nUtilityInit(environment: I18nEnvironment, debug = false): Promise<void> {
     await i18nCoreInit(i18nextUtility, environment, debug, utilityNS, utilityResources);
 }

package/test/character-set.test.ts

@@ -1,4 +1,4 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import {
     ALPHABETIC_CREATOR, ALPHABETIC_VALIDATOR,
@@ -11,7 +11,7 @@ import {
     Sequence
 } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 // Type is used to ensure that testCharacterSet() is not called with creator twice.
 type ValidatorNotCreator<T extends CharacterSetValidator> = T extends CharacterSetCreator ? never : T;

package/test/record.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { i18nUtilityInit, RecordValidator } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 describe("Record validator", () => {
     enum StringEnum {

package/test/reg-exp.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { i18nUtilityInit, RegExpValidator } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 describe("Regular expression validator", () => {
     test("Validation", () => {

package/test/sequence.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { i18nUtilityInit, Sequence } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 describe("Sequence", () => {
     const sequence1 = new Sequence(10, 20);

package/test/transformer.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
-import { afterEach, describe, expect, test } from "vitest";
+import { I18nEnvironment } from "@aidc-toolkit/core";
+import { describe, expect, test } from "vitest";
 import { EncryptionTransformer, i18nUtilityInit, IdentityTransformer, Sequence, Transformer } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 function testTransformer(domain: number, tweak?: number, callback?: (value: bigint, forwardValue: bigint) => void): void {
     const transformer = Transformer.get(domain, tweak);
@@ -52,12 +52,6 @@ function testTransformer(domain: number, tweak?: number, callback?: (value: bigi
     expect(() => transformer.forward(new Sequence(-1, -1))).toThrow("Minimum value -1 must be greater than or equal to 0");
 }
 
-// TODO Remove when https://github.com/vitest-dev/vitest/discussions/6511 resolved.
-afterEach(async () => {
-    // eslint-disable-next-line promise/avoid-new -- Patch.
-    await new Promise(resolve => setImmediate(resolve));
-});
-
 describe("Identity", () => {
     test("Get", () => {
         const transformer = Transformer.get(1000);