@nlptools/distance 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -65,6 +65,260 @@ declare function lcsLength(a: string, b: string, algorithm?: "myers" | "dp"): nu
  */
 declare function lcsPairs(a: string, b: string, algorithm?: "myers" | "dp"): Array<[number, number]>;
 //#endregion
+//#region src/edit/jaro.d.ts
+/**
+ * Jaro and Jaro-Winkler similarity algorithms.
+ *
+ * Jaro measures similarity between two strings by considering matching characters
+ * and transpositions. Jaro-Winkler extends Jaro with a prefix bonus.
+ *
+ * Time: O(m * n)
+ */
+/**
+ * Compute Jaro similarity between two strings.
+ *
+ * J(S1, S2) = (1/3) * (m/|S1| + m/|S2| + (m - t/2) / m)
+ *
+ * where m = number of matching characters (within window),
+ *       t = number of transpositions among matching characters.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Jaro similarity in [0, 1]
+ */
+declare function jaro(a: string, b: string): number;
+/**
+ * Options for Jaro-Winkler similarity.
+ */
+interface IJaroWinklerOptions {
+  /**
+   * Weight applied to the common prefix bonus.
+   * @default 0.1
+   */
+  prefixWeight?: number;
+  /**
+   * Maximum length of common prefix to consider.
+   * @default 4
+   */
+  maxPrefix?: number;
+}
+/**
+ * Compute Jaro-Winkler similarity between two strings.
+ *
+ * JW(S1, S2) = Jaro(S1, S2) + l * p * (1 - Jaro(S1, S2))
+ *
+ * where l = length of common prefix (up to maxPrefix),
+ *       p = prefixWeight.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @param options - Configuration
+ * @returns Jaro-Winkler similarity in [0, 1]
+ */
+declare function jaroWinkler(a: string, b: string, options?: IJaroWinklerOptions): number;
+//#endregion
+//#region src/edit/damerau.d.ts
+/**
+ * Damerau-Levenshtein distance (unrestricted variant).
+ *
+ * Extension of Levenshtein that allows transpositions of adjacent characters,
+ * even when substrings are edited multiple times.
+ *
+ * Matches the default behavior of textdistance.rs (restricted = false).
+ *
+ * Time: O(m * n), Space: O(m * n)
+ */
+/**
+ * Compute the Damerau-Levenshtein distance between two strings.
+ *
+ * Allows insertions, deletions, substitutions, and transpositions of
+ * adjacent characters. This is the unrestricted variant, which correctly
+ * handles cases where a substring is edited more than once.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Edit distance (non-negative integer)
+ */
+declare function damerauLevenshtein(a: string, b: string): number;
+/**
+ * Compute the normalized Damerau-Levenshtein similarity in [0, 1].
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Similarity score where 1 means identical
+ */
+declare function damerauLevenshteinNormalized(a: string, b: string): number;
+//#endregion
+//#region src/edit/hamming.d.ts
+/**
+ * Hamming distance — counts character mismatches between equal-length strings.
+ *
+ * Time: O(min(m, n))
+ */
+/**
+ * Compute the Hamming distance between two strings.
+ *
+ * If strings have different lengths, only compares up to the shorter length
+ * and adds the length difference as additional mismatches.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Number of mismatching characters
+ */
+declare function hamming(a: string, b: string): number;
+/**
+ * Compute the normalized Hamming similarity in [0, 1].
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Similarity score where 1 means identical
+ */
+declare function hammingNormalized(a: string, b: string): number;
+//#endregion
+//#region src/edit/lcs-str.d.ts
+/**
+ * Longest Common Substring (contiguous) algorithms.
+ *
+ * Unlike LCS (subsequence), this requires the matching characters to be contiguous.
+ *
+ * Time: O(m * n), Space: O(min(m, n))
+ */
+/**
+ * Compute the length of the Longest Common Substring.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Length of the longest common substring
+ */
+declare function lcsSubstringLength(a: string, b: string): number;
+/**
+ * Compute the LCS substring distance: len(a) + len(b) - 2 * lcsSubstringLength.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns LCS substring distance (non-negative integer)
+ */
+declare function lcsSubstringDistance(a: string, b: string): number;
+/**
+ * Compute the normalized LCS substring similarity in [0, 1].
+ *
+ * Normalized by max(len(a), len(b)) to match textdistance.rs convention.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Similarity score where 1 means identical
+ */
+declare function lcsSubstringNormalized(a: string, b: string): number;
+//#endregion
+//#region src/edit/sift4.d.ts
+/**
+ * SIFT4 simple — fast approximate string distance.
+ *
+ * A fast algorithm for approximate string matching with O(n) complexity
+ * in typical cases. Returns a distance value (lower = more similar).
+ *
+ * Matches the textdistance.rs implementation exactly.
+ *
+ * Time: O(n * maxOffset)
+ */
+/**
+ * Options for SIFT4.
+ */
+interface ISift4Options {
+  /**
+   * Maximum offset for character matching.
+   * @default 5
+   */
+  maxOffset?: number;
+}
+/**
+ * Compute the SIFT4 simple distance between two strings.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @param options - Configuration
+ * @returns Distance (non-negative integer)
+ */
+declare function sift4(a: string, b: string, options?: ISift4Options): number;
+/**
+ * Compute the normalized SIFT4 similarity in [0, 1].
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @param options - Configuration
+ * @returns Similarity score where 1 means identical
+ */
+declare function sift4Normalized(a: string, b: string, options?: ISift4Options): number;
+//#endregion
+//#region src/edit/ratcliff.d.ts
+/**
+ * Ratcliff-Obershelp algorithm — Gestalt pattern matching.
+ *
+ * Iteratively finds the longest common substring using a stack-based approach,
+ * combining scores from both sides. Returns a similarity in [0, 1].
+ *
+ * Based on the textdistance.rs implementation.
+ *
+ * Time: O(n * m * log(n * m)) worst case, O(n + m) average
+ */
+/**
+ * Compute Ratcliff-Obershelp similarity between two strings.
+ *
+ * Uses an iterative stack-based approach to avoid stack overflow on
+ * very different strings. The algorithm recursively finds the longest
+ * common substring and combines similarity scores from both sides.
+ *
+ * similarity = 2 * M / T, where M = total matched characters, T = total characters
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Ratcliff-Obershelp similarity in [0, 1]
+ */
+declare function ratcliff(a: string, b: string): number;
+//#endregion
+//#region src/edit/smith-waterman.d.ts
+/**
+ * Smith-Waterman local sequence alignment algorithm.
+ *
+ * Designed for biological sequence alignment, it finds the best
+ * local alignment between two sequences.
+ *
+ * Default scoring: match=1, mismatch=0, gap=-1 (matches textdistance.rs)
+ *
+ * Time: O(m * n), Space: O(m * n)
+ */
+/**
+ * Options for Smith-Waterman alignment.
+ */
+interface ISmithWatermanOptions {
+  /** Score for matching characters. @default 1 */
+  matchScore?: number;
+  /** Score for mismatching characters. @default 0 */
+  mismatchScore?: number;
+  /** Score penalty for a gap. @default -1 */
+  gapScore?: number;
+}
+/**
+ * Compute the raw Smith-Waterman alignment score.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @param options - Scoring parameters
+ * @returns Raw alignment score (non-negative)
+ */
+declare function smithWaterman(a: string, b: string, options?: ISmithWatermanOptions): number;
+/**
+ * Compute the normalized Smith-Waterman similarity in [0, 1].
+ *
+ * Normalized by matchScore * max(len(a), len(b)), matching textdistance.rs convention.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @param options - Scoring parameters
+ * @returns Normalized similarity in [0, 1]
+ */
+declare function smithWatermanNormalized(a: string, b: string, options?: ISmithWatermanOptions): number;
+//#endregion
 //#region src/token/jaccard.d.ts
 /**
  * Jaccard similarity between two strings based on character-level multiset.
@@ -95,10 +349,10 @@ declare function jaccardNgram(a: string, b: string, n?: number): number;
 /**
  * Cosine similarity between two strings based on character-level multiset.
  *
- * cos(A, B) = (A · B) / (|A| * |B|)
+ * Uses textdistance.rs convention:
+ *   cosine(A, B) = intersect_count(A, B) / sqrt(count(A) * count(B))
  *
- * Uses Counter (frequency map) for multiset semantics,
- * matching the textdistance crate behavior.
+ * Where intersect_count = sum(min(freqA[c], freqB[c])) and count = sum of frequencies.
  *
  * Time: O(m + n)
  *
@@ -110,6 +364,9 @@ declare function cosine(a: string, b: string): number;
 /**
  * Cosine similarity based on character n-grams.
  *
+ * Uses textdistance.rs convention (same as character-level cosine but on n-grams):
+ *   cosine_ngram(A, B) = intersect_count(A, B) / sqrt(count(A) * count(B))
+ *
  * @param a - First string
  * @param b - Second string
  * @param n - N-gram size (default: 2)
@@ -143,6 +400,96 @@ declare function sorensen(a: string, b: string): number;
  */
 declare function sorensenNgram(a: string, b: string, n?: number): number;
 //#endregion
+//#region src/token/tversky.d.ts
+/**
+ * Tversky index — asymmetric set similarity measure.
+ *
+ * Reduces to Jaccard when alpha = beta = 1.
+ * Reduces to Sorensen-Dice when alpha = beta = 0.5.
+ *
+ * Time: O(m + n)
+ */
+/**
+ * Options for Tversky index.
+ */
+interface ITverskyOptions {
+  /**
+   * Weight for elements unique to the first set (a).
+   * @default 1
+   */
+  alpha?: number;
+  /**
+   * Weight for elements unique to the second set (b).
+   * @default 1
+   */
+  beta?: number;
+}
+/**
+ * Compute the Tversky index between two strings based on character multiset.
+ *
+ * T(A, B; α, β) = |A ∩ B| / (|A ∩ B| + α|A \ B| + β|B \ A|)
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @param options - alpha and beta weights
+ * @returns Tversky index in [0, 1]
+ */
+declare function tversky(a: string, b: string, options?: ITverskyOptions): number;
+//#endregion
+//#region src/token/overlap.d.ts
+/**
+ * Overlap coefficient — set similarity normalized by the smaller set.
+ *
+ * overlap(A, B) = |A ∩ B| / min(|A|, |B|)
+ *
+ * Time: O(m + n)
+ */
+/**
+ * Compute the overlap coefficient between two strings based on character multiset.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Overlap coefficient in [0, 1]
+ */
+declare function overlap(a: string, b: string): number;
+//#endregion
+//#region src/token/naive.d.ts
+/**
+ * Naive string similarity measures: prefix, suffix, length.
+ *
+ * Time: O(min(m, n)) for prefix/suffix, O(1) for length
+ */
+/**
+ * Compute prefix similarity between two strings.
+ *
+ * prefix(a, b) = commonPrefixLength / max(|a|, |b|)
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Prefix similarity in [0, 1]
+ */
+declare function prefix(a: string, b: string): number;
+/**
+ * Compute suffix similarity between two strings.
+ *
+ * suffix(a, b) = commonSuffixLength / max(|a|, |b|)
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Suffix similarity in [0, 1]
+ */
+declare function suffix(a: string, b: string): number;
+/**
+ * Compute length-based similarity between two strings.
+ *
+ * length(a, b) = 1 - |len(a) - len(b)| / max(len(a), len(b))
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Normalized length similarity in [0, 1]
+ */
+declare function length(a: string, b: string): number;
+//#endregion
 //#region src/hash/simhash.d.ts
 interface ISimHashOptions {
   /**
@@ -389,4 +736,360 @@ declare class LSH {
   get size(): number;
 }
 //#endregion
-export { DiffType, type IDiffItem, type IDiffOptions, ILSHOptions, type ILcs, type ILcsAlgorithm, IMinHashOptions, ISimHashOptions, LSH, LcsPairsFunc, LcsSizeFunc, MinHash, SimHasher, cosine, cosineNgram, diff, hammingDistance, hammingSimilarity, jaccard, jaccardNgram, lcsDistance, lcsLength, lcsNormalized, lcsPairs, levenshtein, levenshteinNormalized, simhash, sorensen, sorensenNgram, stringEquals };
+//#region src/search.d.ts
+/**
+ * A function that computes similarity between two strings, returning a value
+ * in [0, 1] where 1 means identical.
+ */
+type SimilarityFn = (a: string, b: string) => number;
+/**
+ * Built-in similarity algorithms. Each maps to a normalized similarity
+ * function from @nlptools/distance.
+ */
+type BuiltinAlgorithm = "levenshtein" | "lcs" | "jaccard" | "jaccardNgram" | "cosine" | "cosineNgram" | "sorensen" | "sorensenNgram";
+/**
+ * Configuration for a searchable key on an object item.
+ *
+ * @example
+ * ```ts
+ * const keys = [
+ *   { name: "title", weight: 0.7 },
+ *   { name: "author", weight: 0.3 },
+ * ];
+ * ```
+ */
+interface ISearchKey {
+  /** Property name to search on. */
+  name: string;
+  /**
+   * Weight of this key in the final score.
+   * Weights are normalized to sum to 1.0 internally.
+   * @default 1
+   */
+  weight?: number;
+  /**
+   * Optional custom getter function. If provided, used instead of
+   * reading `item[name]`. Must return a string.
+   */
+  getter?: (item: any) => string;
+}
+/**
+ * A single search result, containing the matched item, its score, and
+ * its position in the original collection.
+ *
+ * Results are sorted by score descending (best match first).
+ */
+interface ISearchResult<T> {
+  /** The matched item from the collection. */
+  item: T;
+  /**
+   * Similarity score in [0, 1], where 1 means identical.
+   * For multi-key search, this is the weighted sum of per-key scores.
+   */
+  score: number;
+  /** Index of the item in the original collection array. */
+  index: number;
+}
+/**
+ * Extended search result including per-key match details.
+ * Only produced when `includeMatchDetails` is true.
+ */
+interface ISearchResultWithDetails<T> extends ISearchResult<T> {
+  /**
+   * Per-key similarity scores.
+   * Keys are the key names from the ISearchKey configuration.
+   * Values are individual similarity scores in [0, 1].
+   */
+  matches: Record<string, number>;
+}
+/**
+ * Options for the {@link FuzzySearch} constructor.
+ *
+ * @example
+ * ```ts
+ * // String array
+ * const search = new FuzzySearch(["apple", "banana", "cherry"]);
+ *
+ * // Object array with weighted keys
+ * const search = new FuzzySearch(books, {
+ *   keys: [
+ *     { name: "title", weight: 0.7 },
+ *     { name: "author", weight: 0.3 },
+ *   ],
+ *   algorithm: "cosine",
+ *   threshold: 0.4,
+ * });
+ * ```
+ */
+interface IFuzzySearchOptions {
+  /**
+   * Similarity algorithm to use for comparing strings.
+   *
+   * - A string from {@link BuiltinAlgorithm} selects a built-in function.
+   * - A custom {@link SimilarityFn} can be provided for full control.
+   *
+   * @default "levenshtein"
+   */
+  algorithm?: BuiltinAlgorithm | SimilarityFn;
+  /**
+   * Keys to search on when the collection contains objects.
+   * Ignored for string arrays.
+   */
+  keys?: ISearchKey[];
+  /**
+   * Minimum similarity score (0-1) for a result to be included.
+   * Results scoring below this threshold are excluded.
+   * @default 0
+   */
+  threshold?: number;
+  /**
+   * Maximum number of results to return.
+   * @default Infinity
+   */
+  limit?: number;
+  /**
+   * Whether search should be case-sensitive.
+   * When false (default), both the query and the item strings are lowercased
+   * before comparison (case-insensitive search).
+   * @default false
+   */
+  caseSensitive?: boolean;
+  /**
+   * Include per-key match details in results.
+   * When true, results include a `matches` field with individual
+   * similarity scores per key.
+   * @default false
+   */
+  includeMatchDetails?: boolean;
+  /**
+   * Enable LSH-accelerated search for large collections (>1000 items).
+   * Uses MinHash + banding as a candidate filter, then re-scores with
+   * the exact algorithm. Provides sub-linear query time at the cost of
+   * approximate results (some true matches may be missed).
+   */
+  lsh?: {
+    /** Number of hash functions for MinHash signature size. @default 128 */numHashes?: number;
+    /**
+     * Number of bands for LSH banding.
+     * More bands = higher recall, lower precision.
+     * @default 16
+     */
+    numBands?: number;
+  };
+}
+/**
+ * Options for the {@link findBestMatch} function.
+ *
+ * @example
+ * ```ts
+ * const result = findBestMatch("kitten", ["sitting", "kit", "mitten"], {
+ *   algorithm: "levenshtein",
+ *   threshold: 0.3,
+ * });
+ * ```
+ */
+interface IFindBestMatchOptions {
+  /** Similarity algorithm. @default "levenshtein" */
+  algorithm?: BuiltinAlgorithm | SimilarityFn;
+  /** Keys for object-array search. */
+  keys?: ISearchKey[];
+  /** Minimum similarity score. @default 0 */
+  threshold?: number;
+  /** Whether search is case-insensitive. @default false (case-insensitive) */
+  caseSensitive?: boolean;
+}
+/**
+ * Fuzzy search engine for finding similar items in a collection.
+ *
+ * Supports both string arrays and object arrays with weighted multi-key search.
+ * Uses any similarity algorithm from @nlptools/distance, with optional LSH
+ * acceleration for large datasets.
+ *
+ * @example
+ * ```ts
+ * // String array search
+ * const search = new FuzzySearch(["apple", "banana", "cherry"]);
+ * const results = search.search("aple"); // [{ item: "apple", score: 0.75, index: 0 }]
+ *
+ * // Object array with weighted keys
+ * const books = [
+ *   { title: "Old Man's War", author: "John Scalzi" },
+ *   { title: "The Lock Artist", author: "Steve Hamilton" },
+ * ];
+ * const bookSearch = new FuzzySearch(books, {
+ *   keys: [
+ *     { name: "title", weight: 0.7 },
+ *     { name: "author", weight: 0.3 },
+ *   ],
+ *   algorithm: "cosine",
+ * });
+ * const results = bookSearch.search("old man"); // finds "Old Man's War"
+ * ```
+ */
+declare class FuzzySearch<T> {
+  private readonly similarityFn;
+  private readonly keys;
+  private readonly threshold;
+  private readonly limit;
+  private readonly caseSensitive;
+  private readonly includeMatchDetails;
+  private readonly isObjectArray;
+  private collection;
+  private readonly useLSH;
+  private readonly lshNumHashes;
+  private readonly lshNumBands;
+  private lshIndex;
+  private minHashSignatures;
+  constructor(collection: ReadonlyArray<T>, options?: IFuzzySearchOptions);
+  /**
+   * Search the collection for items similar to the query.
+   *
+   * @param query - The search query string
+   * @param limit - Optional per-query limit override
+   * @returns Array of results sorted by score descending
+   */
+  search(query: string, limit?: number): ISearchResult<T>[];
+  /**
+   * Add an item to the collection.
+   * If LSH is enabled, the index is updated incrementally.
+   */
+  add(item: T): void;
+  /**
+   * Remove an item from the collection by index.
+   * If LSH is enabled, the index is rebuilt (O(n)).
+   *
+   * @returns true if the item was found and removed
+   */
+  remove(index: number): boolean;
+  /**
+   * Replace the entire collection.
+   * If LSH is enabled, the index is rebuilt.
+   */
+  setCollection(collection: ReadonlyArray<T>): void;
+  /**
+   * Get the current collection.
+   */
+  getCollection(): ReadonlyArray<T>;
+  /**
+   * Get the number of items in the collection.
+   */
+  get size(): number;
+  /**
+   * Clear the collection and any LSH index.
+   */
+  clear(): void;
+  private searchLinear;
+  private searchWithLSH;
+  private buildLSHIndex;
+  private buildMinHashSignature;
+  private computeItemScore;
+  private computeDetailedScore;
+  private extractSearchText;
+  private extractKeyValue;
+  private normalizeString;
+}
+/**
+ * Find the single best match for a query against a collection.
+ *
+ * This is a convenience wrapper around {@link FuzzySearch} for one-shot queries.
+ * For repeated searches against the same collection, prefer creating a
+ * {@link FuzzySearch} instance directly.
+ *
+ * Time: O(n * k) where n = collection size, k = number of keys
+ *
+ * @param query - The search query string
+ * @param collection - Array of strings or objects to search
+ * @param options - Search configuration
+ * @returns The best matching result, or null if nothing meets the threshold
+ *
+ * @example
+ * ```ts
+ * // String array
+ * const result = findBestMatch("kitten", ["sitting", "kit", "mitten"]);
+ * console.log(result?.item); // "kit"
+ * console.log(result?.score); // 0.5
+ *
+ * // Object array with weighted keys
+ * const books = [
+ *   { title: "The Great Gatsby", author: "F. Scott Fitzgerald" },
+ *   { title: "Great Expectations", author: "Charles Dickens" },
+ * ];
+ * const result = findBestMatch("grate gatsbi", books, {
+ *   keys: [
+ *     { name: "title", weight: 0.7 },
+ *     { name: "author", weight: 0.3 },
+ *   ],
+ * });
+ * ```
+ */
+declare function findBestMatch<T>(query: string, collection: ReadonlyArray<T>, options?: IFindBestMatchOptions): ISearchResult<T> | null;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Generate character n-grams from a string.
+ *
+ * @param str - Input string
+ * @param n - N-gram size (default: 2 for bigrams)
+ */
+declare function ngrams(str: string, n?: number): string[];
+/**
+ * Build an n-gram frequency map using integer-encoded keys.
+ * Encodes n characters into a single number to avoid string allocation
+ * and speed up Map hashing.
+ *
+ * For ASCII bigrams: key = (c1 << 8) | c2 (fits in 16 bits).
+ * For non-ASCII or n > 2: falls back to string keys.
+ */
+declare function ngramFrequencyMap(str: string, n?: number): Map<number, number> | null;
+/**
+ * Build a frequency map (Counter/multiset) from an iterable of tokens.
+ * Matches the behavior of Rust's textdistance Counter.
+ */
+declare function frequencyMap(tokens: Iterable<string>): Map<string, number>;
+/**
+ * Build a character-level frequency map from a string.
+ * This is the default tokenization strategy used by textdistance.
+ */
+declare function charFrequencyMap(str: string): Map<string, number>;
+/** Size of the ASCII frequency array (covers charCode 0-127). */
+declare const CHAR_FREQ_SIZE = 128;
+/**
+ * Build a character frequency array from a string.
+ * Returns false if any character is non-ASCII (charCode >= 128).
+ * The caller must zero the array before use.
+ */
+declare function buildCharFreqArray(arr: Int32Array, str: string): boolean;
+/**
+ * Count intersect size between two frequency maps.
+ * For each key, takes the minimum count (multiset intersection).
+ */
+declare function intersectCount(a: Map<string, number>, b: Map<string, number>): number;
+/**
+ * Count union size between two frequency maps.
+ * For each key, takes the maximum count (multiset union).
+ */
+declare function unionCount(a: Map<string, number>, b: Map<string, number>): number;
+/**
+ * Get total token count from a frequency map.
+ */
+declare function totalCount(map: Map<string, number>): number;
+declare function intersectCountInt(a: Map<number, number>, b: Map<number, number>): number;
+declare function unionCountInt(a: Map<number, number>, b: Map<number, number>): number;
+declare function totalCountInt(map: Map<number, number>): number;
+/**
+ * Normalize a raw distance to a similarity score in [0, 1].
+ *
+ * @param distance - Raw distance value
+ * @param maxDistance - Maximum possible distance (usually max(len(a), len(b)))
+ */
+declare function normalize(distance: number, maxDistance: number): number;
+/**
+ * FNV-1a hash for strings. Fast, good distribution for hash-based algorithms.
+ */
+declare function fnv1a(str: string): number;
+/**
+ * Combine two hashes into one (for generating multiple independent hash values).
+ */
+declare function combineHash(a: number, b: number): number;
+//#endregion
+export { BuiltinAlgorithm, CHAR_FREQ_SIZE, DiffType, FuzzySearch, type IDiffItem, type IDiffOptions, IFindBestMatchOptions, IFuzzySearchOptions, IJaroWinklerOptions, ILSHOptions, type ILcs, type ILcsAlgorithm, IMinHashOptions, ISearchKey, ISearchResult, ISearchResultWithDetails, ISift4Options, ISimHashOptions, ISmithWatermanOptions, ITverskyOptions, LSH, LcsPairsFunc, LcsSizeFunc, MinHash, SimHasher, SimilarityFn, buildCharFreqArray, charFrequencyMap, combineHash, cosine, cosineNgram, damerauLevenshtein, damerauLevenshteinNormalized, diff, findBestMatch, fnv1a, frequencyMap, hamming, hammingDistance, hammingNormalized, hammingSimilarity, intersectCount, intersectCountInt, jaccard, jaccardNgram, jaro, jaroWinkler, lcsDistance, lcsLength, lcsNormalized, lcsPairs, lcsSubstringDistance, lcsSubstringLength, lcsSubstringNormalized, length, levenshtein, levenshteinNormalized, ngramFrequencyMap, ngrams, normalize, overlap, prefix, ratcliff, sift4, sift4Normalized, simhash, smithWaterman, smithWatermanNormalized, sorensen, sorensenNgram, stringEquals, suffix, totalCount, totalCountInt, tversky, unionCount, unionCountInt };