cmpstr 2.0.2 → 3.0.0

package/dist/types/CmpStrAsync.d.ts

@@ -0,0 +1,233 @@
+/**
+ * CmpStrAsync Asynchronous API
+ * src/CmpStrAsync.ts
+ *
+ * The CmpStrAsync class provides a fully asynchronous, Promise-based interface for
+ * advanced string comparison, similarity measurement, phonetic indexing, filtering
+ * and normalization. It extends the CmpStr class and overrides all relevant methods
+ * to support non-blocking, scalable, and I/O-friendly workloads.
+ *
+ * Features:
+ *  - Asynchronous normalization, filtering, and metric computation
+ *  - Async batch, pairwise, and single string comparison with detailed results
+ *  - Async phonetic indexing and phonetic-aware search and comparison
+ *  - Full compatibility with the synchronous CmpStr API
+ *  - Designed for large-scale, high-performance, and server-side applications
+ *
+ * @module CmpStrAsync
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { CmpStrOptions, CmpStrProcessors, CmpStrResult, NormalizeFlags, PhoneticOptions, MetricRaw, MetricInput, MetricMode, MetricResult, MetricResultSingle, MetricResultBatch } from './utils/Types';
+import { CmpStr } from './CmpStr';
+/**
+ * The CmpStrAsync class provides a fully asynchronous API for string comparison,
+ * phonetic indexing, filtering and normalization.
+ *
+ * @template R - The type of the metric result, defaults to MetricRaw
+ */
+export declare class CmpStrAsync<R = MetricRaw> extends CmpStr<R> {
+    /**
+     * --------------------------------------------------------------------------------
+     * Instanciate the CmpStrAsync class
+     * --------------------------------------------------------------------------------
+     *
+     * Methods to create a new CmpStrAsync instance with the given options.
+     * Using the static `create` method is recommended to ensure proper instantiation.
+     */
+    /**
+     * Creates a new CmpStrAsync instance with the given options.
+     *
+     * @param {string|CmpStrOptions} [opt] - Optional serialized or options object
+     * @returns {CmpStrAsync<R>} - A new CmpStrAsync instance
+     */
+    static create<R = MetricRaw>(opt?: string | CmpStrOptions): CmpStrAsync<R>;
+    /**
+     * Creates a new CmpStrAsync instance calliing the super constructor.
+     *
+     * @param {string|CmpStrOptions} [opt] - Optional serialized or options object
+     */
+    protected constructor(opt?: string | CmpStrOptions);
+    /**
+     * ---------------------------------------------------------------------------------
+     * Protected asynchronously utility methods for internal use
+     * ---------------------------------------------------------------------------------
+     *
+     * These methods provide asynchronous normalization, filtering, and metric
+     * computation capabilities, allowing for non-blocking operations.
+     */
+    /**
+     * Asynchronously normalizes the input string or array using the configured or provided flags.
+     *
+     * @param {MetricInput} input - The input string or array
+     * @param {NormalizeFlags} [flags] - Normalization flags
+     * @returns {Promise<MetricInput>} - The normalized input
+     */
+    protected normalizeAsync(input: MetricInput, flags?: NormalizeFlags): Promise<MetricInput>;
+    /**
+     * Asynchronously applies all active filters to the input string or array.
+     *
+     * @param {MetricInput} input - The input string or array
+     * @param {string} [hook='input'] - The filter hook
+     * @returns {Promise<MetricInput>} - The filtered string(s)
+     */
+    protected filterAsync(input: MetricInput, hook: string): Promise<MetricInput>;
+    /**
+     * Asynchronously prepares the input by normalizing and filtering.
+     *
+     * @param {MetricInput} [input] - The input string or array
+     * @param {CmpStrOptions} [opt] - Optional options to use
+     * @returns {Promise<MetricInput>} - The prepared input
+     */
+    protected prepareAsync(input: MetricInput, opt?: CmpStrOptions): Promise<MetricInput>;
+    /**
+     * Asynchronously computes the phonetic index for the given input using
+     * the specified phonetic algorithm.
+     *
+     * @param {MetricInput} input - The input string or array
+     * @param {{ algo: string, opt?: PhoneticOptions }} options - The phonetic algorithm and options
+     * @returns {Promise<MetricInput>} - The phonetic index for the given input
+     */
+    protected indexAsync(input: MetricInput, { algo, opt }: {
+        algo: string;
+        opt?: PhoneticOptions;
+    }): Promise<MetricInput>;
+    /**
+     * Asynchronously computes the metric result for the given inputs, applying
+     * normalization and filtering as configured.
+     *
+     * @template T - The type of the metric result
+     * @param {MetricInput} a - The first input string or array
+     * @param {MetricInput} b - The second input string or array
+     * @param {CmpStrOptions} [opt] - Optional options to use
+     * @param {MetricMode} [mode='single'] - The metric mode to use
+     * @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
+     */
+    protected computeAsync<T extends MetricResult<R> | CmpStrResult | CmpStrResult[]>(a: MetricInput, b: MetricInput, opt?: CmpStrOptions, mode?: MetricMode, raw?: boolean, skip?: boolean): Promise<T>;
+    /**
+     * ---------------------------------------------------------------------------------
+     * Public asynchronously core methods for string comparison
+     * ---------------------------------------------------------------------------------
+     *
+     * These methods provide the asynchronous core functionality for string comparison,
+     * phonetic indexing and text search, allowing for non-blocking operations.
+     */
+    /**
+     * Asynchronously performs a single metric comparison.
+     *
+     * @template T - The type of the metric result
+     * @param {string} a - The source string
+     * @param {string} b - The target string
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The metric result
+     */
+    testAsync<T extends CmpStrResult | MetricResultSingle<R>>(a: string, b: string, opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously performs a single metric comparison returning the numeric score.
+     *
+     * @param {string} a - The source string
+     * @param {string} b - The target string
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<number>} - The similarity score (0..1)
+     */
+    compareAsync(a: string, b: string, opt?: CmpStrOptions): Promise<number>;
+    /**
+     * Asynchronously performs a batch metric comparison between source and target
+     * strings or array of strings.
+     *
+     * @template T - The type of the metric result
+     * @param {MetricInput} a - The source string or array of strings
+     * @param {MetricInput} b - The target string or array of strings
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The batch metric results
+     */
+    batchTestAsync<T extends CmpStrResult[] | MetricResultBatch<R>>(a: MetricInput, b: MetricInput, opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously performs a batch metric comparison and returns results sorted by score.
+     *
+     * @template T - The type of the metric result
+     * @param {MetricInput} a - The source string or array of strings
+     * @param {MetricInput} b - The target string or array of strings
+     * @param {'desc'|'asc'} [dir='desc'] - Sort direction (desc, asc)
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The sorted batch results
+     */
+    batchSortedAsync<T extends CmpStrResult[] | MetricResultBatch<R>>(a: MetricInput, b: MetricInput, dir?: 'desc' | 'asc', opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously performs a pairwise metric comparison between source and target
+     * strings or array of strings.
+     *
+     * @template T - The type of the metric result
+     * Input arrays needs of the same length to perform pairwise comparison,
+     * otherwise the method will throw an error.
+     *
+     * @param {MetricInput} a - The source string or array of strings
+     * @param {MetricInput} b - The target string or array of strings
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The pairwise metric results
+     */
+    pairsAsync<T extends CmpStrResult[] | MetricResultBatch<R>>(a: MetricInput, b: MetricInput, opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously performs a batch comparison and returns only results above the threshold.
+     *
+     * @template T - The type of the metric result
+     * @param {MetricInput} a - The source string or array of strings
+     * @param {MetricInput} b - The target string or array of strings
+     * @param {number} threshold - The similarity threshold (0..1)
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The filtered batch results
+     */
+    matchAsync<T extends CmpStrResult[] | MetricResultBatch<R>>(a: MetricInput, b: MetricInput, threshold: number, opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously returns the n closest matches from a batch comparison.
+     *
+     * @template T - The type of the metric result
+     * @param {MetricInput} a - The source string or array of strings
+     * @param {MetricInput} b - The target string or array of strings
+     * @param {number} [n=1] - Number of closest matches
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The closest matches
+     */
+    closestAsync<T extends CmpStrResult[] | MetricResultBatch<R>>(a: MetricInput, b: MetricInput, n?: number, opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously returns the n furthest matches from a batch comparison.
+     *
+     * @template T - The type of the metric result
+     * @param {MetricInput} a - The source string or array of strings
+     * @param {MetricInput} b - The target string or array of strings
+     * @param {number} [n=1] - Number of furthest matches
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<T>} - The furthest matches
+     */
+    furthestAsync<T extends CmpStrResult[] | MetricResultBatch<R>>(a: MetricInput, b: MetricInput, n?: number, opt?: CmpStrOptions): Promise<T>;
+    /**
+     * Asynchronously performs a normalized and filtered substring search.
+     *
+     * @param {string} needle - The search string
+     * @param {string[]} haystack - The array to search in
+     * @param {NormalizeFlags} [flags] - Normalization flags
+     * @param {CmpStrProcessors} [processors] - Pre-processors to apply
+     * @returns {Promise<string[]>} - Array of matching entries
+     */
+    searchAsync(needle: string, haystack: string[], flags?: NormalizeFlags, processors?: CmpStrProcessors): Promise<string[]>;
+    /**
+     * Asynchronously computes a similarity matrix for the given input array.
+     *
+     * @param {string[]} input - The input array
+     * @param {CmpStrOptions} [opt] - Optional options
+     * @returns {Promise<number[][]>} - The similarity matrix
+     */
+    matrixAsync(input: string[], opt?: CmpStrOptions): Promise<number[][]>;
+    /**
+     * Asynchronously computes the phonetic index for a string using the
+     * configured or given algorithm.
+     *
+     * @param {string} [input] - The input string
+     * @param {string} [algo] - The phonetic algorithm to use
+     * @param {PhoneticOptions} [opt] - Optional phonetic options
+     * @returns {Promise<string>} - The phonetic index as a string
+     */
+    phoneticIndexAsync(input: string, algo?: string, opt?: PhoneticOptions): Promise<string>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * CmpStr Main Entry Point
+ * src/index.ts
+ *
+ * CmpStr is a comprehensive, extensible, and highly abstracted TypeScript library for
+ * advanced string comparison, similarity measurement, phonetic indexing, normalization,
+ * 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.0.0
+ * Author: Paul Köhler (komed3)
+ * License: MIT
+ *
+ * Core Features:
+ * --------------
+ *
+ *  - Unified interface for string similarity, distance, and matching
+ *  - Pluggable metric system (Levenshtein, Jaro-Winkler, Cosine, Dice, Hamming, LCS, etc.)
+ *  - Phonetic algorithms (Cologne, Soundex, Metaphone) with mapping registry
+ *  - Flexible normalization and filtering pipeline for all inputs
+ *  - Batch, pairwise, and single comparison with detailed, type-safe results
+ *  - Phonetic-aware search, indexing, and comparison
+ *  - Readability and text analysis utilities (syllables, word stats, etc.)
+ *  - Unified diff and difference reporting (line/word, ASCII/CLI)
+ *  - Full TypeScript type safety, extensibility, and profiling support
+ *  - Modular architecture for easy integration and extension
+ *
+ * Overview:
+ * ---------
+ *
+ * CmpStr provides a single entry point for all string comparison and analysis tasks.
+ * The main class, `CmpStr`, exposes a rich API for comparing strings, arrays, or
+ * batches, with full support for normalization, filtering, and phonetic processing.
+ * All metric and phonetic algorithms are managed via registries, allowing for
+ * dynamic extension and customization. The package also includes utilities for
+ * diffing, text analysis, and profiling, making it suitable for applications such as
+ * search engines, data deduplication, fuzzy matching, linguistics, and more.
+ *
+ * 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.0.0
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+export * from './utils/Types';
+export { CmpStr } from './CmpStr';
+export { CmpStrAsync } from './CmpStrAsync';
+export { DiffChecker } from './utils/DiffChecker';
+export { Normalizer } from './utils/Normalizer';
+export { TextAnalyzer } from './utils/TextAnalyzer';

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

@@ -0,0 +1,57 @@
+/**
+ * Cosine Similarity
+ * src/metric/Cosine.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Cosine_similarity
+ *
+ * Cosine similarity is a metric used to measure how similar two vectors are, regardless
+ * of their magnitude. In text analysis, it is commonly used to compare documents or
+ * strings by representing them as term frequency vectors and computing the cosine of
+ * the angle between these vectors.
+ *
+ * The result is a value between 0 and 1, where 1 means the vectors are identical and
+ * 0 means they are orthogonal (no similarity).
+ *
+ * @module Metric/CosineSimilarity
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface CosineRaw {
+    dotProduct: number;
+    magnitudeA: number;
+    magnitudeB: number;
+}
+/**
+ * CosineSimilarity class extends the Metric class to implement the Cosine similarity algorithm.
+ */
+export declare class CosineSimilarity extends Metric<CosineRaw> {
+    /**
+     * Constructor for the CosineSimilarity class.
+     *
+     * Initializes the Cosine similarity metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Calculates the term frequency vector for a given string.
+     *
+     * @param {string} str - The input string
+     * @param {string} delimiter - The delimiter to split terms
+     * @return {Map<string, number>} - Term frequency object
+     */
+    private _termFreq;
+    /**
+     * Calculates the Cosine similarity between two strings.
+     *
+     * @param {string} a - First string
+     * @param {string} b - Second string
+     * @return {MetricCompute<CosineRaw>} - Object containing the similarity result and raw values
+     */
+    protected compute(a: string, b: string): MetricCompute<CosineRaw>;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Damerau-Levenshtein Distance
+ * src/metric/DamerauLevenshtein.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance
+ *
+ * The Damerau-Levenshtein distance extends the classical Levenshtein algorithm by
+ * including transpositions (swapping of two adjacent characters) as a single edit
+ * operation, in addition to insertions, deletions, and substitutions.
+ *
+ * This metric is particularly useful for detecting and correcting common
+ * typographical errors.
+ *
+ * @module Metric/DamerauLevenshtein
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface DamerauRaw {
+    dist: number;
+    maxLen: number;
+}
+/**
+ * DamerauLevenshteinDistance class extends the Metric class to implement the Damerau-Levenshtein algorithm.
+ */
+export declare class DamerauLevenshteinDistance extends Metric<DamerauRaw> {
+    /**
+     * Constructor for the DamerauLevenshteinDistance class.
+     *
+     * Initializes the Damerau-Levenshtein metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Calculates the normalized Damerau-Levenshtein distance between two strings.
+     *
+     * @param {string} a - First string (always the shorter string for memory efficiency)
+     * @param {string} b - Second string
+     * @param {number} m - Length of the first string (a)
+     * @param {number} n - Length of the second string (b)
+     * @param {number} maxLen - Maximum length of the strings
+     * @return {MetricCompute<DamerauRaw>} - Object containing the similarity result and raw distance
+     */
+    protected compute(a: string, b: string, m: number, n: number, maxLen: number): MetricCompute<DamerauRaw>;
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Dice-Sørensen Coefficient
+ * src/metric/DiceSorensen.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Dice-S%C3%B8rensen_coefficient
+ *
+ * This module implements the Dice-Sørensen coefficient, a statistic used to gauge
+ * the similarity of two samples. It is commonly used in natural language processing
+ * and information retrieval to compare the similarity between two sets of data,
+ * such as text documents. The coefficient is defined as twice the size of the
+ * intersection divided by the sum of the sizes of the two sets.
+ *
+ * The implementation includes methods to compute bigrams from strings and calculate
+ * the coefficient based on these bigrams. It handles edge cases, such as empty
+ * strings and identical strings, to ensure accurate results.
+ *
+ * @module Metric/DiceSorensenCoefficient
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface DiceRaw {
+    intersection: number;
+    size: number;
+}
+/**
+ * DiceSorensenCoefficient class extends the Metric class to implement the Dice-Sørensen coefficient.
+ */
+export declare class DiceSorensenCoefficient extends Metric<DiceRaw> {
+    /**
+     * Constructor for the DiceSorensen class.
+     *
+     * Initializes the DiceSorensen metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Computes the bigrams of a given string.
+     *
+     * @param {string} str - The input string
+     * @return {Set<string>} - A set of bigrams (two-character sequences) from the string
+     */
+    private _bigrams;
+    /**
+     * Calculates the Dice-Sørensen coefficient between two strings.
+     *
+     * @param {string} a - First string
+     * @param {string} b - Second string
+     * @return {MetricCompute<DiceRaw>} - Object containing the similarity result and raw distance
+     */
+    protected compute(a: string, b: string): MetricCompute<DiceRaw>;
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Hamming Distance
+ * src/metric/Hamming.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Hamming_distance
+ *
+ * The Hamming distance is a metric for comparing two strings of equal length. It
+ * measures the number of positions at which the corresponding symbols are different.
+ *
+ * This implementation allows for optional padding of the shorter string to equalize
+ * lengths, otherwise it throws an error if the strings are of unequal length.
+ *
+ * @module Metric/HammingDistance
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface HammingRaw {
+    dist: number;
+}
+/**
+ * HammingDistance class extends the Metric class to implement the Hamming distance.
+ */
+export declare class HammingDistance extends Metric<HammingRaw> {
+    /**
+     * Constructor for the Hamming class.
+     *
+     * Initializes the Hamming distance metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Calculates the Hamming distance between two strings.
+     *
+     * @param {string} a - First string
+     * @param {string} b - Second string
+     * @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<HammingRaw>} - Object containing the similarity result and raw distance
+     * @throws {Error} - If strings are of unequal length and padding is not specified
+     */
+    protected compute(a: string, b: string, m: number, n: number, maxLen: number): MetricCompute<HammingRaw>;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Jaccard Index
+ * src/metric/Jaccard.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Jaccard_index
+ *
+ * The Jaccard Index (or Jaccard similarity coefficient) measures the similarity
+ * between two sets by dividing the size of their intersection by the size of
+ * their union. In string similarity, it is often used to compare sets of characters,
+ * tokens, or n-grams. The result is a value between 0 and 1, where 1 means the
+ * sets are identical and 0 means they have no elements in common.
+ *
+ * @module Metric/JaccardIndex
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface JaccardRaw {
+    intersection: number;
+    union: number;
+}
+/**
+ * JaccardIndex class extends the Metric class to implement the Jaccard Index algorithm.
+ */
+export declare class JaccardIndex extends Metric<JaccardRaw> {
+    /**
+     * Constructor for the JaccardIndex class.
+     *
+     * Initializes the Jaccard Index metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Calculates the Jaccard Index between two strings.
+     *
+     * @param {string} a - First string
+     * @param {string} b - Second string
+     * @param {number} m - Length of the first string
+     * @param {number} n - Length of the second string
+     * @return {MetricCompute<JaccardRaw>} - Object containing the similarity result and raw values
+     */
+    protected compute(a: string, b: string, m: number, n: number): MetricCompute<JaccardRaw>;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Jaro-Winkler Distance
+ * src/metric/JaroWinkler.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance
+ *
+ * The Jaro-Winkler distance is a string similarity metric that gives more weight
+ * to matching characters at the start of the strings. It is especially effective
+ * for short strings and typographical errors, and is widely used in record linkage
+ * and duplicate detection.
+ *
+ * @module Metric/JaroWinkler
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface JaroWinklerRaw {
+    matchWindow: number;
+    matches: number;
+    transpos: number;
+    jaro: number;
+    prefix: number;
+}
+/**
+ * JaroWinklerDistance class extends the Metric class to implement the Jaro-Winkler algorithm.
+ */
+export declare class JaroWinklerDistance extends Metric<JaroWinklerRaw> {
+    /**
+     * Constructor for the JaroWinklerDistance class.
+     *
+     * Initializes the Jaro-Winkler metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Calculates the Jaro-Winkler similarity between two strings.
+     *
+     * @param {string} a - First string
+     * @param {string} b - Second string
+     * @param {number} m - Length of the first string
+     * @param {number} n - Length of the second string
+     * @return {MetricCompute<JaroWinklerRaw>} - Object containing the similarity result and raw values
+     */
+    protected compute(a: string, b: string, m: number, n: number): MetricCompute<JaroWinklerRaw>;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Longest Common Subsequence (LCS)
+ * src/metric/LCS.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Longest_common_subsequence
+ *
+ * The Longest Common Subsequence (LCS) metric measures the length of the longest
+ * subsequence common to both strings. Unlike substrings, the characters of a
+ * subsequence do not need to be contiguous, but must appear in the same order.
+ *
+ * The LCS is widely used in diff tools, bioinformatics, and approximate string
+ * matching.
+ *
+ * @module Metric/LCS
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { MetricInput, MetricOptions, MetricCompute } from '../utils/Types';
+import { Metric } from './Metric';
+export interface LCSRaw {
+    lcs: number;
+    maxLen: number;
+}
+/**
+ * LCSMetric class extends the Metric class to implement the Longest Common Subsequence algorithm.
+ */
+export declare class LCSMetric extends Metric<LCSRaw> {
+    /**
+     * Constructor for the LCSMetric class.
+     *
+     * Initializes the LCS metric with two input strings or
+     * arrays of strings and optional options.
+     *
+     * @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
+     */
+    constructor(a: MetricInput, b: MetricInput, opt?: MetricOptions);
+    /**
+     * Calculates the normalized LCS similarity between two strings.
+     *
+     * @param {string} a - First string
+     * @param {string} b - Second string
+     * @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<LCSRaw>} - Object containing the similarity result and raw LCS length
+     */
+    protected compute(a: string, b: string, m: number, n: number, maxLen: number): MetricCompute<LCSRaw>;
+}