cmpstr 3.1.1 → 3.2.1

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

@@ -21,10 +21,11 @@
  * implement the `compute` method to define the specific metric computation logic.
  *
  * @module Metric
+ * @name Metric
  * @author Paul Köhler (komed3)
  * @license MIT
  */
-import type { MetricMode, MetricInput, MetricOptions, MetricCompute, MetricRaw, MetricResult, RegistryService } from '../utils/Types';
+import type { MetricCompute, MetricInput, MetricMode, MetricOptions, MetricRaw, MetricResult, RegistryService } from '../utils/Types';
 /**
  * Abstract class representing a generic string metric.
  *
@@ -32,13 +33,20 @@ import type { MetricMode, MetricInput, MetricOptions, MetricCompute, MetricRaw,
  * @template R - The type of the raw result, defaulting to `MetricRaw`.
  */
 export declare abstract class Metric<R = MetricRaw> {
+    /** Cache for metric computations to avoid redundant calculations */
     private static cache;
+    /** Metric name for identification */
     private readonly metric;
+    /** Inputs for the metric computation, transformed into arrays */
     private readonly a;
     private readonly b;
+    /** Store original inputs for result mapping */
     private origA;
     private origB;
+    /** Options for the metric computation, such as performance tracking */
     protected readonly options: MetricOptions;
+    protected readonly optKey: string;
+    /** Indicates whether the metric is symmetric (same result for inputs in any order) */
     protected readonly symmetric: boolean;
     /**
      * Result of the metric computation, which can be a single result or an array of results.
@@ -48,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.
      *
@@ -56,21 +64,16 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {string} b - Second string
      * @param {number} m - Length of the first string
      * @param {number} n - Length of the second string
-     * @returns {[string, string, number, number]} - Swapped strings and lengths
+     * @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.
@@ -91,7 +94,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {string} b - Second string
      * @param {number} m - Length of the first string
      * @param {number} n - Length of the second string
-     * @returns {MetricCompute<R>|undefined} - Pre-computed result or undefined if not applicable
+     * @returns {MetricCompute< R > | undefined} - Pre-computed result or undefined if not applicable
      */
     protected preCompute(a: string, b: string, m: number, n: number): MetricCompute<R> | undefined;
     /**
@@ -103,7 +106,7 @@ export declare abstract class Metric<R = MetricRaw> {
      * @param {number} m - Length of the first string
      * @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
+     * @returns {MetricCompute< R >} - The result of the metric computation
      * @throws {Error} - If not overridden in a subclass
      */
     protected compute(a: string, b: string, m: number, n: number, maxLen: number): MetricCompute<R>;
@@ -115,7 +118,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
+     * @returns {MetricResultSingle< R >} - The result of the metric computation
      */
     private runSingle;
     /**
@@ -123,7 +126,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 {Promise<MetricResultSingle<R>>} - Promise resolving the result of the metric computation
+     * @returns {Promise< MetricResultSingle< R > >} - Promise resolving the result of the metric computation
      */
     private runSingleAsync;
     /**
@@ -163,7 +166,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.
      *
@@ -172,7 +175,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.
      *
@@ -192,7 +195,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.
      *
@@ -202,7 +205,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.
      *
@@ -210,7 +213,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.
      *
@@ -233,11 +236,11 @@ 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.
      *
-     * @returns {MetricResult<R>} - The result of the metric computation
+     * @returns {MetricResult< R >} - The result of the metric computation
      * @throws {Error} - If `run()` has not been called before this method
      */
     getResults(): MetricResult<R>;

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

@@ -8,11 +8,12 @@
  * 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
  */
-import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import type { MetricCompute, MetricInput, MetricOptions } from '../utils/Types';
 import { Metric } from './Metric';
 export interface NeedlemanRaw {
     score: number;
@@ -28,6 +29,8 @@ export declare class NeedlemanWunschDistance extends Metric<NeedlemanRaw> {
      * Initializes the Needleman-Wunsch metric with two input strings or
      * arrays of strings and optional options.
      *
+     * Metric is symmetrical.
+     *
      * @param {MetricInput} a - First input string or array of strings
      * @param {MetricInput} b - Second input string or array of strings
      * @param {MetricOptions} [opt] - Options for the metric computation
@@ -41,7 +44,7 @@ export declare class NeedlemanWunschDistance extends Metric<NeedlemanRaw> {
      * @param {number} m - Length of the first string
      * @param {number} n - Length of the second string
      * @param {number} maxLen - Maximum length of the strings
-     * @return {MetricCompute<NeedlemanRaw>} - Object containing the similarity result and raw score
+     * @return {MetricCompute< NeedlemanRaw >} - Object containing the similarity result and raw score
      */
     protected compute(a: string, b: string, m: number, n: number, maxLen: number): MetricCompute<NeedlemanRaw>;
 }

package/dist/types/metric/{qGram.d.ts → QGram.d.ts}

@@ -12,11 +12,12 @@
  * 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
  */
-import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import type { MetricCompute, MetricInput, MetricOptions } from '../utils/Types';
 import { Metric } from './Metric';
 export interface QGramRaw {
     intersection: number;
@@ -32,6 +33,8 @@ export declare class QGramSimilarity extends Metric<QGramRaw> {
      * Initializes the q-Gram similarity metric with two input strings or
      * arrays of strings and optional options.
      *
+     * Metric is symmetrical.
+     *
      * @param {MetricInput} a - First input string or array of strings
      * @param {MetricInput} b - Second input string or array of strings
      * @param {MetricOptions} [opt] - Options for the metric computation
@@ -42,7 +45,7 @@ export declare class QGramSimilarity extends Metric<QGramRaw> {
      *
      * @param {string} str - The input string
      * @param {number} q - The length of each q-gram
-     * @return {Set<string>} - Set of q-grams
+     * @return {Set< string >} - Set of q-grams
      */
     private _qGrams;
     /**
@@ -50,7 +53,7 @@ export declare class QGramSimilarity extends Metric<QGramRaw> {
      *
      * @param {string} a - First string
      * @param {string} b - Second string
-     * @return {MetricCompute<QGramRaw>} - Object containing the similarity result and raw values
+     * @return {MetricCompute< QGramRaw >} - Object containing the similarity result and raw values
      */
     protected compute(a: string, b: string): MetricCompute<QGramRaw>;
 }

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

@@ -10,11 +10,12 @@
  * 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
  */
-import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import type { MetricCompute, MetricInput, MetricOptions } from '../utils/Types';
 import { Metric } from './Metric';
 export interface SmithWatermanRaw {
     score: number;
@@ -30,6 +31,8 @@ export declare class SmithWatermanDistance extends Metric<SmithWatermanRaw> {
      * Initializes the Smith-Waterman metric with two input strings or
      * arrays of strings and optional options.
      *
+     * Metric is symmetrical.
+     *
      * @param {MetricInput} a - First input string or array of strings
      * @param {MetricInput} b - Second input string or array of strings
      * @param {MetricOptions} [opt] - Options for the metric computation
@@ -42,7 +45,7 @@ export declare class SmithWatermanDistance extends Metric<SmithWatermanRaw> {
      * @param {string} b - Second string
      * @param {number} m - Length of the first string
      * @param {number} n - Length of the second string
-     * @return {MetricCompute<SmithWatermanRaw>} - Object containing the similarity result and raw score
+     * @return {MetricCompute< SmithWatermanRaw >} - Object containing the similarity result and raw score
      */
     protected compute(a: string, b: string, m: number, n: number): MetricCompute<SmithWatermanRaw>;
 }

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
  */
@@ -36,6 +37,6 @@ import './JaroWinkler';
 import './LCS';
 import './Levenshtein';
 import './NeedlemanWunsch';
-import './qGram';
+import './QGram';
 import './SmithWaterman';
-export { MetricRegistry, Metric, MetricCls } from './Metric';
+export { Metric, MetricCls, MetricRegistry } from './Metric';

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
  */
@@ -22,6 +23,9 @@ import { Phonetic } from './Phonetic';
  * Caverphone class extends the Phonetic class to implement the Caverphone phonetic algorithm.
  */
 export declare class Caverphone extends Phonetic {
+    /** Regular expressions used in the Caverphone algorithm */
+    private static readonly REGEX;
+    /** Default options for the Caverphone phonetic algorithm */
     protected static default: PhoneticOptions;
     /**
      * Constructor for the Caverphone class.
@@ -44,12 +48,12 @@ export declare class Caverphone extends Phonetic {
      * @param {string} char - The character to be mapped
      * @returns {string} - The mapped character
      */
-    protected mapChar(char: string): string;
+    protected mapChar: (char: string) => string;
     /**
      * Adjusts the phonetic code to uppercase.
      *
      * @param {string} code - The phonetic code to adjust
      * @returns {string} - The adjusted phonetic code
      */
-    protected adjustCode(code: string): string;
+    protected adjustCode: (code: string) => string;
 }

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
  */
@@ -27,6 +28,7 @@ import { Phonetic } from './Phonetic';
  * Cologne class extends the Phonetic class to implement the Cologne phonetic algorithm.
  */
 export declare class Cologne extends Phonetic {
+    /** Default options for the Cologne phonetic algorithm */
     protected static default: PhoneticOptions;
     /**
      * Constructor for the Cologne class.

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
  */
@@ -24,6 +25,9 @@ import { Phonetic } from './Phonetic';
  * Metaphone class extends the Phonetic class to implement the Metaphone phonetic algorithm.
  */
 export declare class Metaphone extends Phonetic {
+    /** Regular expressions used in the Metaphone algorithm */
+    private static readonly REGEX;
+    /** Default options for the Metaphone phonetic algorithm */
     protected static default: PhoneticOptions;
     /**
      * Constructor for the Metaphone class.

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

@@ -19,10 +19,11 @@
  * phonetic algorithms by extending the abstract class.
  *
  * @module Phonetic
+ * @name Phonetic
  * @author Paul Köhler (komed3)
  * @license MIT
  */
-import type { PhoneticMap, PhoneticOptions, RegistryService, PhoneticMappingService } from '../utils/Types';
+import type { PhoneticMap, PhoneticMappingService, PhoneticOptions, RegistryService } from '../utils/Types';
 /**
  * Abstract class representing a phonetic algorithm.
  *
@@ -33,6 +34,7 @@ import type { PhoneticMap, PhoneticOptions, RegistryService, PhoneticMappingServ
  * @abstract
  */
 export declare abstract class Phonetic {
+    /** Cache for indexed words to avoid redundant calculations */
     private static cache;
     /**
      * Default phonetic options.
@@ -41,13 +43,16 @@ export declare abstract class Phonetic {
      * implemented in the subclass.
      */
     protected static default: PhoneticOptions;
+    /** Phonetic algorithm name for identification */
     private readonly algo;
+    /** Phonetic map and options for the algorithm */
     protected readonly options: PhoneticOptions;
+    protected readonly optKey: string;
     protected readonly map: PhoneticMap;
     /**
      * Static method to clear the cache of indexed words.
      */
-    static clear(): void;
+    static clear: () => void;
     /**
      * Constructor for the Phonetic class.
      *
@@ -81,7 +86,7 @@ export declare abstract class Phonetic {
      * @param {number} i - The current position within the word
      * @param {string[]} chars - The word as an array of characters
      * @param {number} charLen - The total length of the word
-     * @returns {string|undefined} - The rule code or undefined if no rule applies
+     * @returns {string | undefined} - The rule code or undefined if no rule applies
      */
     protected applyRules(char: string, i: number, chars: string[], charLen: number): string | undefined;
     /**
@@ -101,9 +106,9 @@ export declare abstract class Phonetic {
      * @param {number} i - The current position within the word
      * @param {string[]} chars - The word as an array of characters
      * @param {number} charLen - The total length of the word
-     * @param {string|null} lastCode - The last code generated (to avoid duplicates)
-     * @param {Record<string, string>} map - The phonetic mapping
-     * @returns {string|undefined} - The phonetic code or undefined if no code applies
+     * @param {string | null} lastCode - The last code generated (to avoid duplicates)
+     * @param {Record< string, string >} map - The phonetic mapping
+     * @returns {string | undefined} - The phonetic code or undefined if no code applies
      */
     protected mapChar(char: string, i: number, chars: string[], charLen: number, lastCode: string | null, map: Record<string, string>): string | undefined;
     /**
@@ -119,7 +124,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.
      *
@@ -153,7 +158,7 @@ export declare abstract class Phonetic {
      * and ensures that the resulting codes are of equal length.
      *
      * @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
+     * @returns {Promise< string[] >} - A promise that resolves to an array of phonetic indices for the input words
      */
     protected loopAsync(words: string[]): Promise<string[]>;
     /**
@@ -161,7 +166,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.
      *
@@ -173,7 +178,7 @@ export declare abstract class Phonetic {
      * Asynchronously generates a phonetic index for the given input string.
      *
      * @param {string} input - The input string to be indexed
-     * @returns {Promise<string[]>} - A promise that resolves to an array of phonetic indices for the input words
+     * @returns {Promise< string[] >} - A promise that resolves to an array of phonetic indices for the input words
      */
     getIndexAsync(input: 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
  */
@@ -28,6 +29,7 @@ import { Phonetic } from './Phonetic';
  * Soundex class extends the Phonetic class to implement the Soundex phonetic algorithm.
  */
 export declare class Soundex extends Phonetic {
+    /** Default options for the Soundex phonetic algorithm */
     protected static default: PhoneticOptions;
     /**
      * Constructor for the Soundex class.

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
  */
@@ -28,4 +29,4 @@ import './Caverphone';
 import './Cologne';
 import './Metaphone';
 import './Soundex';
-export { PhoneticRegistry, PhoneticMappingRegistry, Phonetic, PhoneticCls } from './Phonetic';
+export { Phonetic, PhoneticCls, PhoneticMappingRegistry, PhoneticRegistry } from './Phonetic';

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.1.1
+ * @version 3.2.1
  * @author Paul Köhler (komed3)
  * @license MIT
  */
@@ -17,23 +17,23 @@ export * from './index';
 /**
  * Export utils to implement new metrics
  *
- *  - MetricRegistry: Metric registry service for managing metric implementations.
  *  - Metric: Abstract class representing a generic string metric.
  *  - MetricCls: Type definition for a class constructor that extends the Metric class.
+ *  - MetricRegistry: Metric registry service for managing metric implementations.
  */
-export { MetricRegistry, Metric, MetricCls } from './metric';
+export { Metric, MetricCls, MetricRegistry } from './metric';
 /**
  * Export utils to implement new phonetic algorithms
  *
- *  - PhoneticRegistry: Phonetic registry service for managing phonetic algorithm implementations.
- *  - PhoneticMappingRegistry: Registry for managing phonetic character mappings.
  *  - Phonetic: Abstract class representing a generic phonetic algorithm.
  *  - PhoneticCls: Type definition for a class constructor that extends the Phonetic class.
+ *  - PhoneticMappingRegistry: Registry for managing phonetic character mappings.
+ *  - PhoneticRegistry: Phonetic registry service for managing phonetic algorithm implementations.
  */
-export { PhoneticRegistry, PhoneticMappingRegistry, Phonetic, PhoneticCls } from './phonetic';
+export { Phonetic, PhoneticCls, PhoneticMappingRegistry, PhoneticRegistry } from './phonetic';
 export * as DeepMerge from './utils/DeepMerge';
 export { Filter } from './utils/Filter';
-export { HashTable } from './utils/HashTable';
+export { Hasher, HashTable } from './utils/HashTable';
 export { Pool } from './utils/Pool';
 export { Profiler } from './utils/Profiler';
 export { StructuredData } from './utils/StructuredData';

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
  */
@@ -22,12 +23,13 @@
  * 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} fallback - The default value to return if the path does not exist
- * @returns {T|R|undefined} - The value at the specified path, otherwise the default value
+ * @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, fallback?: any): T | R | undefined;
+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.
  *

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

@@ -20,21 +20,25 @@
  *  - 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
  */
-import type { DiffOptions, DiffLine, DiffGroup } from './Types';
+import type { DiffGroup, DiffLine, DiffOptions } from './Types';
 /**
  * The DiffChecker class provides methods to compare two texts and generate
  * structured diffs, grouped diffs, and unified diff outputs.
  */
 export declare class DiffChecker {
+    /** Original input texts and options */
     private readonly a;
     private readonly b;
     private readonly options;
+    /** Computed diff entries and groups */
     private entries;
     private grouped;
+    /** Flag to indicate if the diff has already been computed */
     private diffRun;
     /**
      * Constructs a new DiffChecker instance for comparing two texts.
@@ -45,8 +49,7 @@ export declare class DiffChecker {
      */
     constructor(a: string, b: string, opt?: DiffOptions);
     /**
-     * Splits both input texts into arrays of lines and returns them
-     * with the maximum line count.
+     * Splits both input texts into arrays of lines and returns them with the maximum line count.
      *
      * @returns { linesA: string[], linesB: string[], maxLen: number }
      */
@@ -115,23 +118,23 @@ export declare class DiffChecker {
      *
      * @returns {DiffLine[]} - Array of line-level diffs
      */
-    getStructuredDiff(): DiffLine[];
+    getStructuredDiff: () => DiffLine[];
     /**
      * Returns the grouped diff as an array of DiffGroup objects.
      *
      * @returns {DiffGroup[]} - Array of grouped diffs
      */
-    getGroupedDiff(): DiffGroup[];
+    getGroupedDiff: () => DiffGroup[];
     /**
      * Returns the unified diff as a plain ASCII string.
      *
      * @returns {string} - Unified diff (ASCII)
      */
-    getASCIIDiff(): string;
+    getASCIIDiff: () => string;
     /**
      * Returns the unified diff as a CLI-colored string.
      *
      * @returns {string} - Unified diff (CLI colors)
      */
-    getCLIDiff(): string;
+    getCLIDiff: () => string;
 }