cspell-trie-lib 5.15.2 → 5.17.0

package/dist/lib/SimpleDictionaryParser.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDictionary = exports.parseLinesToDictionary = exports.parseDictionaryLines = exports.defaultParseDictionaryOptions = void 0;
 const gensequence_1 = require("gensequence");
-const util_1 = require("./util");
+const trie_util_1 = require("./trie-util");
 const constants_1 = require("./constants");
 const TrieBuilder_1 = require("./TrieBuilder");
 const _defaultOptions = {
@@ -68,14 +68,14 @@ function parseDictionaryLines(lines, options) {
         return word[0] === keepCase ? word.slice(1) : word;
     }
     function _normalize(word) {
-        return (0, util_1.normalizeWord)(stripKeepCasePrefixAndQuotes(word));
+        return (0, trie_util_1.normalizeWord)(stripKeepCasePrefixAndQuotes(word));
     }
     function* mapNormalize(word) {
         const nWord = _normalize(word);
         const forms = new Set();
         forms.add(nWord);
         if (stripCaseAndAccents && !doNotNormalizePrefix.has(word[0])) {
-            for (const n of (0, util_1.normalizeWordForCaseInsensitive)(nWord)) {
+            for (const n of (0, trie_util_1.normalizeWordForCaseInsensitive)(nWord)) {
                 if (n !== nWord)
                     forms.add(ignoreCase + n);
             }

package/dist/lib/TrieBuilder.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrieBuilder = exports.buildTrieFast = exports.buildTrie = void 0;
 const trie_1 = require("./trie");
 const consolidate_1 = require("./consolidate");
-const util_1 = require("./util");
-const secondChanceCache_1 = require("./secondChanceCache");
+const trie_util_1 = require("./trie-util");
+const secondChanceCache_1 = require("./utils/secondChanceCache");
 /**
  * Builds an optimized Trie from a Iterable<string>. It attempts to reduce the size of the trie
  * by finding common endings.
@@ -21,7 +21,7 @@ exports.buildTrie = buildTrie;
  * @param trieOptions options for the Trie
  */
 function buildTrieFast(words, trieOptions) {
-    const root = (0, util_1.createTriFromList)(words, trieOptions);
+    const root = (0, trie_util_1.createTriFromList)(words, trieOptions);
     return new trie_1.Trie(root, undefined);
 }
 exports.buildTrieFast = buildTrieFast;
@@ -42,7 +42,7 @@ class TrieBuilder {
         this._canBeCached(this._eow); // this line is just for coverage reasons
         this.signatures.set(this.signature(this._eow), this._eow);
         this.cached.set(this._eow, this.count++);
-        this.trieOptions = Object.freeze((0, util_1.mergeOptionalWithDefaults)(trieOptions));
+        this.trieOptions = Object.freeze((0, trie_util_1.mergeOptionalWithDefaults)(trieOptions));
         if (words) {
             this.insert(words);
         }
@@ -51,7 +51,7 @@ class TrieBuilder {
         this.lastPath[0].n = n;
     }
     get _root() {
-        return (0, util_1.trieNodeToRoot)(this.lastPath[0].n, this.trieOptions);
+        return (0, trie_util_1.trieNodeToRoot)(this.lastPath[0].n, this.trieOptions);
     }
     signature(n) {
         const isWord = n.f ? '*' : '';
@@ -199,7 +199,7 @@ class TrieBuilder {
      * Resets the builder
      */
     reset() {
-        this._root = (0, util_1.createTrieRoot)(this.trieOptions);
+        this._root = (0, trie_util_1.createTrieRoot)(this.trieOptions);
         this.cached.clear();
         this.signatures.clear();
         this.signatures.set(this.signature(this._eow), this._eow);

package/dist/lib/TrieNode.d.ts

@@ -1,16 +1,17 @@
+import type { PartialWithUndefined } from './types';
 export declare const FLAG_WORD = 1;
 export declare class ChildMap extends Map<string, TrieNode> {
 }
 export interface TrieNode {
-    f?: number;
-    c?: ChildMap;
+    f?: number | undefined;
+    c?: ChildMap | undefined;
 }
 export interface TrieOptions {
     compoundCharacter: string;
     stripCaseAndAccentsPrefix: string;
     forbiddenWordPrefix: string;
 }
-export declare type PartialTrieOptions = Partial<TrieOptions> | undefined;
+export declare type PartialTrieOptions = PartialWithUndefined<TrieOptions> | undefined;
 export interface TrieRoot extends TrieOptions {
     c: ChildMap;
 }

package/dist/lib/consolidate.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.consolidate = void 0;
 const TrieNode_1 = require("./TrieNode");
-const util_1 = require("./util");
+const trie_util_1 = require("./trie-util");
 /**
  * Consolidate to DAWG
  * @param root the root of the Trie tree
@@ -89,7 +89,7 @@ function consolidate(root) {
     const eow = findEow(root) || { f: TrieNode_1.FLAG_WORD, c: undefined };
     signatures.set(signature(eow), eow);
     cached.set(eow, count++);
-    return (0, util_1.trieNodeToRoot)(process(root), root);
+    return (0, trie_util_1.trieNodeToRoot)(process(root), root);
 }
 exports.consolidate = consolidate;
 //# sourceMappingURL=consolidate.js.map

package/dist/lib/distance/distance.d.ts

@@ -0,0 +1,35 @@
+import type { SuggestionCostMapDef } from '../models/suggestionCostsDef';
+import type { WeightMap } from './weightedMaps';
+export type { SuggestionCostMapDef } from '../models/suggestionCostsDef';
+export type { WeightMap } from './weightedMaps';
+/**
+ * Calculate the edit distance between any two words.
+ * Use the Damerau–Levenshtein distance algorithm.
+ * @param wordA
+ * @param wordB
+ * @param editCost - the cost of each edit (defaults to 100)
+ * @returns the edit distance.
+ */
+export declare function editDistance(wordA: string, wordB: string, editCost?: number): number;
+/**
+ * Calculate the weighted edit distance between any two words.
+ * @param wordA
+ * @param wordB
+ * @param weights - the weights to use
+ * @param editCost - the cost of each edit (defaults to 100)
+ * @returns the edit distance
+ */
+export declare function editDistanceWeighted(wordA: string, wordB: string, weights: WeightMap, editCost?: number): number;
+/**
+ * Collect Map definitions into a single weighted map.
+ * @param defs - list of definitions
+ * @returns A Weighted Map to be used with distance calculations.
+ */
+export declare function createWeightedMap(defs: SuggestionCostMapDef[]): WeightMap;
+/**
+ * Update a WeightedMap with a WeightedMapDef
+ * @param weightedMap - map to update
+ * @param def - the definition to use
+ */
+export declare function updatedWeightedMap(weightedMap: WeightMap, def: SuggestionCostMapDef): void;
+//# sourceMappingURL=distance.d.ts.map

package/dist/lib/distance/distance.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatedWeightedMap = exports.createWeightedMap = exports.editDistanceWeighted = exports.editDistance = void 0;
+const distanceAStarWeighted_1 = require("./distanceAStarWeighted");
+const levenshtein_1 = require("./levenshtein");
+const weightedMaps_1 = require("./weightedMaps");
+const defaultCost = 100;
+/**
+ * Calculate the edit distance between any two words.
+ * Use the Damerau–Levenshtein distance algorithm.
+ * @param wordA
+ * @param wordB
+ * @param editCost - the cost of each edit (defaults to 100)
+ * @returns the edit distance.
+ */
+function editDistance(wordA, wordB, editCost = defaultCost) {
+    return (0, levenshtein_1.levenshteinDistance)(wordA, wordB) * editCost;
+}
+exports.editDistance = editDistance;
+/**
+ * Calculate the weighted edit distance between any two words.
+ * @param wordA
+ * @param wordB
+ * @param weights - the weights to use
+ * @param editCost - the cost of each edit (defaults to 100)
+ * @returns the edit distance
+ */
+function editDistanceWeighted(wordA, wordB, weights, editCost = defaultCost) {
+    return (0, distanceAStarWeighted_1.distanceAStarWeighted)(wordA, wordB, weights, editCost);
+}
+exports.editDistanceWeighted = editDistanceWeighted;
+/**
+ * Collect Map definitions into a single weighted map.
+ * @param defs - list of definitions
+ * @returns A Weighted Map to be used with distance calculations.
+ */
+function createWeightedMap(defs) {
+    return (0, weightedMaps_1.createWeightMap)(...defs);
+}
+exports.createWeightedMap = createWeightedMap;
+/**
+ * Update a WeightedMap with a WeightedMapDef
+ * @param weightedMap - map to update
+ * @param def - the definition to use
+ */
+function updatedWeightedMap(weightedMap, def) {
+    (0, weightedMaps_1.addDefToWeightMap)(weightedMap, def);
+}
+exports.updatedWeightedMap = updatedWeightedMap;
+//# sourceMappingURL=distance.js.map

package/dist/lib/distance/distanceAStar.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Calculate the edit distance between two words using an A* algorithm.
+ *
+ * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
+ */
+export declare function distanceAStar(a: string, b: string): number;
+//# sourceMappingURL=distanceAStar.d.ts.map

package/dist/lib/distance/distanceAStar.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceAStar = void 0;
+const PairingHeap_1 = require("../utils/PairingHeap");
+/**
+ * Calculate the edit distance between two words using an A* algorithm.
+ *
+ * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
+ */
+function distanceAStar(a, b) {
+    var _a;
+    const aN = a.length;
+    const bN = b.length;
+    const cost = 100;
+    const candidates = new PairingHeap_1.PairingHeap(compare);
+    candidates.add({ ai: 0, bi: 0, c: 0 });
+    function opSub(n) {
+        const { ai, bi, c } = n;
+        if (ai < aN && bi < bN) {
+            const cc = a[ai] === b[bi] ? c : c + cost;
+            candidates.add({ ai: ai + 1, bi: bi + 1, c: cc });
+        }
+    }
+    function opIns(n) {
+        const { ai, bi, c } = n;
+        if (bi < bN) {
+            candidates.add({ ai: ai, bi: bi + 1, c: c + cost });
+        }
+    }
+    function opDel(n) {
+        const { ai, bi, c } = n;
+        if (ai < aN) {
+            candidates.add({ ai: ai + 1, bi: bi, c: c + cost });
+        }
+    }
+    function opSwap(n) {
+        const { ai, bi, c } = n;
+        if (a[ai] === b[bi + 1] && a[ai + 1] === b[bi]) {
+            candidates.add({ ai: ai + 2, bi: bi + 2, c: c + cost });
+        }
+    }
+    let best;
+    // const bc2 = 2 * bc;
+    while ((best = candidates.dequeue())) {
+        if (best.ai === aN && best.bi === bN)
+            break;
+        opSwap(best);
+        opIns(best);
+        opDel(best);
+        opSub(best);
+    }
+    return (_a = best === null || best === void 0 ? void 0 : best.c) !== null && _a !== void 0 ? _a : -1;
+}
+exports.distanceAStar = distanceAStar;
+function compare(a, b) {
+    // Choose lowest cost or farthest Manhattan distance.
+    return a.c - b.c || b.ai + b.bi - a.ai - a.bi;
+}
+//# sourceMappingURL=distanceAStar.js.map

package/dist/lib/distance/distanceAStarWeighted.d.ts

@@ -0,0 +1,20 @@
+import { WeightMap } from './weightedMaps';
+/**
+ * Calculate the edit distance between two words using an A* algorithm.
+ *
+ * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
+ */
+export declare function distanceAStarWeighted(wordA: string, wordB: string, map: WeightMap, cost?: number): number;
+export interface ExResult {
+    a: string;
+    b: string;
+    cost: number;
+    segments: {
+        a: string;
+        b: string;
+        c: number;
+        p: number;
+    }[];
+}
+export declare function distanceAStarWeightedEx(wordA: string, wordB: string, map: WeightMap, cost?: number): ExResult | undefined;
+//# sourceMappingURL=distanceAStarWeighted.d.ts.map

package/dist/lib/distance/distanceAStarWeighted.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceAStarWeightedEx = exports.distanceAStarWeighted = void 0;
+const PairingHeap_1 = require("../utils/PairingHeap");
+/**
+ * Calculate the edit distance between two words using an A* algorithm.
+ *
+ * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
+ */
+function distanceAStarWeighted(wordA, wordB, map, cost = 100) {
+    const best = _distanceAStarWeightedEx(wordA, wordB, map, cost);
+    return best ? best.c + best.p : -1;
+}
+exports.distanceAStarWeighted = distanceAStarWeighted;
+function distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
+    const best = _distanceAStarWeightedEx(wordA, wordB, map, cost);
+    if (!best)
+        return undefined;
+    const aa = '^' + wordA + '$';
+    const bb = '^' + wordB + '$';
+    const result = {
+        a: aa,
+        b: bb,
+        cost: best.c + best.p,
+        segments: [],
+    };
+    const segments = result.segments;
+    for (let n = best; n.f; n = n.f) {
+        const f = n.f;
+        const a = aa.slice(f.ai, n.ai);
+        const b = bb.slice(f.bi, n.bi);
+        const c = n.c - f.c;
+        const p = n.p - f.p;
+        segments.push({ a, b, c, p });
+    }
+    segments.reverse();
+    return result;
+}
+exports.distanceAStarWeightedEx = distanceAStarWeightedEx;
+function _distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
+    // Add ^ and $ for begin/end detection.
+    const a = '^' + wordA + '$';
+    const b = '^' + wordB + '$';
+    const aN = a.length;
+    const bN = b.length;
+    const candidates = new PairingHeap_1.PairingHeap(compare);
+    candidates.add({ ai: 0, bi: 0, c: 0, p: 0, f: undefined });
+    /** Substitute / Replace */
+    function opSub(n) {
+        const { ai, bi, c, p } = n;
+        if (ai < aN && bi < bN) {
+            const cc = a[ai] === b[bi] ? c : c + cost;
+            candidates.add({ ai: ai + 1, bi: bi + 1, c: cc, p, f: n });
+        }
+    }
+    /** Insert */
+    function opIns(n) {
+        const { ai, bi, c, p } = n;
+        if (bi < bN) {
+            candidates.add({ ai: ai, bi: bi + 1, c: c + cost, p, f: n });
+        }
+    }
+    /** Delete */
+    function opDel(n) {
+        const { ai, bi, c, p } = n;
+        if (ai < aN) {
+            candidates.add({ ai: ai + 1, bi: bi, c: c + cost, p, f: n });
+        }
+    }
+    /** Swap adjacent letters */
+    function opSwap(n) {
+        const { ai, bi, c, p } = n;
+        if (a[ai] === b[bi + 1] && a[ai + 1] === b[bi]) {
+            candidates.add({ ai: ai + 2, bi: bi + 2, c: c + cost, p, f: n });
+        }
+    }
+    function opMap(n) {
+        const { ai, bi, c, p } = n;
+        const pos = { a, b, ai, bi, c, p };
+        const costCalculations = [map.calcInsDelCosts(pos), map.calcSwapCosts(pos), map.calcReplaceCosts(pos)];
+        costCalculations.forEach((iter) => {
+            for (const nn of iter) {
+                candidates.add({ ...nn, f: n });
+            }
+        });
+    }
+    let best;
+    // const bc2 = 2 * bc;
+    while ((best = candidates.dequeue())) {
+        if (best.ai === aN && best.bi === bN)
+            break;
+        opSwap(best);
+        opIns(best);
+        opDel(best);
+        opMap(best);
+        opSub(best);
+    }
+    return best;
+}
+function compare(a, b) {
+    // Choose lowest cost or farthest Manhattan distance.
+    return a.c - b.c || b.ai + b.bi - a.ai - a.bi;
+}
+//# sourceMappingURL=distanceAStarWeighted.js.map

package/dist/lib/distance/index.d.ts

@@ -0,0 +1,3 @@
+export { createWeightedMap, editDistance, editDistanceWeighted } from './distance';
+export type { WeightMap } from './distance';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/distance/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editDistanceWeighted = exports.editDistance = exports.createWeightedMap = void 0;
+var distance_1 = require("./distance");
+Object.defineProperty(exports, "createWeightedMap", { enumerable: true, get: function () { return distance_1.createWeightedMap; } });
+Object.defineProperty(exports, "editDistance", { enumerable: true, get: function () { return distance_1.editDistance; } });
+Object.defineProperty(exports, "editDistanceWeighted", { enumerable: true, get: function () { return distance_1.editDistanceWeighted; } });
+//# sourceMappingURL=index.js.map

package/dist/lib/distance/levenshtein.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Damerau–Levenshtein distance
+ * [Damerau–Levenshtein distance - Wikipedia](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance)
+ * @param a - first word
+ * @param b - second word
+ * @returns Distance value
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+//# sourceMappingURL=levenshtein.d.ts.map

package/dist/lib/distance/levenshtein.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshteinDistance = void 0;
+/**
+ * Damerau–Levenshtein distance
+ * [Damerau–Levenshtein distance - Wikipedia](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance)
+ * @param a - first word
+ * @param b - second word
+ * @returns Distance value
+ */
+function levenshteinDistance(a, b) {
+    // By prefixing with spaces, no out of bounds checks are necessary.
+    const aa = '  ' + a;
+    const bb = '  ' + b;
+    const nA = a.length + 1;
+    const nB = b.length + 1;
+    const firstRow = [];
+    for (let i = 0; i <= nA; ++i) {
+        firstRow[i] = i;
+    }
+    const matrix = [firstRow, [1].concat(firstRow), [2, 1].concat(firstRow)];
+    let ppRow = matrix[0];
+    let pRow = matrix[1];
+    for (let j = 2; j <= nB; ++j) {
+        const row = matrix[j % 3];
+        row[0] = pRow[0] + 1;
+        row[1] = pRow[1] + 1;
+        const bp = bb[j - 1];
+        const bc = bb[j];
+        let ap = aa[0];
+        for (let i = 2, i1 = 1; i <= nA; i1 = i, ++i) {
+            const ac = aa[i];
+            const c = pRow[i1] + (ac == bc ? 0 : 1);
+            const ct = ac == bp && ap == bc ? ppRow[i1 - 1] + 1 : c;
+            row[i] = Math.min(c, // substitute
+            ct, // transpose
+            pRow[i] + 1, // insert
+            row[i1] + 1 // delete
+            );
+            ap = ac;
+        }
+        ppRow = pRow;
+        pRow = row;
+    }
+    return pRow[nA];
+}
+exports.levenshteinDistance = levenshteinDistance;
+//# sourceMappingURL=levenshtein.js.map

package/dist/lib/distance/weightedMaps.d.ts

@@ -0,0 +1,83 @@
+import { SuggestionCostMapDef } from '../models/suggestionCostsDef';
+export declare type WeightedRepMapTrie = Record<string, WeightedRepTrieNode>;
+interface WeightedRepTrieNode {
+    /** The nested Trie nodes */
+    r?: WeightedRepMapTrie | undefined;
+    /** The cost to replace */
+    rep?: number | undefined;
+    /** The cost to swap */
+    swap?: number | undefined;
+}
+/**
+ * Costs are minimized while penalties are maximized.
+ */
+interface Cost {
+    /**
+     * The cost of an operation
+     * `c'' = min(c, c')`
+     */
+    c?: number | undefined;
+    /**
+     * The penalties applied
+     * `p'' = max(p, p')`
+     */
+    p?: number | undefined;
+}
+interface TrieCost extends Cost {
+    /** nested trie nodes */
+    n?: Record<string, TrieCost>;
+}
+interface TrieTrieCost {
+    /** nested trie nodes */
+    n?: Record<string, TrieTrieCost>;
+    /** root of cost trie */
+    t?: Record<string, TrieCost>;
+}
+export interface CostPosition {
+    a: string;
+    ai: number;
+    b: string;
+    bi: number;
+    c: number;
+    p: number;
+}
+export interface WeightMap {
+    readonly insDel: TrieCost;
+    readonly replace: TrieTrieCost;
+    readonly swap: TrieTrieCost;
+    calcInsDelCosts(pos: CostPosition): Iterable<CostPosition>;
+    calcSwapCosts(pos: CostPosition): Iterable<CostPosition>;
+    calcReplaceCosts(pos: CostPosition): Iterable<CostPosition>;
+}
+export declare function createWeightMap(...defs: SuggestionCostMapDef[]): WeightMap;
+export declare function addDefToWeightMap(map: WeightMap, def: SuggestionCostMapDef, ...defs: SuggestionCostMapDef[]): WeightMap;
+export declare function splitMapSubstringsIterable(map: string): Iterable<string>;
+export declare function splitMapSubstrings(map: string): string[];
+/**
+ * Splits a WeightedMapDef.map
+ * @param map
+ */
+declare function splitMap(def: Pick<SuggestionCostMapDef, 'map'>): string[][];
+interface MatchTrieCost {
+    i: number;
+    c: number;
+    p: number;
+}
+declare function findTrieCostPrefixes(trie: TrieCost, str: string, i: number): Iterable<MatchTrieCost>;
+interface MatchTrieTrieCost {
+    i: number;
+    t: TrieCost;
+}
+declare function findTrieTrieCostPrefixes(trie: TrieTrieCost, str: string, i: number): Iterable<MatchTrieTrieCost>;
+export declare function prettyPrintReplace(trie: TrieTrieCost, pfx?: string, indent?: string): string;
+export declare function prettyPrintSwap(trie: TrieTrieCost, pfx?: string, indent?: string): string;
+export declare function prettyPrintWeightMap(map: WeightMap): string;
+export declare function lookupReplaceCost(map: WeightMap, a: string, b: string): undefined | number;
+export declare const __testing__: {
+    splitMap: typeof splitMap;
+    splitMapSubstrings: typeof splitMapSubstrings;
+    findTrieCostPrefixes: typeof findTrieCostPrefixes;
+    findTrieTrieCostPrefixes: typeof findTrieTrieCostPrefixes;
+};
+export {};
+//# sourceMappingURL=weightedMaps.d.ts.map