cmpstr 3.2.1 → 3.3.0

package/dist/esm/utils/StructuredData.mjs

@@ -1,9 +1,12 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+import { CmpStrValidationError, ErrorUtil } from './Errors.mjs';
 import { Pool } from './Pool.mjs';
 
 class StructuredData {
   data;
   key;
+  static SORT_ASC = (a, b) => a.res - b.res;
+  static SORT_DESC = (a, b) => b.res - a.res;
   static create(data, key) {
     return new StructuredData(data, key);
   }
@@ -12,14 +15,17 @@ class StructuredData {
     this.key = key;
   }
   extractFrom(arr, key) {
-    const result = Pool.acquire('string[]', arr.length);
-    for (let i = 0; i < arr.length; i++) {
+    const n = arr.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
       const val = arr[i][key];
-      result[i] = typeof val === 'string' ? val : String(val ?? '');
+      result[i] = val != null ? String(val) : '';
     }
     return result;
   }
-  extract = () => this.extractFrom(this.data, this.key);
+  extract() {
+    return this.extractFrom(this.data, this.key);
+  }
   isMetricResult(v) {
     return (
       typeof v === 'object' && v !== null && 'a' in v && 'b' in v && 'res' in v
@@ -37,64 +43,89 @@ class StructuredData {
   normalizeResults(results) {
     if (!Array.isArray(results) || results.length === 0) return [];
     const first = results[0];
-    let normalized = [];
-    if (this.isMetricResult(first)) normalized = results;
-    else if (this.isCmpStrResult(first))
-      normalized = results.map((r) => ({
-        metric: 'unknown',
-        a: r.source,
-        b: r.target,
-        res: r.match,
-        raw: r.raw
-      }));
-    else
-      throw new TypeError(
+    let out = new Array(results.length);
+    if (this.isMetricResult(first)) {
+      const src = results;
+      for (let i = 0; i < src.length; i++) out[i] = { ...src[i], __idx: i };
+    } else if (this.isCmpStrResult(first)) {
+      const src = results;
+      for (let i = 0; i < src.length; i++) {
+        const r = src[i];
+        out[i] = {
+          metric: 'unknown',
+          a: r.source,
+          b: r.target,
+          res: r.match,
+          raw: r.raw,
+          __idx: i
+        };
+      }
+    } else
+      throw new CmpStrValidationError(
         'Unsupported result format for StructuredData normalization.'
       );
-    return normalized.map((r, idx) => ({ ...r, __idx: idx }));
+    return out;
   }
   rebuild(results, sourceData, extractedStrings, removeZero, objectsOnly) {
-    const stringToIndices = new Map();
-    for (let i = 0; i < extractedStrings.length; i++) {
-      const str = extractedStrings[i];
-      if (!stringToIndices.has(str)) stringToIndices.set(str, []);
-      stringToIndices.get(str).push(i);
-    }
-    const output = new Array(results.length);
-    const occurrenceCount = new Map();
-    let out = 0;
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (removeZero && result.res === 0) continue;
-      const targetStr = result.b || '';
-      const indices = stringToIndices.get(targetStr);
-      let dataIndex;
-      if (indices && indices.length > 0) {
-        const occurrence = occurrenceCount.get(targetStr) ?? 0;
-        occurrenceCount.set(targetStr, occurrence + 1);
-        dataIndex = indices[occurrence % indices.length];
-      } else {
-        dataIndex = result.__idx ?? i;
+    const m = extractedStrings.length,
+      n = results.length;
+    const stringToIndices = Pool.acquire('map', m);
+    const occurrenceCount = Pool.acquire('map', n);
+    const output = new Array(n);
+    stringToIndices.clear();
+    occurrenceCount.clear();
+    try {
+      for (let i = 0; i < m; i++) {
+        const str = extractedStrings[i];
+        let arr = stringToIndices.get(str);
+        if (!arr) {
+          arr = [];
+          stringToIndices.set(str, arr);
+        }
+        arr.push(i);
       }
-      if (dataIndex < 0 || dataIndex >= sourceData.length) continue;
-      const sourceObj = sourceData[dataIndex];
-      const mappedTarget = extractedStrings[dataIndex] || targetStr;
-      if (objectsOnly) output[out++] = sourceObj;
-      else
-        output[out++] = {
-          obj: sourceObj,
-          key: this.key,
-          result: { source: result.a, target: mappedTarget, match: result.res },
-          ...(result.raw ? { raw: result.raw } : null)
-        };
+      let out = 0;
+      for (let i = 0; i < n; i++) {
+        const result = results[i];
+        if (removeZero && result.res === 0) continue;
+        const targetStr = result.b || '';
+        const indices = stringToIndices.get(targetStr);
+        let dataIndex;
+        if (indices && indices.length > 0) {
+          const occurrence = occurrenceCount.get(targetStr) ?? 0;
+          occurrenceCount.set(targetStr, occurrence + 1);
+          dataIndex = indices[occurrence % indices.length];
+        } else {
+          dataIndex = result.__idx ?? i;
+        }
+        if (dataIndex < 0 || dataIndex >= sourceData.length) continue;
+        const sourceObj = sourceData[dataIndex];
+        const mappedTarget = extractedStrings[dataIndex] || targetStr;
+        if (objectsOnly) output[out++] = sourceObj;
+        else
+          output[out++] = {
+            obj: sourceObj,
+            key: this.key,
+            result: {
+              source: result.a,
+              target: mappedTarget,
+              match: result.res
+            },
+            ...(result.raw ? { raw: result.raw } : null)
+          };
+      }
+      output.length = out;
+      return output;
+    } finally {
+      Pool.release('map', stringToIndices, m);
+      Pool.release('map', occurrenceCount, n);
     }
-    output.length = out;
-    return output;
   }
   sort(results, sort) {
     if (!sort || results.length <= 1) return results;
-    const asc = sort === 'asc';
-    return results.sort((a, b) => (asc ? a.res - b.res : b.res - a.res));
+    return results.sort(
+      sort === 'asc' ? StructuredData.SORT_ASC : StructuredData.SORT_DESC
+    );
   }
   finalizeLookup(results, extractedStrings, opt) {
     return this.rebuild(
@@ -106,10 +137,18 @@ class StructuredData {
     );
   }
   performLookup(fn, extractedStrings, opt) {
-    return this.finalizeLookup(fn(), extractedStrings, opt);
+    return ErrorUtil.wrap(
+      () => this.finalizeLookup(fn(), extractedStrings, opt),
+      'StructuredData lookup failed',
+      { key: this.key }
+    );
   }
   async performLookupAsync(fn, extractedStrings, opt) {
-    return this.finalizeLookup(await fn(), extractedStrings, opt);
+    return await ErrorUtil.wrapAsync(
+      async () => this.finalizeLookup(await fn(), extractedStrings, opt),
+      'StructuredData async lookup failed',
+      { key: this.key }
+    );
   }
   lookup(fn, query, opt) {
     const b = this.extract();
@@ -150,4 +189,3 @@ class StructuredData {
 }
 
 export { StructuredData };
-//# sourceMappingURL=StructuredData.mjs.map

package/dist/esm/utils/TextAnalyzer.mjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 class TextAnalyzer {
   static REGEX = {
     number: /\d/,
@@ -194,4 +194,3 @@ class TextAnalyzer {
 }
 
 export { TextAnalyzer };
-//# sourceMappingURL=TextAnalyzer.mjs.map

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,8 @@ export declare class CmpStr<R = MetricRaw> {
      *
      * @param {string} cond - The condition to met
      * @param {any} [test] - Value to test for
-     * @throws {Error} If the condition is not met
+     * @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;
     /**
@@ -164,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;
     /**
@@ -233,6 +235,8 @@ 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;
     /**
@@ -242,6 +246,7 @@ export declare class CmpStr<R = MetricRaw> {
      * @param {MetricResult< R >} result - The metric result
      * @param {boolean} [raw] - Whether to return raw results
      * @returns {T} - The resolved result
+     * @throws {CmpStrInternalError} - If the output format cannot be resolved
      */
     protected output<T extends MetricResult<R> | CmpStrResult | CmpStrResult[]>(result: MetricResult<R>, raw?: boolean): T;
     /**
@@ -257,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.
      *
@@ -269,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;
     /**
@@ -276,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;
     /**
@@ -283,6 +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 or the options are invalid
      */
     setSerializedOptions(opt: string): this;
     /**
@@ -291,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;
     /**
@@ -306,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
@@ -468,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,8 @@ 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>;
     /**
@@ -217,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.1
+ * Version: 3.3.0
  * Author: Paul Köhler (komed3)
  * License: MIT
  *
@@ -41,11 +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.1
+ * @version 3.3.0
  * @author Paul Köhler (komed3)
  * @license MIT
  */
 export * from './utils/Types';
+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.
@@ -83,7 +83,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {MetricInput} b - Second input string or array of strings
      * @param {MetricOptions} [opt] - Options for the metric computation
      * @param {boolean} [symmetric=false] - Whether the metric is symmetric (same result for inputs in any order)
-     * @throws {Error} - If inputs `a` or `b` are empty
+     * @throws {CmpStrUsageError} - If the inputs are empty or invalid
      */
     constructor(metric: string, a: MetricInput, b: MetricInput, opt?: MetricOptions, symmetric?: boolean);
     /**
@@ -107,7 +107,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {number} n - Length of the second string
      * @param {number} maxLen - Maximum length of the strings
      * @returns {MetricCompute< R >} - The result of the metric computation
-     * @throws {Error} - If not overridden in a subclass
+     * @throws {CmpStrInternalError} - If the method is not overridden in a subclass
      */
     protected compute(a: string, b: string, m: number, n: number, maxLen: number): MetricCompute<R>;
     /**
@@ -119,6 +119,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {number} i - Pointer to the first string
      * @param {number} j - Pointer to the second string
      * @returns {MetricResultSingle< R >} - The result of the metric computation
+     * @throws {CmpStrInternalError} - If the metric computation fails for the given inputs
      */
     private runSingle;
     /**
@@ -166,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.
      *
@@ -175,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.
      *
@@ -184,7 +185,7 @@ export declare abstract class Metric<R = MetricRaw> {
      *
      * @returns {boolean} - True if both inputs are arrays of equal length
      * @param {boolean} [safe=false] - If true, does not throw an error if lengths are not equal
-     * @throws {Error} - If `safe` is false and the lengths of `a` and `b` are not equal
+     * @throws {CmpStrUsageError} - If `safe` is false and the lengths of `a` and `b` are not equal
      */
     isPairwise(safe?: boolean): boolean;
     /**
@@ -195,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.
      *
@@ -205,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.
      *
@@ -213,13 +214,13 @@ 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.
      *
      * @param {MetricMode} [mode] - The mode to run the metric in (optional)
      * @param {boolean} [clear=true] - Whether to clear previous results before running
-     * @throws {Error} - If an unsupported mode is specified
+     * @throws {CmpStrInternalError} - If an unsupported mode is specified
      */
     run(mode?: MetricMode, clear?: boolean): void;
     /**
@@ -228,7 +229,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {MetricMode} [mode] - The mode to run the metric in (optional)
      * @param {boolean} [clear=true] - Whether to clear previous results before running
      * @returns {Promise<void>} - A promise that resolves when the metric computation is complete
-     * @throws {Error} - If an unsupported mode is specified
+     * @throws {CmpStrInternalError} - If an unsupported mode is specified
      */
     runAsync(mode?: MetricMode, clear?: boolean): Promise<void>;
     /**
@@ -236,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.
      *
@@ -61,7 +62,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);
     /**
@@ -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.
      *
@@ -149,6 +150,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[];
     /**
@@ -159,6 +161,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[]>;
     /**
@@ -166,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.1
+ * @version 3.3.0
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -31,9 +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';