cmpstr 3.2.2 → 3.3.0

package/dist/types/CmpStr.d.ts

@@ -98,8 +98,8 @@ export declare class CmpStr<R = MetricRaw> {
     static readonly clearCache: {
         normalizer: typeof Normalizer.clear;
         filter: typeof Filter.clearPipeline;
-        metric: () => void;
-        phonetic: () => void;
+        metric: typeof Metric.clear;
+        phonetic: typeof Phonetic.clear;
     };
     /**
      * Returns a TextAnalyzer instance for the given input string.
@@ -153,7 +153,7 @@ export declare class CmpStr<R = MetricRaw> {
      *
      * @param {string} cond - The condition to met
      * @param {any} [test] - Value to test for
-     * @throws {CmpStrNotFoundError} - If the specified metric or phonetic algorithm is not found
+     * @throws {CmpStrValidationError} - If the specified metric or phonetic algorithm is not found
      * @throws {CmpStrInternalError} - If an unknown condition is specified
      */
     protected assert(cond: string, test?: any): void;
@@ -165,10 +165,11 @@ export declare class CmpStr<R = MetricRaw> {
     protected assertMany(...cond: [string, any?][]): void;
     /**
      * Resolves the options for the CmpStr instance, merging the provided options with
-     * the existing options.
+     * the existing options. Validates them and throws if the options are invalid.
      *
      * @param {CmpStrOptions} [opt] - Optional options to merge
      * @returns {CmpStrOptions} - The resolved options
+     * @throws {CmpStrValidationError} - If the merged options are invalid
      */
     protected resolveOptions(opt?: CmpStrOptions): CmpStrOptions;
     /**
@@ -234,6 +235,7 @@ export declare class CmpStr<R = MetricRaw> {
      * @param {boolean} [raw=false] - Whether to return raw results
      * @param {boolean} [skip=false] - Whether to skip normalization and filtering
      * @returns {T} - The computed metric result
+     * @throws {CmpStrValidationError} - If the options are invalid
      * @throws {CmpStrInternalError} - If the computation fails due to internal errors
      */
     protected compute<T extends MetricResult<R> | CmpStrResult | CmpStrResult[]>(a: MetricInput, b: MetricInput, opt?: CmpStrOptions, mode?: MetricMode, raw?: boolean, skip?: boolean): T;
@@ -260,7 +262,7 @@ export declare class CmpStr<R = MetricRaw> {
      *
      * @returns {CmpStr< R >} - The cloned instance
      */
-    clone: () => CmpStr<R>;
+    clone(): CmpStr<R>;
     /**
      * Resets the instance, clearing all data and options.
      *
@@ -272,6 +274,7 @@ export declare class CmpStr<R = MetricRaw> {
      *
      * @param {CmpStrOptions} opt - The options
      * @returns {this}
+     * @throws {CmpStrValidationError} - If the provided options are invalid
      */
     setOptions(opt: CmpStrOptions): this;
     /**
@@ -279,6 +282,7 @@ export declare class CmpStr<R = MetricRaw> {
      *
      * @param {CmpStrOptions} opt - The options to merge
      * @returns {this}
+     * @throws {CmpStrValidationError} - If the merged options are invalid
      */
     mergeOptions(opt: CmpStrOptions): this;
     /**
@@ -286,7 +290,7 @@ export declare class CmpStr<R = MetricRaw> {
      *
      * @param {string} opt - The serialized options
      * @returns {this}
-     * @throws {CmpStrValidationError} - If the provided string is not valid JSON
+     * @throws {CmpStrValidationError} - If the provided string is not valid JSON or the options are invalid
      */
     setSerializedOptions(opt: string): this;
     /**
@@ -295,6 +299,7 @@ export declare class CmpStr<R = MetricRaw> {
      * @param {string} path - The path to the option
      * @param {any} value - The value to set
      * @returns {this}
+     * @throws {CmpStrValidationError} - If the updated options are invalid
      */
     setOption(path: string, value: any): this;
     /**
@@ -310,59 +315,59 @@ export declare class CmpStr<R = MetricRaw> {
      * @param {boolean} enable - Whether to enable or disable raw output
      * @returns {this}
      */
-    setRaw: (enable: boolean) => this;
+    setRaw(enable: boolean): this;
     /**
      * Sets the similatity metric to use (e.g., 'levenshtein', 'dice').
      *
      * @param {string} name - The metric name
      * @returns {this}
      */
-    setMetric: (name: string) => this;
+    setMetric(name: string): this;
     /**
      * Sets the normalization flags (e.g., 'itw', 'nfc').
      *
      * @param {NormalizeFlags} flags - The normalization flags
      * @returns {this}
      */
-    setFlags: (flags: NormalizeFlags) => this;
+    setFlags(flags: NormalizeFlags): this;
     /**
      * Removes the normalization flags entirely.
      *
      * @return {this}
      */
-    rmvFlags: () => this;
+    rmvFlags(): this;
     /**
      * Sets the pre-processors to use for preparing the input.
      *
      * @param {CmpStrProcessors} opt - The processors to set
      * @returns {this}
      */
-    setProcessors: (opt: CmpStrProcessors) => this;
+    setProcessors(opt: CmpStrProcessors): this;
     /**
      * Removes the processors entirely.
      *
      * @returns {this}
      */
-    rmvProcessors: () => this;
+    rmvProcessors(): this;
     /**
      * Returns the current options object.
      *
      * @returns {CmpStrOptions} - The options
      */
-    getOptions: () => CmpStrOptions;
+    getOptions(): CmpStrOptions;
     /**
      * Returns the options as a JSON string.
      *
      * @returns {string} - The serialized options
      */
-    getSerializedOptions: () => string;
+    getSerializedOptions(): string;
     /**
      * Returns a specific option value by path.
      *
      * @param {string} path - The path to the option
      * @returns {any} - The option value
      */
-    getOption: (path: string) => any;
+    getOption(path: string): any;
     /**
      * ================================================================================-
      * Public core methods for string comparison
@@ -472,6 +477,8 @@ export declare class CmpStr<R = MetricRaw> {
     /**
      * Computes a similarity matrix for the given input array.
      *
+     * Only works for symmetric metrics.
+     *
      * @param {string[]} input - The input array
      * @param {CmpStrOptions} [opt] - Optional options
      * @returns {number[][]} - The similarity matrix

package/dist/types/CmpStrAsync.d.ts

@@ -106,6 +106,7 @@ export declare class CmpStrAsync<R = MetricRaw> extends CmpStr<R> {
      * @param {boolean} [raw=false] - Whether to return raw results
      * @param {boolean} [skip=false] - Whether to skip normalization and filtering
      * @returns {Promise< T >} - The computed metric result
+     * @throws {CmpStrValidationError} - If the options are invalid
      * @throws {CmpStrInternalError} - If the computation fails due to internal errors
      */
     protected computeAsync<T extends MetricResult<R> | CmpStrResult | CmpStrResult[]>(a: MetricInput, b: MetricInput, opt?: CmpStrOptions, mode?: MetricMode, raw?: boolean, skip?: boolean): Promise<T>;
@@ -218,6 +219,8 @@ export declare class CmpStrAsync<R = MetricRaw> extends CmpStr<R> {
     /**
      * Asynchronously computes a similarity matrix for the given input array.
      *
+     * Only works for symmetric metrics.
+     *
      * @param {string[]} input - The input array
      * @param {CmpStrOptions} [opt] - Optional options
      * @returns {Promise< number[][] >} - The similarity matrix

package/dist/types/index.d.ts

@@ -7,7 +7,7 @@
  * filtering, and text analysis. It is designed for both high-level application development
  * and research, offering a unified API for single, batch, and pairwise operations.
  *
- * Version: 3.2.2
+ * Version: 3.3.0
  * Author: Paul Köhler (komed3)
  * License: MIT
  *
@@ -41,12 +41,12 @@
  * For asynchronous workloads, use `CmpStrAsync`, which provides the same API with
  * Promise-based, non-blocking methods for large-scale or I/O-bound operations.
  *
- * @version 3.2.2
+ * @version 3.3.0
  * @author Paul Köhler (komed3)
  * @license MIT
  */
 export * from './utils/Types';
-export type { CmpStrError, CmpStrValidationError, CmpStrNotFoundError, CmpStrUsageError, CmpStrInternalError } from './utils/Errors';
+export type { CmpStrError, CmpStrValidationError, CmpStrNotFoundError, CmpStrUsageError, CmpStrInternalError, ErrorCode } from './utils/Errors';
 export { CmpStr } from './CmpStr';
 export { CmpStrAsync } from './CmpStrAsync';
 export { DiffChecker } from './utils/DiffChecker';

package/dist/types/metric/Metric.d.ts

@@ -56,7 +56,7 @@ export declare abstract class Metric<R = MetricRaw> {
     /**
      * Static method to clear the cache of metric computations.
      */
-    static clear: () => void;
+    static clear(): void;
     /**
      * Swaps two strings and their lengths if the first is longer than the second.
      *
@@ -66,14 +66,14 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {number} n - Length of the second string
      * @returns {[ string, string, number, number ]} - Swapped strings and lengths
      */
-    protected static swap: (a: string, b: string, m: number, n: number) => [string, string, number, number];
+    protected static swap(a: string, b: string, m: number, n: number): [string, string, number, number];
     /**
      * Clamps the similarity result between 0 and 1.
      *
      * @param {number} res - The input similarity to clamp
      * @returns {number} - The clamped similarity (0 to 1)
      */
-    protected static clamp: (res: number) => number;
+    protected static clamp(res: number): number;
     /**
      * Constructor for the Metric class.
      * Initializes the metric with two inputs (strings or arrays of strings) and options.
@@ -167,7 +167,7 @@ export declare abstract class Metric<R = MetricRaw> {
      *
      * @returns {boolean} - True if either input is an array with more than one element
      */
-    isBatch: () => boolean;
+    isBatch(): boolean;
     /**
      * Check if the inputs are in single mode.
      *
@@ -176,7 +176,7 @@ export declare abstract class Metric<R = MetricRaw> {
      *
      * @returns {boolean} - True if both inputs are single strings
      */
-    isSingle: () => boolean;
+    isSingle(): boolean;
     /**
      * Check if the inputs are in pairwise mode.
      *
@@ -196,7 +196,7 @@ export declare abstract class Metric<R = MetricRaw> {
      *
      * @returns {boolean} - True if the metric is symmetric
      */
-    isSymmetrical: () => boolean;
+    isSymmetrical(): boolean;
     /**
      * Determine which mode to run the metric in.
      *
@@ -206,7 +206,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {MetricMode} [mode] - The mode to run the metric in (optional)
      * @returns {MetricMode} - The determined mode
      */
-    whichMode: (mode?: MetricMode) => MetricMode;
+    whichMode(mode?: MetricMode): MetricMode;
     /**
      * Clear the cached results of the metric.
      *
@@ -214,7 +214,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * any previously computed results. It can be useful for re-running the metric
      * with new inputs or options.
      */
-    clear: () => void;
+    clear(): void;
     /**
      * Run the metric computation based on the specified mode.
      *
@@ -237,7 +237,7 @@ export declare abstract class Metric<R = MetricRaw> {
      *
      * @returns {string} - The name of the metric
      */
-    getMetricName: () => string;
+    getMetricName(): string;
     /**
      * Get the result of the metric computation.
      *

package/dist/types/phonetic/Phonetic.d.ts

@@ -49,10 +49,11 @@ export declare abstract class Phonetic {
     protected readonly options: PhoneticOptions;
     protected readonly optKey: string;
     protected readonly map: PhoneticMap;
+    protected readonly ignoreSet: Set<string>;
     /**
      * Static method to clear the cache of indexed words.
      */
-    static clear: () => void;
+    static clear(): void;
     /**
      * Constructor for the Phonetic class.
      *
@@ -124,7 +125,7 @@ export declare abstract class Phonetic {
      * @param {string} word - The input word to be converted
      * @returns {string[]} - An array of characters from the input word
      */
-    protected word2Chars: (word: string) => string[];
+    protected word2Chars(word: string): string[];
     /**
      * Determines whether to exit early based on the current phonetic code length.
      *
@@ -168,7 +169,7 @@ export declare abstract class Phonetic {
      *
      * @returns {string} - The name of the algorithm
      */
-    getAlgoName: () => string;
+    getAlgoName(): string;
     /**
      * Generates a phonetic index for the given input string.
      *

package/dist/types/root.d.ts

@@ -9,7 +9,7 @@
  * Please visit CmpStr's documentation for more information:
  * https://github.com/komed3/cmpstr/wiki/Extending-CmpStr
  *
- * @version 3.2.2
+ * @version 3.3.0
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -31,10 +31,11 @@ export { Metric, MetricCls, MetricRegistry } from './metric';
  *  - PhoneticRegistry: Phonetic registry service for managing phonetic algorithm implementations.
  */
 export { Phonetic, PhoneticCls, PhoneticMappingRegistry, PhoneticRegistry } from './phonetic';
-export * as DeepMerge from './utils/DeepMerge';
+export { DeepMerge } from './utils/DeepMerge';
 export * as CmpStrError from './utils/Errors';
 export { Filter } from './utils/Filter';
 export { Hasher, HashTable } from './utils/HashTable';
+export { OptionsValidator } from './utils/OptionsValidator';
 export { Pool } from './utils/Pool';
 export { Profiler } from './utils/Profiler';
 export { StructuredData } from './utils/StructuredData';

package/dist/types/utils/DeepMerge.d.ts

@@ -2,71 +2,93 @@
  * Deep Merge Utility
  * src/utils/DeepMerge.ts
  *
- * This module provides utility functions for deep merging objects, getting values by path,
- * and setting values by path in a deeply nested object structure.
+ * This module provides the utility class `DeepMerge` for deep merging objects and
+ * manipulating nested properties using path strings. It allows you to get, set,
+ * check, and delete values at deeply nested paths within an object, as well as
+ * merge two objects together while preserving their structure.
  *
  * It supports dot and bracket notation (e.g. `a.b[0].c`) as well as escaped keys.
  *
- * Included functions:
- *  - `get`:   Retrieve a deeply nested value by path
- *  - `set`:   Assign a value to a nested path
- *  - `merge`: Deeply merge two objects
- *  - `has`:   Check whether a path exists
- *  - `rmv`:   Delete a value at a path
- *
  * @module Utils
  * @name DeepMerge
  * @author Paul Köhler
  * @license MIT
  */
 /**
- * Deeply get a value from an object by a path string.
- *
- * @template T - The type of the object to get the value from
- * @template R - The return type of the value
- * @param {T} t - The object to get the value from
- * @param {string} path - The path string, e.g. `a.b.c`
- * @param {any} fb - The default value to return if the path does not exist
- * @returns {R | undefined} - The value at the specified path, otherwise the default value
- */
-export declare function get<T extends Record<string, any>, R = any>(t: T, path: string, fb?: R): R | undefined;
-/**
- * Check if a path exists in an object.
- *
- * @template T - The type of the object to get the value from
- * @param {T} t - The object to check
- * @param {string} path - The path string, e.g. `a.b.c`
- * @returns {boolean} - True if the path exists, otherwise false
- */
-export declare function has<T extends Record<string, any>>(t: T, path: string): boolean;
-/**
- * Deeply set a value in an object by a path string.
- *
- * @template T - The type of the object to get the value from
- * @param {T} t - The object to set the value in
- * @param {string} path - The path string, e.g. `a.b.c`
- * @param {any} value - The value to set at the specified path
- * @returns {T} - The modified object with the value set at the specified path
- * @throws {CmpStrUsageError} - If the path is invalid or if a non-object value is encountered along the path
- */
-export declare function set<T extends Record<string, any>>(t: T, path: string, value: any): T;
-/**
- * Deeply merge two objects, where the second object overrides the first.
- *
- * @template T - The type of the object to get the value from
- * @param {T} t - The target object to merge into
- * @param {T} o - The source object to merge from
- * @param {boolean} [mergeUndefined=false] - Whether to merge undefined values
- * @returns {T} - The merged object
- */
-export declare function merge<T extends Record<string, any>>(t?: T | undefined, o?: T | undefined, mergeUndefined?: boolean): T;
-/**
- * Delete a value at a specified path in an object.
- *
- * @template T - The type of the object to get the value from
- * @param {T} t - The object to delete the value from
- * @param {string} path - The path string, e.g. `a.b.c`
- * @param {boolean} [preserveEmpty=false] - Whether to preserve empty objects/arrays
- * @returns {T} - The modified object with the value deleted at the specified path
+ * DeepMerge class provides static methods for deep merging objects and
+ * manipulating nested properties using path strings.
  */
-export declare function rmv<T extends Record<string, any>>(t: T, path: string, preserveEmpty?: boolean): T;
+export declare class DeepMerge {
+    /** Regular expression to match bracket notation in paths */
+    private static readonly BRACKET_PATTERN;
+    /** Path cache for efficient parsing */
+    private static readonly PATH_CACHE;
+    /**
+     * Walk through an object using an array of keys and return
+     * whether the path exists and its value.
+     *
+     * @param {any} obj - The object to walk through
+     * @param {( string | number )[]} keys - An array of keys representing the path to walk
+     * @returns {{ exists: false } | { exists: true, value: any }} -
+     *      An object indicating whether the path exists and its value if it does
+     */
+    private static walk;
+    /**
+     * Parse a path string into an array of keys.
+     *
+     * @param {string} p - The path string, e.g. `a.b.c` or `a[0].b`
+     * @returns {( string | number )[]} - An array of keys, e.g. `['a', 'b', 'c']` or `['a', 0, 'b']`
+     */
+    static parse(p: string): (string | number)[];
+    /**
+     * Check if a path exists in an object.
+     *
+     * @template T - The type of the object to get the value from
+     * @param {T} t - The object to check
+     * @param {string} path - The path string, e.g. `a.b.c`
+     * @returns {boolean} - True if the path exists, otherwise false
+     */
+    static has<T extends Record<string, any>>(t: T, path: string): boolean;
+    /**
+     * Deeply get a value from an object by a path string.
+     *
+     * @template T - The type of the object to get the value from
+     * @template R - The return type of the value
+     * @param {T} t - The object to get the value from
+     * @param {string} path - The path string, e.g. `a.b.c`
+     * @param {any} fb - The default value to return if the path does not exist
+     * @returns {R | undefined} - The value at the specified path, otherwise the default value
+     */
+    static get<T extends Record<string, any>, R = any>(t: T, path: string, fb?: R): R | undefined;
+    /**
+     * Deeply set a value in an object by a path string.
+     *
+     * @template T - The type of the object to get the value from
+     * @param {T} t - The object to set the value in
+     * @param {string} path - The path string, e.g. `a.b.c`
+     * @param {any} value - The value to set at the specified path
+     * @returns {T} - The modified object with the value set at the specified path
+     * @throws {CmpStrUsageError} - If the path is invalid or if a non-object value is encountered along the path
+     */
+    static set<T extends Record<string, any>>(t: T, path: string, value: any): T;
+    /**
+     * Delete a value at a specified path in an object.
+     *
+     * @template T - The type of the object to get the value from
+     * @param {T} t - The object to delete the value from
+     * @param {string} path - The path string, e.g. `a.b.c`
+     * @param {boolean} [preserveEmpty=false] - Whether to preserve empty objects/arrays
+     * @returns {T} - The modified object with the value deleted at the specified path
+     */
+    static rmv<T extends Record<string, any>>(t: T, path: string, preserveEmpty?: boolean): T;
+    /**
+     * Deeply merge two objects, where the second object overrides the first.
+     *
+     * @template T - The type of the object to get the value from
+     * @param {T} t - The target object to merge into
+     * @param {T} o - The source object to merge from
+     * @param {boolean} [mergeUndefined=false] - Whether to merge undefined values
+     * @returns {T} - The merged object
+     */
+    static merge<T extends Record<string, any>>(t?: T | undefined, o?: T | undefined, mergeUndefined?: boolean): T;
+}

package/dist/types/utils/Errors.d.ts

@@ -17,6 +17,19 @@
  * @license MIT
  */
 import type { CmpStrErrorJSON, CmpStrErrorMeta } from './Types';
+/**
+ * Standardized error codes for CmpStr errors.
+ *
+ * These codes are used in the `code` field of `CmpStrError` instances to allow
+ * for easy programmatic handling of different error types without relying on
+ * string matching of messages or class names.
+ */
+export declare const enum ErrorCode {
+    VALIDATION = "E_VALIDATION",
+    NOT_FOUND = "E_NOT_FOUND",
+    USAGE = "E_USAGE",
+    INTERNAL = "E_INTERNAL"
+}
 /**
  * Base error class for CmpStr.
  *
@@ -28,8 +41,6 @@ export declare class CmpStrError extends Error {
     readonly code: string;
     /** Optional structured metadata for the error */
     readonly meta?: CmpStrErrorMeta;
-    /** Optional cause (native JS Error chaining) */
-    readonly cause?: unknown;
     /** Timestamp when the error was created (ISO 8601) */
     readonly when: string;
     /**
@@ -44,15 +55,21 @@ export declare class CmpStrError extends Error {
      */
     constructor(code: string, message: string, meta?: CmpStrErrorMeta, cause?: unknown);
     /**
-     * Serialize the error into a plain object for JSON output.
+     * Format the error into a readable string, including code, message, and optional metadata.
+     *
+     * @param {boolean} [stack=false] - Whether to include the stack trace in the output
      */
-    toJSON(): CmpStrErrorJSON;
+    format(stack?: boolean): string;
     /**
      * Pretty string representation of the error.
+     */
+    toString(): string;
+    /**
+     * Serialize the error into a plain object for JSON output.
      *
-     * @param {boolean} [stack=false] - Whether to include the stack trace in the output
+     * @param {boolean} [stack=false] - Whether to include the stack trace in the JSON
      */
-    toString(stack?: boolean): string;
+    toJSON(stack?: boolean): CmpStrErrorJSON;
 }
 /**
  * Error thrown when user input (options, arguments) is invalid.
@@ -103,7 +120,7 @@ export declare class ErrorUtil {
      * @param {CmpStrErrorMeta} [meta] - Optional structured metadata for the error
      * @throws {CmpStrInternalError} - Always throws a new `CmpStrInternalError` wrapping the original error
      */
-    static create(err: unknown, message: string, meta?: CmpStrErrorMeta): never;
+    static rethrow(err: unknown, message: string, meta?: CmpStrErrorMeta): never;
     /**
      * Format any error into a readable string.
      *
@@ -130,7 +147,7 @@ export declare class ErrorUtil {
      * @param {() => Promise< T >} fn - The asynchronous function to execute
      * @param {string} message - The error message to use if an exception is thrown
      * @param {CmpStrErrorMeta} [meta] - Optional structured metadata for the error
-     * @return {Promise<T>} A promise that resolves to the result of the function if it executes successfully
+     * @return {Promise< T >} A promise that resolves to the result of the function if it executes successfully
      * @throws {CmpStrInternalError} - If the function throws an error, it will be wrapped and re-thrown as a `CmpStrInternalError`
      */
     static wrapAsync<T>(fn: () => Promise<T>, message: string, meta?: CmpStrErrorMeta): Promise<T>;

package/dist/types/utils/Filter.d.ts

@@ -17,6 +17,8 @@ import type { FilterFn, FilterHooks, FilterOptions } from './Types';
  * The Filter class provides a way to manage and apply filters to strings based on hooks.
  */
 export declare class Filter {
+    /** Filter function that returns the input string unchanged */
+    private static readonly IDENTITY;
     /**
      * A static map to hold all filters.
      * The key is the hook name, and the value is an Map of FilterEntry objects.
@@ -32,6 +34,7 @@ export declare class Filter {
      * If the function is not cached, it compiles it from the active filters.
      *
      * @param {FilterHooks} hook - The name of the hook
+     * @param {boolean} [force=false] - If true, forces recompilation of the pipeline even if it is cached
      * @returns {FilterFn} - The compiled filter function for the hook
      * @throws {CmpStrInternalError} - Throws an error if the pipeline compilation fails
      */
@@ -57,7 +60,7 @@ export declare class Filter {
      */
     static add(hook: FilterHooks, id: string, fn: FilterFn, opt?: FilterOptions): boolean;
     /**
-     * Removes a filter by its hook and id.
+     * Removes a filter from the specified hook by its id.
      *
      * @param {FilterHooks} hook - The name of the hook
      * @param {string} id - The id of the filter

package/dist/types/utils/HashTable.d.ts

@@ -48,11 +48,10 @@ export declare class Hasher {
  * @template T - The type of value to be stored in the hash table (e.g. MetricCompute, string, …)
  */
 export declare class HashTable<K extends string, T> {
-    private readonly LRU;
+    private readonly FIFO;
+    private readonly maxSize;
     /** The max. length of a string to hash, which is set to 2048 characters */
     private static readonly MAX_LEN;
-    /** The max. size of the hash table, which is set to 10,000 */
-    private static readonly TABLE_SIZE;
     /**
      * The internal map to store entries.
      * The key is a string generated from the label and any number of hashed strings.
@@ -62,9 +61,10 @@ export declare class HashTable<K extends string, T> {
     /**
      * Creates an instance of HashTable.
      *
-     * @param {boolean} [LRU=true] - Whether to use Least Recently Used (LRU) eviction policy
+     * @param {boolean} [FIFO=true] - Whether to use FIFO eviction (true) when the table is full
+     * @param {number} [maxSize=10000] - The maximum number of entries in the hash table
      */
-    constructor(LRU?: boolean);
+    constructor(FIFO?: boolean, maxSize?: number);
     /**
      * Generates a unique hash key for any number of string arguments.
      * Return false if any string exceeds the maximum length.
@@ -82,17 +82,18 @@ export declare class HashTable<K extends string, T> {
      * @param {string} key - The key to check
      * @returns {boolean} - True if the key exists, false otherwise
      */
-    has: (key: string) => boolean;
+    has(key: string): boolean;
     /**
      * Retrieves the entry from the hash table by its key.
      *
      * @param {string} key - The key to look up
      * @returns {T | undefined} - The entry if found, undefined otherwise
      */
-    get: (key: string) => T | undefined;
+    get(key: string): T | undefined;
     /**
      * Adds an entry to the hash table.
-     * If the table is full, it evicts the least recently used entry (if LRU is enabled).
+     * If the table is full, it evicts the least recently used entry
+     * (if FIFO is enabled) or returns false.
      *
      * @param {string} key - The hashed key for the entry
      * @param {T} entry - The entry itself to add
@@ -106,16 +107,16 @@ export declare class HashTable<K extends string, T> {
      * @param {string} key - The key of the entry to delete
      * @returns {boolean} - True if the entry was deleted, false if the key was not found
      */
-    delete: (key: string) => boolean;
+    delete(key: string): boolean;
     /**
      * Clears the hash table.
      * This method removes all entries from the hash table.
      */
-    clear: () => void;
+    clear(): void;
     /**
      * Returns the current size of the hash table.
      *
      * @returns {number} - The number of entries in the hash table
      */
-    size: () => number;
+    size(): number;
 }

package/dist/types/utils/Normalizer.d.ts

@@ -66,10 +66,11 @@ export declare class Normalizer {
      *
      * @param {string | string[]} input - The string or array of strings to normalize
      * @param {NormalizeFlags} flags - A string of characters representing the normalization steps
+     * @param {NormalizeFlags} [normalizedFlags] - Optional pre-canonicalized flags to avoid redundant canonicalization
      * @returns {string | string[]} - The normalized string(s)
      * @throws {CmpStrInternalError} - Throws an error if the normalization process fails
      */
-    static normalize(input: string | string[], flags: NormalizeFlags): string | string[];
+    static normalize(input: string | string[], flags: NormalizeFlags, normalizedFlags?: NormalizeFlags): string | string[];
     /**
      * Asynchronously normalizes the input string or array of strings based on the
      * provided flags. This method is useful for handling large inputs or when