cmpstr 3.2.0 → 3.2.2

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

@@ -8,7 +8,8 @@
  * entirely, including gaps. It is commonly used in bioinformatics for sequence
  * alignment.
  *
- * @module Metric/NeedlemanWunsch
+ * @module Metric
+ * @name NeedlemanWunsch
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -12,7 +12,8 @@
  * This metric is widely used in approximate string matching, information retrieval,
  * and computational linguistics.
  *
- * @module Metric/QGramSimilarity
+ * @module Metric
+ * @name QGramSimilarity
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -10,7 +10,8 @@
  * algorithm compares segments of all possible lengths and optimizes the similarity
  * measure.
  *
- * @module Metric/SmithWatermanDistance
+ * @module Metric
+ * @name SmithWatermanDistance
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -24,6 +24,7 @@
  * pooling system to manage resources effectively, ensuring minimal overhead
  * and maximum performance.
  *
+ * @module Metric
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -12,7 +12,8 @@
  * It converts words into a standardized phonetic code, allowing for variations
  * in spelling and pronunciation to be matched.
  *
- * @module Phonetic/Caverphone
+ * @module Phonetic
+ * @name Caverphone
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -17,7 +17,8 @@
  * The Cologne phonetic algorithm works by mapping letters to digits, ignoring
  * certain letters, and applying specific rules to handle character combinations.
  *
- * @module Phonetic/Cologne
+ * @module Phonetic
+ * @name Cologne
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -14,7 +14,8 @@
  * transform input words into their Metaphone code. The algorithm drops or transforms
  * letters according to context-sensitive rules, and only retains vowels at the start.
  *
- * @module Phonetic/Metaphone
+ * @module Phonetic
+ * @name Metaphone
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -19,6 +19,7 @@
  * phonetic algorithms by extending the abstract class.
  *
  * @module Phonetic
+ * @name Phonetic
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -60,7 +61,7 @@ export declare abstract class Phonetic {
      *
      * @param {string} algo - The name of the algorithm (e.g. 'soundex')
      * @param {PhoneticOptions} [opt] - Options for the phonetic algorithm
-     * @throws {Error} - If the requested mapping is not declared
+     * @throws {CmpStrNotFoundError} - If no mapping is specified or if the requested mapping is not declared
      */
     constructor(algo: string, opt?: PhoneticOptions);
     /**
@@ -148,6 +149,7 @@ export declare abstract class Phonetic {
      *
      * @param {string[]} words - An array of words to be processed
      * @returns {string[]} - An array of phonetic indices for the input words
+     * @throws {CmpStrInternalError} - If the phonetic index generation fails
      */
     protected loop(words: string[]): string[];
     /**
@@ -158,6 +160,7 @@ export declare abstract class Phonetic {
      *
      * @param {string[]} words - An array of words to be processed
      * @returns {Promise< string[] >} - A promise that resolves to an array of phonetic indices for the input words
+     * @throws {CmpStrInternalError} - If the asynchronous phonetic index generation fails
      */
     protected loopAsync(words: string[]): Promise<string[]>;
     /**

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

@@ -18,7 +18,8 @@
  * consonants. It outputs an array of strings that represents the phonetic code
  * of the input, typically limited to the length of four characters.
  *
- * @module Phonetic/Soundex
+ * @module Phonetic
+ * @name Soundex
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -21,6 +21,7 @@
  *  - Consistent interface for accessing, listing, and managing phonetic algorithms
  *  - Ensures that all phonetic algorithms are available for use in the CmpStr API
  *
+ * @module Phonetic
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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.0
+ * @version 3.2.2
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -32,6 +32,7 @@ export { Metric, MetricCls, MetricRegistry } from './metric';
  */
 export { Phonetic, PhoneticCls, PhoneticMappingRegistry, PhoneticRegistry } from './phonetic';
 export * as DeepMerge from './utils/DeepMerge';
+export * as CmpStrError from './utils/Errors';
 export { Filter } from './utils/Filter';
 export { Hasher, HashTable } from './utils/HashTable';
 export { Pool } from './utils/Pool';

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

@@ -14,7 +14,8 @@
  *  - `has`:   Check whether a path exists
  *  - `rmv`:   Delete a value at a path
  *
- * @module Utils/DeepMerge
+ * @module Utils
+ * @name DeepMerge
  * @author Paul Köhler
  * @license MIT
  */
@@ -46,7 +47,7 @@ export declare function has<T extends Record<string, any>>(t: T, path: string):
  * @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 {Error} - Throws an error if the key is not a valid identifier
+ * @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;
 /**

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

@@ -20,7 +20,8 @@
  *  - Change magnitude calculation (relative to group or line)
  *  - Expand-all mode for full file context
  *
- * @module Utils/DiffChecker
+ * @module Utils
+ * @name DiffChecker
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -0,0 +1,137 @@
+/**
+ * Error Utilities
+ * src/utils/Errors.ts
+ *
+ * This module provides a small hierarchy of error classes and helper methods
+ * that standardize error creation and formatting across the CmpStr project.
+ * It improves on vanilla JavaScript errors by adding codes, structured metadata,
+ * and consistent `toString()` / `toJSON()` output while keeping the original
+ * message text intact.
+ *
+ * The error classes are designed to be lightweight and fast, while still
+ * providing useful context for debugging (including optional `cause` chaining).
+ *
+ * @module Utils
+ * @name Errors
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { CmpStrErrorJSON, CmpStrErrorMeta } from './Types';
+/**
+ * Base error class for CmpStr.
+ *
+ * It provides a standard `code` field and a consistent `toString()` / `toJSON()`
+ * output without changing the original error message expectations.
+ */
+export declare class CmpStrError extends Error {
+    /** A short, machine-readable error code */
+    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;
+    /**
+     * Constructor for CmpStrError.
+     *
+     * Will construct an error with a code, message, optional metadata, and optional cause.
+     *
+     * @param {string} code - A short, machine-readable error code
+     * @param {string} message - The error message (human-readable)
+     * @param {CmpStrErrorMeta} [meta] - Optional structured metadata for the error
+     * @param {unknown} [cause] - Optional cause (native JS Error chaining)
+     */
+    constructor(code: string, message: string, meta?: CmpStrErrorMeta, cause?: unknown);
+    /**
+     * Serialize the error into a plain object for JSON output.
+     */
+    toJSON(): CmpStrErrorJSON;
+    /**
+     * Pretty string representation of the error.
+     *
+     * @param {boolean} [stack=false] - Whether to include the stack trace in the output
+     */
+    toString(stack?: boolean): string;
+}
+/**
+ * Error thrown when user input (options, arguments) is invalid.
+ */
+export declare class CmpStrValidationError extends CmpStrError {
+    constructor(message: string, meta?: CmpStrErrorMeta, cause?: unknown);
+}
+/**
+ * Error thrown when a requested resource is missing or not found.
+ */
+export declare class CmpStrNotFoundError extends CmpStrError {
+    constructor(message: string, meta?: CmpStrErrorMeta, cause?: unknown);
+}
+/**
+ * Error thrown for incorrect usage or invalid state (assertions).
+ */
+export declare class CmpStrUsageError extends CmpStrError {
+    constructor(message: string, meta?: CmpStrErrorMeta, cause?: unknown);
+}
+/**
+ * Error thrown for internal failures that should not happen under normal usage.
+ */
+export declare class CmpStrInternalError extends CmpStrError {
+    constructor(message: string, meta?: CmpStrErrorMeta, cause?: unknown);
+}
+/**
+ * Helper utilities for throwing and formatting errors.
+ *
+ * Provides methods for asserting conditions, wrapping unknown errors, and formatting
+ * errors into readable strings. This centralizes error handling logic and ensures
+ * consistent error messages across the codebase.
+ */
+export declare class ErrorUtil {
+    /**
+     * Throw a `CmpStrUsageError` if a condition is not met.
+     *
+     * @param {boolean} condition - The condition to assert
+     * @param {string} message - The error message to throw if the condition is false
+     * @param {CmpStrErrorMeta} [meta] - Optional structured metadata for the error
+     * @throws {CmpStrUsageError} - If the condition is false
+     */
+    static assert(condition: boolean, message: string, meta?: CmpStrErrorMeta): asserts condition;
+    /**
+     * Wrap an unknown error into a `CmpStrInternalError`.
+     *
+     * @param {unknown} err - The error to wrap
+     * @param {string} message - The error message to use for the wrapped error
+     * @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;
+    /**
+     * Format any error into a readable string.
+     *
+     * @param {unknown} err - The error to format
+     * @returns {string} - A formatted string representation of the error
+     */
+    static format(err: unknown): string;
+    /**
+     * Execute a synchronous operation and wrap any exception as a `CmpStrInternalError`.
+     *
+     * This is used to avoid repeating try/catch blocks and to add consistent context
+     * to unexpected failures while preserving the original error as `cause`.
+     *
+     * @param {() => T} fn - The 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 {T} 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 wrap<T>(fn: () => T, message: string, meta?: CmpStrErrorMeta): T;
+    /**
+     * Execute an asynchronous operation and wrap any exception as a `CmpStrInternalError`.
+     *
+     * @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
+     * @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

@@ -7,11 +7,12 @@
  * applied to input strings. Each filter has an id, a function, a priority, and options
  * for activation and overrideability.
  *
- * @module Utils/Filter
+ * @module Utils
+ * @name Filter
  * @author Paul Köhler (komed3)
  * @license MIT
  */
-import type { FilterFn, FilterOptions } from './Types';
+import type { FilterFn, FilterHooks, FilterOptions } from './Types';
 /**
  * The Filter class provides a way to manage and apply filters to strings based on hooks.
  */
@@ -30,82 +31,92 @@ export declare class Filter {
      * Retrieves the compiled filter function for a given hook.
      * If the function is not cached, it compiles it from the active filters.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @returns {FilterFn} - The compiled filter function for the hook
+     * @throws {CmpStrInternalError} - Throws an error if the pipeline compilation fails
      */
     private static getPipeline;
     /**
      * Checks if a filter exists for a given hook and id.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string} id - The id of the filter
      * @returns {boolean} - Returns true if the filter exists, false otherwise
      */
-    static has(hook: string, id: string): boolean;
+    static has(hook: FilterHooks, id: string): boolean;
     /**
      * Adds a filter to the specified hook.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string} id - The id of the filter
      * @param {FilterFn} fn - The filter function
      * @param {FilterOptions} [opt] - Additional options for the filter
-     * @returns {boolean} - Returns true if the filter was added, false if it was not added due to override restrictions
+     * @returns {boolean} - Returns true if the filter was added,
+     *                      false if it was not added due to override restrictions
+     * @throws {CmpStrInternalError} - Throws an error if there is an issue adding the filter
      */
-    static add(hook: string, id: string, fn: FilterFn, opt?: FilterOptions): boolean;
+    static add(hook: FilterHooks, id: string, fn: FilterFn, opt?: FilterOptions): boolean;
     /**
      * Removes a filter by its hook and id.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string} id - The id of the filter
      * @returns {boolean} - Returns true if the filter was removed, false if it was not found
      */
-    static remove(hook: string, id: string): boolean;
+    static remove(hook: FilterHooks, id: string): boolean;
     /**
      * Pauses a filter by its hook and id.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string} id - The id of the filter
      * @returns {boolean} - Returns true if the filter was paused, false if it was not found
      */
-    static pause(hook: string, id: string): boolean;
+    static pause(hook: FilterHooks, id: string): boolean;
     /**
      * Resumes a filter by its hook and id.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string} id - The id of the filter
      * @returns {boolean} - Returns true if the filter was resumed, false if it was not found
      */
-    static resume(hook: string, id: string): boolean;
+    static resume(hook: FilterHooks, id: string): boolean;
     /**
      * Lists all filters for a given hook.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {boolean} active - If true, only list active filters
      * @returns {string[]} - An array of filter ids
      */
-    static list(hook: string, active?: boolean): string[];
+    static list(hook: FilterHooks, active?: boolean): string[];
     /**
      * Applies all active filters for a given hook to the input string(s).
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string | string[]} input - The input string(s) to be filtered
      * @returns {string | string[]} - The filtered string(s)
+     * @throws {CmpStrInternalError} - Throws an error if there is an issue applying the filters
      */
-    static apply(hook: string, input: string | string[]): string | string[];
+    static apply(hook: FilterHooks, input: string | string[]): string | string[];
     /**
      * Applies all active filters for a given hook to the input string(s) asynchronously.
      * Each filter function may return a Promise or a plain string; all are awaited in order.
      *
-     * @param {string} hook - The name of the hook
+     * @param {FilterHooks} hook - The name of the hook
      * @param {string | string[]} input - The input string(s) to be filtered
      * @returns {Promise< string | string[] >} - The filtered string(s)
+     * @throws {CmpStrInternalError} - Throws an error if there is an issue applying the filters
      */
-    static applyAsync(hook: string, input: string | string[]): Promise<string | string[]>;
+    static applyAsync(hook: FilterHooks, input: string | string[]): Promise<string | string[]>;
     /**
      * Clears all filters or filters for a specific hook.
      * If no hook is provided, clear all filters
      *
-     * @param {string} [hook] - Optional name of the hook to clear filters for
+     * @param {FilterHooks} [hook] - Optional name of the hook to clear filters for
      */
-    static clear(hook?: string): void;
+    static clear(hook?: FilterHooks): void;
+    /**
+     * Clears the entire filter pipeline cache.
+     * This forces recompilation of all pipelines on next application.
+     */
+    static clearPipeline(): void;
 }

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

@@ -15,7 +15,8 @@
  * The key() method supports any number of string arguments, enabling flexible cache keys
  * for different use cases (e.g. normalization, metrics, etc.).
  *
- * @module Utils/HashTable
+ * @module Utils
+ * @name HashTable
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -22,7 +22,8 @@
  *  'n' :: Remove non-number characters
  *  'i' :: Case insensitive (convert to lowercase)
  *
- * @module Utils/Normalizer
+ * @module Utils
+ * @name Normalizer
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -56,6 +57,7 @@ export declare class Normalizer {
      *
      * @param {NormalizeFlags} flags - A string of characters representing the normalization steps
      * @returns {NormalizerFn} - A function that normalizes a string based on the provided flags
+     * @throws {CmpStrInternalError} - Throws an error if the pipeline creation fails
      */
     private static getPipeline;
     /**
@@ -65,6 +67,7 @@ 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
      * @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[];
     /**
@@ -75,6 +78,7 @@ 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
      * @returns {Promise< string | string[] >} - A promise that resolves to the normalized string(s)
+     * @throws {CmpStrInternalError} - Throws an error if the normalization process fails
      */
     static normalizeAsync(input: string | string[], flags: NormalizeFlags): Promise<string | string[]>;
     /**

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

@@ -12,7 +12,8 @@
  * It supports different types of buffers (Int32Array, number[], string[], Set, Map)
  * and allows for acquiring buffers of specific sizes while managing a max pool size.
  *
- * @module Utils/Pool
+ * @module Utils
+ * @name Pool
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -43,6 +44,7 @@ export declare class Pool {
      * @param {PoolType} type - The type of buffer to acquire (e.g., 'int32', 'number[]', 'map')
      * @param {number} size - The size of the buffer to acquire
      * @return {T} - The acquired buffer of the specified type
+     * @throws {CmpStrUsageError} - Throws an error if the pool type is unsupported
      */
     static acquire<T = any>(type: PoolType, size: number): T;
     /**
@@ -60,6 +62,7 @@ export declare class Pool {
      * @param {PoolType} type - The type of buffer to release
      * @param {T} buffer - The buffer to release
      * @param {number} size - The size of the buffer
+     * @throws {CmpStrUsageError} - Throws an error if the pool type is unsupported
      */
     static release<T = any>(type: PoolType, buffer: T, size: number): void;
 }

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

@@ -1,6 +1,6 @@
 /**
  * Profiler Utility
- * src/utils/profiler.ts
+ * src/utils/Profiler.ts
  *
  * @see https://en.wikipedia.org/wiki/Profiling_(computer_programming)
  *
@@ -12,7 +12,8 @@
  * The class is optimized for minimal overhead and can be used for fine-grained
  * performance profiling.
  *
- * @module Utils/Profiler
+ * @module Utils
+ * @name Profiler
  * @author Paul Köhler (komed3)
  * @license MIT
  */

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

@@ -8,7 +8,8 @@
  * It is designed to manage class extensions, ensuring that all registered
  * classes extend a specified base constructor.
  *
- * @module Utils/Registry
+ * @module Utils
+ * @name Registry
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -34,7 +35,7 @@ export declare const factory: Record<string, (cls: string, ...args: any[]) => In
  * @param {string} reg - The name of the registry
  * @param {RegistryConstructor< T >} ctor - The base constructor that all registered classes must extend
  * @returns {RegistryService< T >} - An object with methods to register, remove, check, get, and list classes
- * @throws {Error} If the registry already exists (overwriting is forbidden)
+ * @throws {Error} - If the registry already exists (overwriting is forbidden)
  */
 export declare function Registry<T>(reg: string, ctor: RegistryConstructor<T>): RegistryService<T>;
 /**
@@ -44,7 +45,7 @@ export declare function Registry<T>(reg: string, ctor: RegistryConstructor<T>):
  * @param {string} reg - The name of the registry
  * @param {T | string} cls - The class itself or name of the class to resolve
  * @returns {T | undefined} - The class constructor if found, otherwise undefined
- * @throws {ReferenceError} If the registry does not exist
+ * @throws {CmpStrNotFoundError} - If the registry or class does not exist
  */
 export declare function resolveCls<T extends RegistryConstructor<any>>(reg: string, cls: T | string): T;
 /**
@@ -55,6 +56,6 @@ export declare function resolveCls<T extends RegistryConstructor<any>>(reg: stri
  * @param {T | string} cls - The class itself or name of the class to instantiate
  * @param {...any} args - Arguments to pass to the class constructor
  * @returns {T} - An instance of the class
- * @throws {Error} If the class cannot be instantiated
+ * @throws {CmpStrInternalError} - If instantiation fails due to an internal error
  */
 export declare function createFromRegistry<T extends RegistryConstructor<any>>(reg: string, cls: T | string, ...args: any[]): InstanceType<T>;

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

@@ -13,7 +13,8 @@
  *  - Integration with CmpStr comparison methods
  *  - Optional "objects-only" output mode for minimal result structure
  *
- * @module Utils/StructuredData
+ * @module Utils
+ * @name StructuredData
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -79,7 +80,7 @@ export declare class StructuredData<T = any, R = MetricRaw> {
      *
      * @param {any} results - The raw metric results
      * @returns {IndexedResult< R >[]} - Normalized results with indices
-     * @throws {TypeError} - If results format is unsupported
+     * @throws {CmpStrValidationError} - If the results format is unsupported
      */
     private normalizeResults;
     /**
@@ -120,6 +121,7 @@ export declare class StructuredData<T = any, R = MetricRaw> {
      * @param {string[]} extractedStrings - The extracted strings for index mapping
      * @param {StructuredDataOptions} [opt] - Additional options
      * @returns {StructuredDataBatchResult< T, R > | T[]} - The lookup results
+     * @throws {CmpStrUsageError} - If the lookup process fails
      */
     private performLookup;
     /**
@@ -129,6 +131,7 @@ export declare class StructuredData<T = any, R = MetricRaw> {
      * @param {string[]} extractedStrings - The extracted strings for index mapping
      * @param {StructuredDataOptions} [opt] - Additional options
      * @returns {Promise< StructuredDataBatchResult< T, R > | T[] >} - The async lookup results
+     * @throws {CmpStrUsageError} - If the async lookup process fails
      */
     private performLookupAsync;
     /**

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

@@ -9,7 +9,8 @@
  * efficiency and flexibility, it is suitable for linguistic research, readability
  * scoring, and text preprocessing tasks.
  *
- * @module Utils/TextAnalyzer
+ * @module Utils
+ * @name TextAnalyzer
  * @author Paul Köhler (komed3)
  * @license MIT
  */