cspell-trie-lib 5.18.0-alpha.0 → 5.18.3

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

@@ -74,11 +74,13 @@ export declare function prettyPrintReplace(trie: TrieTrieCost, pfx?: string, ind
 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;
+declare function normalizeDef(def: SuggestionCostMapDef): SuggestionCostMapDef;
 export declare const __testing__: {
-    splitMap: typeof splitMap;
-    splitMapSubstrings: typeof splitMapSubstrings;
     findTrieCostPrefixes: typeof findTrieCostPrefixes;
     findTrieTrieCostPrefixes: typeof findTrieTrieCostPrefixes;
+    normalizeDef: typeof normalizeDef;
+    splitMap: typeof splitMap;
+    splitMapSubstrings: typeof splitMapSubstrings;
 };
 export {};
 //# sourceMappingURL=weightedMaps.d.ts.map

package/dist/lib/distance/weightedMaps.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.lookupReplaceCost = exports.prettyPrintWeightMap = exports.prettyPrintSwap = exports.prettyPrintReplace = exports.splitMapSubstrings = exports.splitMapSubstringsIterable = exports.addDefsToWeightMap = exports.addDefToWeightMap = exports.createWeightMap = void 0;
+const suggestCollector_1 = require("../suggestions/suggestCollector");
+const matchPossibleWordSeparators = /[+∙•・●]/g;
 function createWeightMap(...defs) {
     const map = _createWeightMap();
     addDefsToWeightMap(map, defs);
@@ -17,7 +19,8 @@ function addDefsToWeightMap(map, defs) {
         addSetToTrieTrieCost(map.replace, set, def.replace, def.penalty);
         addSetToTrieTrieCost(map.swap, set, def.swap, def.penalty);
     }
-    for (const def of defs) {
+    for (const _def of defs) {
+        const def = normalizeDef(_def);
         const mapSets = splitMap(def);
         mapSets.forEach((s) => addSet(s, def));
     }
@@ -262,10 +265,18 @@ function lookupReplaceCost(map, a, b) {
     return t === null || t === void 0 ? void 0 : t.c;
 }
 exports.lookupReplaceCost = lookupReplaceCost;
+function normalizeDef(def) {
+    const { map, ...rest } = def;
+    return { ...rest, map: normalizeMap(map) };
+}
+function normalizeMap(map) {
+    return map.replace(matchPossibleWordSeparators, suggestCollector_1.DEFAULT_COMPOUNDED_WORD_SEPARATOR);
+}
 exports.__testing__ = {
-    splitMap,
-    splitMapSubstrings,
     findTrieCostPrefixes,
     findTrieTrieCostPrefixes,
+    normalizeDef,
+    splitMap,
+    splitMapSubstrings,
 };
 //# sourceMappingURL=weightedMaps.js.map

package/dist/lib/find.d.ts

@@ -1,5 +1,6 @@
-import { TrieNode } from './TrieNode';
+import { TrieNode, TrieRoot } from './TrieNode';
 import type { PartialWithUndefined } from './types';
+declare type Root = PartialWithUndefined<TrieRoot>;
 /**
  * No compounding allowed.
  */
@@ -48,20 +49,20 @@ export interface FindFullNodeResult extends FindNodeResult, FindFullResult {
  * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
  * @param options
  */
-export declare function findWord(root: TrieNode, word: string, options?: PartialFindOptions): FindFullResult;
+export declare function findWord(root: Root, word: string, options?: PartialFindOptions): FindFullResult;
 /**
  *
  * @param root Trie root node. root.c contains the compound root and forbidden root.
  * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
  * @param options
  */
-export declare function findWordNode(root: TrieNode, word: string, options?: PartialFindOptions): FindFullNodeResult;
-export declare function findLegacyCompound(root: TrieNode, word: string, options: FindOptions): FindFullNodeResult;
-export declare function findCompoundNode(root: TrieNode | undefined, word: string, compoundCharacter: string, ignoreCasePrefix: string): FindFullNodeResult;
-export declare function findWordExact(root: TrieNode | undefined, word: string): boolean;
+export declare function findWordNode(root: Root, word: string, options?: PartialFindOptions): FindFullNodeResult;
+export declare function findLegacyCompound(root: Root, word: string, options: FindOptions): FindFullNodeResult;
+export declare function findCompoundNode(root: Root | undefined, word: string, compoundCharacter: string, ignoreCasePrefix: string): FindFullNodeResult;
+export declare function findWordExact(root: Root | TrieNode | undefined, word: string): boolean;
 export declare function isEndOfWordNode(n: TrieNode | undefined): boolean;
 declare function findLegacyCompoundWord(roots: (TrieNode | undefined)[], word: string, minCompoundLength: number): FindResult;
-export declare function isForbiddenWord(root: TrieNode | undefined, word: string, forbiddenPrefix: string): boolean;
+export declare function isForbiddenWord(root: Root | TrieNode | undefined, word: string, forbiddenPrefix: string): boolean;
 export declare function createFindOptions(options: PartialFindOptions | undefined): FindOptions;
 export declare const __testing__: {
     findLegacyCompoundWord: typeof findLegacyCompoundWord;

package/dist/lib/find.js

@@ -42,8 +42,8 @@ exports.findWordNode = findWordNode;
  * @param options
  */
 function _findWord(root, word, options) {
-    const { found, forbidden, compoundUsed, caseMatched } = _findWordNode(root, word, options);
-    return { found, forbidden, compoundUsed, caseMatched };
+    const { node: _, ...result } = _findWordNode(root, word, options);
+    return result;
 }
 /**
  *
@@ -52,9 +52,10 @@ function _findWord(root, word, options) {
  * @param options
  */
 function _findWordNode(root, word, options) {
+    var _a, _b;
     const compoundMode = knownCompoundModes.get(options.compoundMode) || _defaultFindOptions.compoundMode;
-    const compoundPrefix = options.compoundMode === 'compound' ? options.compoundFix : '';
-    const ignoreCasePrefix = options.matchCase ? '' : options.caseInsensitivePrefix;
+    const compoundPrefix = options.compoundMode === 'compound' ? (_a = root.compoundCharacter) !== null && _a !== void 0 ? _a : options.compoundFix : '';
+    const ignoreCasePrefix = options.matchCase ? '' : (_b = root.stripCaseAndAccentsPrefix) !== null && _b !== void 0 ? _b : options.caseInsensitivePrefix;
     function __findCompound() {
         const f = findCompoundWord(root, word, compoundPrefix, ignoreCasePrefix);
         const result = { ...f };
@@ -99,6 +100,7 @@ function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
     var _a, _b, _c;
     // Approach - do a depth first search for the matching word.
     const stack = [
+        // { n: root, compoundPrefix: '', cr: undefined, caseMatched: true },
         { n: root, compoundPrefix: ignoreCasePrefix, cr: undefined, caseMatched: true },
     ];
     const compoundPrefix = compoundCharacter || ignoreCasePrefix;

package/dist/lib/index.d.ts

@@ -6,7 +6,8 @@ export { ExportOptions, importTrie, serializeTrie } from './io/importExport';
 export { mapDictionaryInformationToWeightMap } from './mappers/mapDictionaryInfoToWeightMap';
 export type { SuggestionCostMapDef } from './models/suggestionCostsDef';
 export { parseDictionary, parseDictionaryLines } from './SimpleDictionaryParser';
-export { MaxCost, suggestionCollector, SuggestionCollector, SuggestionResult } from './suggestCollector';
+export { impersonateCollector, suggestionCollector } from './suggestCollector';
+export type { MaxCost, SuggestionCollector, SuggestionResult } from './suggestCollector';
 export { CASE_INSENSITIVE_PREFIX, COMPOUND, COMPOUND_FIX, defaultTrieOptions, FORBID, FORBID_PREFIX, NORMALIZED, OPTIONAL_COMPOUND, OPTIONAL_COMPOUND_FIX, Trie, } from './trie';
 export type { FindWordOptions, PartialTrieOptions, TrieOptions } from './trie';
 export { countNodes, countWords, createTrieRoot, createTriFromList, findNode, has, insert, isCircular, isDefined, isWordTerminationNode, iterateTrie, iteratorTrieWords, mergeDefaults, mergeOptionalWithDefaults, normalizeWord, normalizeWordForCaseInsensitive, normalizeWordToLowercase, orderTrie, trieNodeToRoot, walk, } from './trie-util';

package/dist/lib/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORD_SEPARATOR = exports.walker = exports.JOIN_SEPARATOR = exports.hintedWalker = exports.CompoundWordsMethod = exports.FLAG_WORD = exports.ChildMap = exports.TrieBuilder = exports.buildTrieFast = exports.buildTrie = exports.walk = exports.trieNodeToRoot = exports.orderTrie = exports.normalizeWordToLowercase = exports.normalizeWordForCaseInsensitive = exports.normalizeWord = exports.mergeOptionalWithDefaults = exports.mergeDefaults = exports.iteratorTrieWords = exports.iterateTrie = exports.isWordTerminationNode = exports.isDefined = exports.isCircular = exports.insert = exports.has = exports.findNode = exports.createTriFromList = exports.createTrieRoot = exports.countWords = exports.countNodes = exports.Trie = exports.OPTIONAL_COMPOUND_FIX = exports.OPTIONAL_COMPOUND = exports.NORMALIZED = exports.FORBID_PREFIX = exports.FORBID = exports.defaultTrieOptions = exports.COMPOUND_FIX = exports.COMPOUND = exports.CASE_INSENSITIVE_PREFIX = exports.suggestionCollector = exports.parseDictionaryLines = exports.parseDictionary = exports.mapDictionaryInformationToWeightMap = exports.serializeTrie = exports.importTrie = exports.editDistanceWeighted = exports.editDistance = exports.createWeightedMap = exports.consolidate = void 0;
+exports.walker = exports.JOIN_SEPARATOR = exports.hintedWalker = exports.CompoundWordsMethod = exports.FLAG_WORD = exports.ChildMap = exports.TrieBuilder = exports.buildTrieFast = exports.buildTrie = exports.walk = exports.trieNodeToRoot = exports.orderTrie = exports.normalizeWordToLowercase = exports.normalizeWordForCaseInsensitive = exports.normalizeWord = exports.mergeOptionalWithDefaults = exports.mergeDefaults = exports.iteratorTrieWords = exports.iterateTrie = exports.isWordTerminationNode = exports.isDefined = exports.isCircular = exports.insert = exports.has = exports.findNode = exports.createTriFromList = exports.createTrieRoot = exports.countWords = exports.countNodes = exports.Trie = exports.OPTIONAL_COMPOUND_FIX = exports.OPTIONAL_COMPOUND = exports.NORMALIZED = exports.FORBID_PREFIX = exports.FORBID = exports.defaultTrieOptions = exports.COMPOUND_FIX = exports.COMPOUND = exports.CASE_INSENSITIVE_PREFIX = exports.suggestionCollector = exports.impersonateCollector = exports.parseDictionaryLines = exports.parseDictionary = exports.mapDictionaryInformationToWeightMap = exports.serializeTrie = exports.importTrie = exports.editDistanceWeighted = exports.editDistance = exports.createWeightedMap = exports.consolidate = void 0;
+exports.WORD_SEPARATOR = void 0;
 var consolidate_1 = require("./consolidate");
 Object.defineProperty(exports, "consolidate", { enumerable: true, get: function () { return consolidate_1.consolidate; } });
 var distance_1 = require("./distance");
@@ -16,6 +17,7 @@ var SimpleDictionaryParser_1 = require("./SimpleDictionaryParser");
 Object.defineProperty(exports, "parseDictionary", { enumerable: true, get: function () { return SimpleDictionaryParser_1.parseDictionary; } });
 Object.defineProperty(exports, "parseDictionaryLines", { enumerable: true, get: function () { return SimpleDictionaryParser_1.parseDictionaryLines; } });
 var suggestCollector_1 = require("./suggestCollector");
+Object.defineProperty(exports, "impersonateCollector", { enumerable: true, get: function () { return suggestCollector_1.impersonateCollector; } });
 Object.defineProperty(exports, "suggestionCollector", { enumerable: true, get: function () { return suggestCollector_1.suggestionCollector; } });
 var trie_1 = require("./trie");
 Object.defineProperty(exports, "CASE_INSENSITIVE_PREFIX", { enumerable: true, get: function () { return trie_1.CASE_INSENSITIVE_PREFIX; } });

package/dist/lib/mappers/mapToSuggestionCostDef.js

@@ -51,14 +51,14 @@ function calcFirstCharacterReplace(cs, editCost) {
         ...(0, cspell_pipe_1.pipeSync)((0, text_1.expandCharacterSet)(cs.characters), (0, cspell_pipe_1.opUnique)(), (0, cspell_pipe_1.opMap)((letter) => `(^${letter})`)),
     ]
         .sort()
-        .join('');
+        .join('') + '(^)';
     const penalty = editCost.firstLetterPenalty;
     // Make it a bit cheaper so it will match
     const cost = cs.cost - penalty;
     return {
         map: mapOfFirstLetters,
         replace: cost,
-        penalty,
+        penalty: penalty * 2,
     };
 }
 exports.calcFirstCharacterReplace = calcFirstCharacterReplace;

package/dist/lib/suggestCollector.d.ts

@@ -1,6 +1,6 @@
 /**
  * This file is here to support code the referenced suggest directly and limit the exports.
  */
-export { compSuggestionResults, defaultSuggestionCollectorOptions, isSuggestionResult, suggestionCollector, } from './suggestions/suggestCollector';
+export { compSuggestionResults, defaultSuggestionCollectorOptions, impersonateCollector, isSuggestionResult, suggestionCollector, } from './suggestions/suggestCollector';
 export type { Cost, FilterWordFn, GenerateNextParam, GenerateSuggestionResult, MaxCost, Progress, SuggestionCollector, SuggestionCollectorOptions, SuggestionGenerator, SuggestionResult, } from './suggestions/suggestCollector';
 //# sourceMappingURL=suggestCollector.d.ts.map

package/dist/lib/suggestCollector.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.suggestionCollector = exports.isSuggestionResult = exports.defaultSuggestionCollectorOptions = exports.compSuggestionResults = void 0;
+exports.suggestionCollector = exports.isSuggestionResult = exports.impersonateCollector = exports.defaultSuggestionCollectorOptions = exports.compSuggestionResults = void 0;
 /**
  * This file is here to support code the referenced suggest directly and limit the exports.
  */
 var suggestCollector_1 = require("./suggestions/suggestCollector");
 Object.defineProperty(exports, "compSuggestionResults", { enumerable: true, get: function () { return suggestCollector_1.compSuggestionResults; } });
 Object.defineProperty(exports, "defaultSuggestionCollectorOptions", { enumerable: true, get: function () { return suggestCollector_1.defaultSuggestionCollectorOptions; } });
+Object.defineProperty(exports, "impersonateCollector", { enumerable: true, get: function () { return suggestCollector_1.impersonateCollector; } });
 Object.defineProperty(exports, "isSuggestionResult", { enumerable: true, get: function () { return suggestCollector_1.isSuggestionResult; } });
 Object.defineProperty(exports, "suggestionCollector", { enumerable: true, get: function () { return suggestCollector_1.suggestionCollector; } });
 //# sourceMappingURL=suggestCollector.js.map

package/dist/lib/{genSuggestionsOptions.d.ts → suggestions/genSuggestionsOptions.d.ts}

@@ -1,4 +1,4 @@
-import { WeightMap } from '.';
+import { WeightMap } from '..';
 import { CompoundWordsMethod } from './walker';
 export interface GenSuggestionOptionsStrict {
     /**
@@ -15,6 +15,11 @@ export interface GenSuggestionOptionsStrict {
      * 3 is a good number. Above 5 can be very slow.
      */
     changeLimit: number;
+    /**
+     * Inserts a compound character between compounded word segments.
+     * @default ""
+     */
+    compoundSeparator?: string;
 }
 export declare type GenSuggestionOptions = Partial<GenSuggestionOptionsStrict>;
 export interface SuggestionOptionsStrict extends GenSuggestionOptionsStrict {

package/dist/lib/{genSuggestionsOptions.js → suggestions/genSuggestionsOptions.js}

@@ -17,6 +17,7 @@ const keyMapOfGenSuggestionOptionsStrict = {
     changeLimit: 'changeLimit',
     compoundMethod: 'compoundMethod',
     ignoreCase: 'ignoreCase',
+    compoundSeparator: 'compoundSeparator',
 };
 const keyMapOfSuggestionOptionsStrict = {
     ...keyMapOfGenSuggestionOptionsStrict,

package/dist/lib/suggestions/suggest.d.ts

@@ -1,6 +1,6 @@
-import { GenSuggestionOptions, SuggestionOptions } from '../genSuggestionsOptions';
-import { SuggestionGenerator, SuggestionResult } from './suggestCollector';
 import { TrieRoot } from '../TrieNode';
+import { GenSuggestionOptions, SuggestionOptions } from './genSuggestionsOptions';
+import { SuggestionGenerator, SuggestionResult } from './suggestCollector';
 export declare function suggest(root: TrieRoot | TrieRoot[], word: string, options?: SuggestionOptions): SuggestionResult[];
 export declare function genSuggestions(root: TrieRoot | TrieRoot[], word: string, options?: GenSuggestionOptions): SuggestionGenerator;
 export declare function genCompoundableSuggestions(root: TrieRoot, word: string, options?: GenSuggestionOptions): SuggestionGenerator;

package/dist/lib/suggestions/suggest.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.genCompoundableSuggestions = exports.genSuggestions = exports.suggest = void 0;
-const genSuggestionsOptions_1 = require("../genSuggestionsOptions");
+const trie_util_1 = require("../trie-util");
+const genSuggestionsOptions_1 = require("./genSuggestionsOptions");
 const orthography_1 = require("./orthography");
 const suggestCollector_1 = require("./suggestCollector");
-const trie_util_1 = require("../trie-util");
-const walker_1 = require("../walker");
+const walker_1 = require("./walker");
 const baseCost = 100;
 const swapCost = 75;
 const postSwapCost = swapCost - baseCost;
@@ -18,7 +18,7 @@ function suggest(root, word, options = {}) {
     const opts = (0, genSuggestionsOptions_1.createSuggestionOptions)(options);
     const collectorOpts = (0, trie_util_1.clean)(opts);
     const collector = (0, suggestCollector_1.suggestionCollector)(word, collectorOpts);
-    collector.collect(genSuggestions(root, word, opts));
+    collector.collect(genSuggestions(root, word, { ...opts, ...collector.genSuggestionOptions }));
     return collector.suggestions;
 }
 exports.suggest = suggest;
@@ -68,7 +68,7 @@ function* genCompoundableSuggestions(root, word, options = {}) {
     }
     stack[0] = { a, b };
     const hint = word;
-    const iWalk = (0, walker_1.hintedWalker)(root, ignoreCase, hint, compoundMethod);
+    const iWalk = (0, walker_1.hintedWalker)(root, ignoreCase, hint, compoundMethod, options.compoundSeparator);
     let goDeeper = true;
     for (let r = iWalk.next({ goDeeper }); !stopNow && !r.done; r = iWalk.next({ goDeeper })) {
         const { text, node, depth } = r.value;

package/dist/lib/suggestions/suggestAStar.d.ts

@@ -1,6 +1,6 @@
 import { TrieRoot } from '../TrieNode';
 import { SuggestionGenerator, SuggestionResult } from './suggestCollector';
-import { GenSuggestionOptionsStrict, SuggestionOptions } from '../genSuggestionsOptions';
+import { GenSuggestionOptionsStrict, SuggestionOptions } from './genSuggestionsOptions';
 export declare function genCompoundableSuggestions(root: TrieRoot, word: string, options: GenSuggestionOptionsStrict): SuggestionGenerator;
 export declare function suggest(root: TrieRoot | TrieRoot[], word: string, options: SuggestionOptions): SuggestionResult[];
 export declare function genSuggestions(root: TrieRoot | TrieRoot[], word: string, options: GenSuggestionOptionsStrict): SuggestionGenerator;

package/dist/lib/suggestions/suggestAStar.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.genSuggestions = exports.suggest = exports.genCompoundableSuggestions = void 0;
-const walker_1 = require("../walker");
+const walker_1 = require("./walker");
 const suggestCollector_1 = require("./suggestCollector");
 const PairingHeap_1 = require("../utils/PairingHeap");
 const orthography_1 = require("./orthography");
-const genSuggestionsOptions_1 = require("../genSuggestionsOptions");
+const genSuggestionsOptions_1 = require("./genSuggestionsOptions");
 function* genCompoundableSuggestions(root, word, options) {
     const { compoundMethod, ignoreCase, changeLimit } = options;
     const len = word.length;

package/dist/lib/suggestions/suggestCollector.d.ts

@@ -1,10 +1,19 @@
 import { WeightMap } from '..';
+import { RequireOptional } from '../types';
+import { GenSuggestionOptions, GenSuggestionOptionsStrict } from './genSuggestionsOptions';
+export declare const DEFAULT_COMPOUNDED_WORD_SEPARATOR = "\u2219";
 export declare type Cost = number;
 export declare type MaxCost = Cost;
-export interface SuggestionResult {
+export interface SuggestionResultBase {
+    /** The suggested word */
     word: string;
+    /** The edit cost 100 = 1 edit */
     cost: Cost;
 }
+export interface SuggestionResult extends SuggestionResultBase {
+    /** The suggested word with compound marks, generally a `•` */
+    compoundWord?: string | undefined;
+}
 export interface Progress {
     type: 'progress';
     /** Number of Completed Tasks so far */
@@ -16,7 +25,7 @@ export interface Progress {
     remaining: number;
 }
 export declare type GenerateNextParam = MaxCost | symbol | undefined;
-export declare type GenerateSuggestionResult = SuggestionResult | Progress | undefined;
+export declare type GenerateSuggestionResult = SuggestionResultBase | Progress | undefined;
 /**
  * Ask for the next result.
  * maxCost - sets the max cost for following suggestions
@@ -26,7 +35,7 @@ export declare type GenerateSuggestionResult = SuggestionResult | Progress | und
  * The SuggestionIterator is generally the
  */
 export declare type SuggestionGenerator = Generator<GenerateSuggestionResult, void, GenerateNextParam>;
-export declare function compSuggestionResults(a: SuggestionResult, b: SuggestionResult): number;
+export declare function compSuggestionResults(a: SuggestionResultBase, b: SuggestionResultBase): number;
 export declare type FilterWordFn = (word: string, cost: number) => boolean;
 export interface SuggestionCollector {
     /**
@@ -40,7 +49,7 @@ export interface SuggestionCollector {
      * if (r === collector.symbolStopProcessing) // ...stop generating suggestions.
      */
     collect: (src: SuggestionGenerator, timeout?: number, filter?: FilterWordFn) => void;
-    add: (suggestion: SuggestionResult) => SuggestionCollector;
+    add: (suggestion: SuggestionResultBase) => SuggestionCollector;
     readonly suggestions: SuggestionResult[];
     readonly changeLimit: number;
     readonly maxCost: number;
@@ -48,12 +57,13 @@ export interface SuggestionCollector {
     readonly maxNumSuggestions: number;
     readonly includesTies: boolean;
     readonly ignoreCase: boolean;
+    readonly genSuggestionOptions: GenSuggestionOptions;
     /**
      * Possible value sent to the SuggestionIterator telling it to stop processing.
      */
     readonly symbolStopProcessing: symbol;
 }
-export interface SuggestionCollectorOptions {
+export interface SuggestionCollectorOptions extends Omit<GenSuggestionOptionsStrict, 'ignoreCase' | 'changeLimit'> {
     /**
      * number of best matching suggestions.
      * @default 10
@@ -90,7 +100,15 @@ export interface SuggestionCollectorOptions {
      */
     weightMap?: WeightMap | undefined;
 }
-export declare const defaultSuggestionCollectorOptions: SuggestionCollectorOptions;
+export declare const defaultSuggestionCollectorOptions: RequireOptional<SuggestionCollectorOptions>;
 export declare function suggestionCollector(wordToMatch: string, options: SuggestionCollectorOptions): SuggestionCollector;
+/**
+ * Impersonating a Collector, allows searching for multiple variants on the same word.
+ * The collection is still in the original collector.
+ * @param collector - collector to impersonate
+ * @param word - word to present instead of `collector.word`.
+ * @returns a SuggestionCollector
+ */
+export declare function impersonateCollector(collector: SuggestionCollector, word: string): SuggestionCollector;
 export declare function isSuggestionResult(s: GenerateSuggestionResult): s is SuggestionResult;
 //# sourceMappingURL=suggestCollector.d.ts.map

package/dist/lib/suggestions/suggestCollector.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSuggestionResult = exports.suggestionCollector = exports.defaultSuggestionCollectorOptions = exports.compSuggestionResults = void 0;
+exports.isSuggestionResult = exports.impersonateCollector = exports.suggestionCollector = exports.defaultSuggestionCollectorOptions = exports.compSuggestionResults = exports.DEFAULT_COMPOUNDED_WORD_SEPARATOR = void 0;
 const __1 = require("..");
+const weightedMaps_1 = require("../distance/weightedMaps");
 const timer_1 = require("../utils/timer");
-const walker_1 = require("../walker");
+const util_1 = require("../utils/util");
+const walker_1 = require("./walker");
 const defaultMaxNumberSuggestions = 10;
 const BASE_COST = 100;
 const MAX_NUM_CHANGES = 5;
@@ -11,9 +13,12 @@ const MAX_COST_SCALE = 0.5;
 // max allowed cost scale should be a bit over 50% to allow for suggestions to short words, but not too high to have too many suggestions.
 const MAX_ALLOWED_COST_SCALE = 1.03 * MAX_COST_SCALE;
 const collator = new Intl.Collator();
-const regexSeparator = new RegExp(`[${regexQuote(walker_1.JOIN_SEPARATOR + walker_1.WORD_SEPARATOR)}]`, 'g');
+// This is a bit broken, it was supposed to also include JOIN_SEPARATOR (`+`)
+// Add it back later.
+const regexSeparator = new RegExp(`[${(0, util_1.regexQuote)(walker_1.WORD_SEPARATOR)}]`, 'g');
 const wordLengthCost = [0, 50, 25, 5, 0];
 const EXTRA_WORD_COST = 5;
+exports.DEFAULT_COMPOUNDED_WORD_SEPARATOR = '∙';
 /** time in ms */
 const DEFAULT_COLLECTOR_TIMEOUT = 1000;
 const symStopProcessing = Symbol('Collector Stop Processing');
@@ -29,12 +34,28 @@ exports.defaultSuggestionCollectorOptions = Object.freeze({
     includeTies: false,
     ignoreCase: true,
     timeout: DEFAULT_COLLECTOR_TIMEOUT,
+    weightMap: undefined,
+    compoundSeparator: '',
+    compoundMethod: undefined,
 });
 function suggestionCollector(wordToMatch, options) {
-    const { filter = () => true, changeLimit = MAX_NUM_CHANGES, includeTies = false, ignoreCase = true, timeout = DEFAULT_COLLECTOR_TIMEOUT, weightMap, } = options;
+    const { filter = () => true, changeLimit = MAX_NUM_CHANGES, includeTies = false, ignoreCase = true, timeout = DEFAULT_COLLECTOR_TIMEOUT, weightMap, compoundSeparator = exports.defaultSuggestionCollectorOptions.compoundSeparator, } = options;
     const numSuggestions = Math.max(options.numSuggestions, 0) || 0;
+    const numSugToHold = weightMap ? numSuggestions * 2 : numSuggestions;
     const sugs = new Map();
     let maxCost = BASE_COST * Math.min(wordToMatch.length * MAX_ALLOWED_COST_SCALE, changeLimit);
+    const useSeparator = compoundSeparator ||
+        (weightMap ? exports.DEFAULT_COMPOUNDED_WORD_SEPARATOR : exports.defaultSuggestionCollectorOptions.compoundSeparator);
+    const fnCleanWord = !useSeparator || useSeparator === compoundSeparator ? (w) => w : (0, util_1.replaceAllFactory)(useSeparator, '');
+    if (useSeparator && weightMap) {
+        (0, weightedMaps_1.addDefToWeightMap)(weightMap, { map: useSeparator, insDel: 50 });
+    }
+    const genSuggestionOptions = (0, util_1.clean)({
+        changeLimit,
+        ignoreCase,
+        compoundMethod: options.compoundMethod,
+        compoundSeparator: useSeparator,
+    });
     let timeRemaining = timeout;
     function dropMax() {
         if (sugs.size < 2 || !numSuggestions) {
@@ -42,7 +63,7 @@ function suggestionCollector(wordToMatch, options) {
             return;
         }
         const sorted = [...sugs.values()].sort(compSuggestionResults);
-        let i = numSuggestions - 1;
+        let i = numSugToHold - 1;
         maxCost = sorted[i].cost;
         for (; i < sorted.length && sorted[i].cost <= maxCost; ++i) {
             /* empty */
@@ -57,9 +78,6 @@ function suggestionCollector(wordToMatch, options) {
             (words.length - 1) * EXTRA_WORD_COST;
         return { word: sug.word, cost: sug.cost + extraCost };
     }
-    function handleProgress(_progress) {
-        // Do nothing.
-    }
     function collectSuggestion(suggestion) {
         const { word, cost } = adjustCost(suggestion);
         if (cost <= maxCost && filter(suggestion.word, cost)) {
@@ -69,7 +87,7 @@ function suggestionCollector(wordToMatch, options) {
             }
             else {
                 sugs.set(word, { word, cost });
-                if (cost < maxCost && sugs.size > numSuggestions) {
+                if (cost < maxCost && sugs.size > numSugToHold) {
                     dropMax();
                 }
             }
@@ -102,11 +120,24 @@ function suggestionCollector(wordToMatch, options) {
                 }
                 continue;
             }
-            handleProgress(value);
         }
         timeRemaining -= timer.elapsed();
     }
+    function cleanCompoundResult(sr) {
+        const { word, cost } = sr;
+        const cWord = fnCleanWord(word);
+        if (cWord !== word) {
+            return {
+                word: cWord,
+                cost,
+                compoundWord: word,
+            };
+        }
+        return { ...sr };
+    }
     function suggestions() {
+        if (numSuggestions < 1 || !sugs.size)
+            return [];
         const NF = 'NFD';
         const nWordToMatch = wordToMatch.normalize(NF);
         const rawValues = [...sugs.values()];
@@ -116,10 +147,14 @@ function suggestionCollector(wordToMatch, options) {
                 cost: (0, __1.editDistanceWeighted)(nWordToMatch, word.normalize(NF), weightMap, 110),
             }))
             : rawValues;
-        const sorted = values.sort(compSuggestionResults);
-        if (!includeTies && sorted.length > numSuggestions) {
-            sorted.length = numSuggestions;
+        const sorted = values.sort(compSuggestionResults).map(cleanCompoundResult);
+        let i = Math.min(sorted.length, numSuggestions) - 1;
+        const limit = includeTies ? sorted.length : Math.min(sorted.length, numSuggestions);
+        const maxCost = sorted[i].cost;
+        for (++i; i < limit && sorted[i].cost === maxCost; ++i) {
+            // loop
         }
+        sorted.length = i;
         return sorted;
     }
     const collector = {
@@ -146,21 +181,27 @@ function suggestionCollector(wordToMatch, options) {
         includesTies: includeTies,
         ignoreCase,
         symbolStopProcessing: symStopProcessing,
+        genSuggestionOptions,
     };
     return collector;
 }
 exports.suggestionCollector = suggestionCollector;
+/**
+ * Impersonating a Collector, allows searching for multiple variants on the same word.
+ * The collection is still in the original collector.
+ * @param collector - collector to impersonate
+ * @param word - word to present instead of `collector.word`.
+ * @returns a SuggestionCollector
+ */
+function impersonateCollector(collector, word) {
+    const r = Object.create(collector);
+    Object.defineProperty(r, 'word', { value: word, writable: false });
+    return r;
+}
+exports.impersonateCollector = impersonateCollector;
 function isSuggestionResult(s) {
     const r = s;
     return (r === null || r === void 0 ? void 0 : r.cost) !== undefined && r.word != undefined;
 }
 exports.isSuggestionResult = isSuggestionResult;
-/**
- *
- * @param text verbatim text to be inserted into a regexp
- * @returns text that can be used in a regexp.
- */
-function regexQuote(text) {
-    return text.replace(/[[\]\-+(){},|*.\\]/g, '\\$1');
-}
 //# sourceMappingURL=suggestCollector.js.map

package/dist/lib/suggestions/walker/hintedWalker.d.ts

@@ -0,0 +1,22 @@
+import { TrieRoot } from '../../TrieNode';
+import { CompoundWordsMethod, YieldResult } from './walkerTypes';
+/**
+ * Ask for the next result.
+ * goDeeper of true tells the walker to go deeper in the Trie if possible. Default is true.
+ * This can be used to limit the walker's depth.
+ */
+export declare type HintedWalkerIterator = Generator<YieldResult, void, Hinting | undefined>;
+export declare function hintedWalker(root: TrieRoot, ignoreCase: boolean, hint: string, compoundingMethod: CompoundWordsMethod | undefined, emitWordSeparator?: string): HintedWalkerIterator;
+/**
+ * Walks the Trie and yields a value at each node.
+ * next(goDeeper: boolean):
+ */
+declare function hintedWalkerNext(root: TrieRoot, ignoreCase: boolean, hint: string, compoundingMethod: CompoundWordsMethod | undefined, emitWordSeparator?: string): HintedWalkerIterator;
+export interface Hinting {
+    goDeeper: boolean;
+}
+export declare const __testing__: {
+    hintedWalkerNext: typeof hintedWalkerNext;
+};
+export {};
+//# sourceMappingURL=hintedWalker.d.ts.map

package/dist/lib/suggestions/walker/hintedWalker.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.hintedWalker = void 0;
+const trie_util_1 = require("../../trie-util");
+const walkerTypes_1 = require("./walkerTypes");
+function hintedWalker(root, ignoreCase, hint, compoundingMethod, emitWordSeparator) {
+    return hintedWalkerNext(root, ignoreCase, hint, compoundingMethod, emitWordSeparator);
+}
+exports.hintedWalker = hintedWalker;
+/**
+ * Walks the Trie and yields a value at each node.
+ * next(goDeeper: boolean):
+ */
+function* hintedWalkerNext(root, ignoreCase, hint, compoundingMethod, emitWordSeparator = '') {
+    const _compoundingMethod = compoundingMethod !== null && compoundingMethod !== void 0 ? compoundingMethod : walkerTypes_1.CompoundWordsMethod.NONE;
+    const compoundCharacter = root.compoundCharacter;
+    const noCaseCharacter = root.stripCaseAndAccentsPrefix;
+    const rawRoots = [root, ignoreCase ? root.c.get(noCaseCharacter) : undefined].filter(trie_util_1.isDefined);
+    const specialRootsPrefix = existMap([compoundCharacter, noCaseCharacter, root.forbiddenWordPrefix]);
+    function filterRoot(root) {
+        var _a;
+        const children = (_a = root.c) === null || _a === void 0 ? void 0 : _a.entries();
+        const c = children && [...children].filter(([v]) => !(v in specialRootsPrefix));
+        return {
+            c: c && new Map(c),
+        };
+    }
+    const roots = rawRoots.map(filterRoot);
+    const compoundRoots = rawRoots.map((r) => { var _a; return (_a = r.c) === null || _a === void 0 ? void 0 : _a.get(compoundCharacter); }).filter(trie_util_1.isDefined);
+    const setOfCompoundRoots = new Set(compoundRoots);
+    const rootsForCompoundMethods = roots.concat(compoundRoots);
+    const compoundMethodRoots = {
+        [walkerTypes_1.CompoundWordsMethod.NONE]: [],
+        [walkerTypes_1.CompoundWordsMethod.JOIN_WORDS]: [...rootsForCompoundMethods.map((r) => [walkerTypes_1.JOIN_SEPARATOR, r])],
+        [walkerTypes_1.CompoundWordsMethod.SEPARATE_WORDS]: [...rootsForCompoundMethods.map((r) => [walkerTypes_1.WORD_SEPARATOR, r])],
+    };
+    function* children(n, hintOffset) {
+        if (n.c) {
+            const h = hint.slice(hintOffset, hintOffset + 3) + hint.slice(Math.max(0, hintOffset - 2), hintOffset);
+            const hints = new Set(h);
+            const c = n.c;
+            // First yield the hints
+            yield* [...hints]
+                .filter((a) => c.has(a))
+                .map((letter) => ({
+                letter,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                node: c.get(letter),
+                hintOffset: hintOffset + 1,
+            }));
+            // We don't want to suggest the compound character.
+            hints.add(compoundCharacter);
+            // Then yield everything else.
+            yield* [...c]
+                .filter((a) => !hints.has(a[0]))
+                .map(([letter, node]) => ({
+                letter,
+                node,
+                hintOffset: hintOffset + 1,
+            }));
+            if (c.has(compoundCharacter) && !setOfCompoundRoots.has(n)) {
+                for (const compoundRoot of compoundRoots) {
+                    for (const child of children(compoundRoot, hintOffset)) {
+                        const { letter, node, hintOffset } = child;
+                        yield { letter: emitWordSeparator + letter, node, hintOffset };
+                    }
+                }
+            }
+        }
+        if (n.f) {
+            yield* [...compoundMethodRoots[_compoundingMethod]].map(([letter, node]) => ({
+                letter: letter,
+                node,
+                hintOffset,
+            }));
+        }
+    }
+    for (const root of roots) {
+        let depth = 0;
+        const stack = [];
+        const stackText = [''];
+        stack[depth] = children(root, depth);
+        let ir;
+        while (depth >= 0) {
+            while (!(ir = stack[depth].next()).done) {
+                const { letter: char, node, hintOffset } = ir.value;
+                const text = stackText[depth] + char;
+                const hinting = (yield { text, node, depth });
+                if (hinting && hinting.goDeeper) {
+                    depth++;
+                    stackText[depth] = text;
+                    stack[depth] = children(node, hintOffset);
+                }
+            }
+            depth -= 1;
+        }
+    }
+}
+function existMap(values) {
+    const m = Object.create(null);
+    for (const v of values) {
+        m[v] = true;
+    }
+    return m;
+}
+exports.__testing__ = {
+    hintedWalkerNext,
+};
+//# sourceMappingURL=hintedWalker.js.map

package/dist/lib/suggestions/walker/index.d.ts

@@ -0,0 +1,5 @@
+export * from './walker';
+export { hintedWalker } from './hintedWalker';
+export type { HintedWalkerIterator, Hinting } from './hintedWalker';
+export * from './walkerTypes';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/suggestions/walker/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hintedWalker = void 0;
+__exportStar(require("./walker"), exports);
+var hintedWalker_1 = require("./hintedWalker");
+Object.defineProperty(exports, "hintedWalker", { enumerable: true, get: function () { return hintedWalker_1.hintedWalker; } });
+__exportStar(require("./walkerTypes"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/suggestions/walker/walker.d.ts

@@ -0,0 +1,8 @@
+import { TrieNode } from '../../TrieNode';
+import { CompoundWordsMethod, WalkerIterator } from './walkerTypes';
+/**
+ * Walks the Trie and yields a value at each node.
+ * next(goDeeper: boolean):
+ */
+export declare function walker(root: TrieNode, compoundingMethod?: CompoundWordsMethod): WalkerIterator;
+//# sourceMappingURL=walker.d.ts.map

package/dist/lib/suggestions/walker/walker.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walker = void 0;
+const walkerTypes_1 = require("./walkerTypes");
+/**
+ * Walks the Trie and yields a value at each node.
+ * next(goDeeper: boolean):
+ */
+function* walker(root, compoundingMethod = walkerTypes_1.CompoundWordsMethod.NONE) {
+    const roots = {
+        [walkerTypes_1.CompoundWordsMethod.NONE]: [],
+        [walkerTypes_1.CompoundWordsMethod.JOIN_WORDS]: [[walkerTypes_1.JOIN_SEPARATOR, root]],
+        [walkerTypes_1.CompoundWordsMethod.SEPARATE_WORDS]: [[walkerTypes_1.WORD_SEPARATOR, root]],
+    };
+    function* children(n) {
+        if (n.c) {
+            yield* n.c;
+        }
+        if (n.f) {
+            yield* roots[compoundingMethod];
+        }
+    }
+    let depth = 0;
+    const stack = [];
+    stack[depth] = { t: '', c: children(root) };
+    let ir;
+    while (depth >= 0) {
+        let baseText = stack[depth].t;
+        while (!(ir = stack[depth].c.next()).done) {
+            const [char, node] = ir.value;
+            const text = baseText + char;
+            const goDeeper = yield { text, node, depth };
+            if (goDeeper || goDeeper === undefined) {
+                depth++;
+                baseText = text;
+                stack[depth] = { t: text, c: children(node) };
+            }
+        }
+        depth -= 1;
+    }
+}
+exports.walker = walker;
+//# sourceMappingURL=walker.js.map

package/dist/lib/suggestions/walker/walkerTypes.d.ts

@@ -0,0 +1,24 @@
+import { TrieNode } from '../../TrieNode';
+export declare const JOIN_SEPARATOR = "+";
+export declare const WORD_SEPARATOR = " ";
+export interface YieldResult {
+    text: string;
+    node: TrieNode;
+    depth: number;
+}
+export declare enum CompoundWordsMethod {
+    /**
+     * Do not compound words.
+     */
+    NONE = 0,
+    /**
+     * Create word compounds separated by spaces.
+     */
+    SEPARATE_WORDS = 1,
+    /**
+     * Create word compounds without separation.
+     */
+    JOIN_WORDS = 2
+}
+export declare type WalkerIterator = Generator<YieldResult, void, boolean | undefined>;
+//# sourceMappingURL=walkerTypes.d.ts.map

package/dist/lib/suggestions/walker/walkerTypes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompoundWordsMethod = exports.WORD_SEPARATOR = exports.JOIN_SEPARATOR = void 0;
+exports.JOIN_SEPARATOR = '+';
+exports.WORD_SEPARATOR = ' ';
+var CompoundWordsMethod;
+(function (CompoundWordsMethod) {
+    /**
+     * Do not compound words.
+     */
+    CompoundWordsMethod[CompoundWordsMethod["NONE"] = 0] = "NONE";
+    /**
+     * Create word compounds separated by spaces.
+     */
+    CompoundWordsMethod[CompoundWordsMethod["SEPARATE_WORDS"] = 1] = "SEPARATE_WORDS";
+    /**
+     * Create word compounds without separation.
+     */
+    CompoundWordsMethod[CompoundWordsMethod["JOIN_WORDS"] = 2] = "JOIN_WORDS";
+})(CompoundWordsMethod = exports.CompoundWordsMethod || (exports.CompoundWordsMethod = {}));
+//# sourceMappingURL=walkerTypes.js.map

package/dist/lib/trie-util.js

@@ -171,11 +171,10 @@ exports.isCircular = isCircular;
  */
 function mergeDefaults(value, defaultValue) {
     const result = { ...defaultValue };
-    const allowedKeys = new Set(Object.keys(defaultValue));
     if (value) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         for (const [k, v] of Object.entries(value)) {
-            if (allowedKeys.has(k)) {
+            if (k in result) {
                 result[k] = v !== null && v !== void 0 ? v : result[k];
             }
         }

package/dist/lib/trie.d.ts

@@ -1,7 +1,7 @@
 import { Sequence } from 'gensequence';
 import { FindFullResult } from './find';
-import { SuggestionOptions } from './genSuggestionsOptions';
 import { SuggestionCollector, SuggestionResult } from './suggestCollector';
+import { SuggestionOptions } from './suggestions/genSuggestionsOptions';
 import { PartialTrieOptions, TrieNode, TrieOptions, TrieRoot } from './TrieNode';
 import { CompoundWordsMethod, WalkerIterator } from './walker';
 export { CASE_INSENSITIVE_PREFIX, COMPOUND_FIX, defaultTrieOptions, FORBID_PREFIX, OPTIONAL_COMPOUND_FIX, } from './constants';

package/dist/lib/trie.js

@@ -6,6 +6,7 @@ const constants_1 = require("./constants");
 const find_1 = require("./find");
 const suggest_1 = require("./suggest");
 const trie_util_1 = require("./trie-util");
+const util_1 = require("./utils/util");
 const walker_1 = require("./walker");
 var constants_2 = require("./constants");
 Object.defineProperty(exports, "CASE_INSENSITIVE_PREFIX", { enumerable: true, get: function () { return constants_2.CASE_INSENSITIVE_PREFIX; } });
@@ -142,10 +143,15 @@ class Trie {
      * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
      */
     suggestWithCost(text, options) {
+        const sep = options.compoundSeparator;
+        const adjWord = sep ? (0, util_1.replaceAllFactory)(sep, '') : (a) => a;
         const optFilter = options.filter;
         const filter = optFilter
-            ? (word, cost) => !this.isForbiddenWord(word) && optFilter(word, cost)
-            : (word) => !this.isForbiddenWord(word);
+            ? (word, cost) => {
+                const w = adjWord(word);
+                return !this.isForbiddenWord(w) && optFilter(w, cost);
+            }
+            : (word) => !this.isForbiddenWord(adjWord(word));
         const opts = { ...options, filter };
         return (0, suggest_1.suggest)(this.root, text, opts);
     }
@@ -156,8 +162,8 @@ class Trie {
      */
     genSuggestions(collector, compoundMethod) {
         const filter = (word) => !this.isForbiddenWord(word);
-        const { changeLimit, ignoreCase } = collector;
-        const suggestions = (0, suggest_1.genSuggestions)(this.root, collector.word, (0, trie_util_1.clean)({ compoundMethod, changeLimit, ignoreCase }));
+        const options = (0, trie_util_1.clean)({ compoundMethod, ...collector.genSuggestionOptions });
+        const suggestions = (0, suggest_1.genSuggestions)(this.root, collector.word, options);
         collector.collect(suggestions, undefined, filter);
     }
     /**

package/dist/lib/types.d.ts

@@ -52,9 +52,18 @@ export declare type NoUndefined<T> = {
 export declare type OnlyOptionalOrUndefined<T> = {
     [P in keyof T as P extends OptionalOrUndefinedKeys<T> ? P : never]: T[P];
 };
+/**
+ * Make fields that can be `undefined` optional
+ */
 export declare type MakeOptional<T> = OnlyRequired<T> & Partial<OnlyOptionalOrUndefined<T>>;
+/**
+ * Like Required, but keeps the Optional.
+ */
 export declare type RemoveUndefined<T> = {
     [P in keyof T]: Exclude<T[P], undefined>;
 };
+/**
+ * Make all `undefined` optional and removes the `undefined`
+ */
 export declare type UndefinedToOptional<T> = RemoveUndefined<MakeOptional<T>>;
 //# sourceMappingURL=types.d.ts.map

package/dist/lib/utils/util.d.ts

@@ -15,4 +15,17 @@ export declare function cleanCopy<T, U = UndefinedToOptional<T>>(t: T): U;
 export declare function clean<T, U = UndefinedToOptional<T>>(t: T): U;
 export declare function unique<T>(a: Iterable<T>): T[];
 export declare function flatten<T>(i: Iterable<Iterable<T>>): Iterable<T>;
+export declare function replaceAll(text: string, match: string, withText: string): string;
+/**
+ *
+ * @param text verbatim text to be inserted into a regexp
+ * @returns text that can be used in a regexp.
+ */
+export declare function regexQuote(text: string): string;
+/**
+ * Factory to create a function that will replace all occurrences of `match` with `withText`
+ * @param match - string to match
+ * @param replaceWithText - the text to substitute.
+ */
+export declare function replaceAllFactory(match: string, replaceWithText: string): (text: string) => string;
 //# sourceMappingURL=util.d.ts.map

package/dist/lib/utils/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatten = exports.unique = exports.clean = exports.cleanCopy = exports.isDefined = void 0;
+exports.replaceAllFactory = exports.regexQuote = exports.replaceAll = exports.flatten = exports.unique = exports.clean = exports.cleanCopy = exports.isDefined = void 0;
 function isDefined(a) {
     return a !== undefined;
 }
@@ -40,4 +40,28 @@ function* flatten(i) {
     }
 }
 exports.flatten = flatten;
+function replaceAll(text, match, withText) {
+    const fn = replaceAllFactory(match, withText);
+    return fn(text);
+}
+exports.replaceAll = replaceAll;
+/**
+ *
+ * @param text verbatim text to be inserted into a regexp
+ * @returns text that can be used in a regexp.
+ */
+function regexQuote(text) {
+    return text.replace(/([[\]\-+(){},|*.\\])/g, '\\$1');
+}
+exports.regexQuote = regexQuote;
+/**
+ * Factory to create a function that will replace all occurrences of `match` with `withText`
+ * @param match - string to match
+ * @param replaceWithText - the text to substitute.
+ */
+function replaceAllFactory(match, replaceWithText) {
+    const r = RegExp(regexQuote(match), 'g');
+    return (text) => text.replace(r, replaceWithText);
+}
+exports.replaceAllFactory = replaceAllFactory;
 //# sourceMappingURL=util.js.map

package/dist/lib/walker.d.ts

@@ -1,43 +1,2 @@
-import { TrieNode, TrieRoot } from './TrieNode';
-export declare const JOIN_SEPARATOR = "+";
-export declare const WORD_SEPARATOR = " ";
-export interface YieldResult {
-    text: string;
-    node: TrieNode;
-    depth: number;
-}
-export declare enum CompoundWordsMethod {
-    /**
-     * Do not compound words.
-     */
-    NONE = 0,
-    /**
-     * Create word compounds separated by spaces.
-     */
-    SEPARATE_WORDS = 1,
-    /**
-     * Create word compounds without separation.
-     */
-    JOIN_WORDS = 2
-}
-export declare type WalkerIterator = Generator<YieldResult, void, boolean | undefined>;
-/**
- * Walks the Trie and yields a value at each node.
- * next(goDeeper: boolean):
- */
-export declare function walker(root: TrieNode, compoundingMethod?: CompoundWordsMethod): WalkerIterator;
-export interface Hinting {
-    goDeeper: boolean;
-}
-/**
- * Ask for the next result.
- * goDeeper of true tells the walker to go deeper in the Trie if possible. Default is true.
- * This can be used to limit the walker's depth.
- */
-export declare type HintedWalkerIterator = Generator<YieldResult, void, Hinting | undefined>;
-/**
- * Walks the Trie and yields a value at each node.
- * next(goDeeper: boolean):
- */
-export declare function hintedWalker(root: TrieRoot, ignoreCase: boolean, hint: string, compoundingMethod: CompoundWordsMethod | undefined): HintedWalkerIterator;
+export * from './suggestions/walker/index';
 //# sourceMappingURL=walker.d.ts.map

package/dist/lib/walker.js

@@ -1,154 +1,14 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hintedWalker = exports.walker = exports.CompoundWordsMethod = exports.WORD_SEPARATOR = exports.JOIN_SEPARATOR = void 0;
-const trie_util_1 = require("./trie-util");
-exports.JOIN_SEPARATOR = '+';
-exports.WORD_SEPARATOR = ' ';
-var CompoundWordsMethod;
-(function (CompoundWordsMethod) {
-    /**
-     * Do not compound words.
-     */
-    CompoundWordsMethod[CompoundWordsMethod["NONE"] = 0] = "NONE";
-    /**
-     * Create word compounds separated by spaces.
-     */
-    CompoundWordsMethod[CompoundWordsMethod["SEPARATE_WORDS"] = 1] = "SEPARATE_WORDS";
-    /**
-     * Create word compounds without separation.
-     */
-    CompoundWordsMethod[CompoundWordsMethod["JOIN_WORDS"] = 2] = "JOIN_WORDS";
-})(CompoundWordsMethod = exports.CompoundWordsMethod || (exports.CompoundWordsMethod = {}));
-/**
- * Walks the Trie and yields a value at each node.
- * next(goDeeper: boolean):
- */
-function* walker(root, compoundingMethod = CompoundWordsMethod.NONE) {
-    const roots = {
-        [CompoundWordsMethod.NONE]: [],
-        [CompoundWordsMethod.JOIN_WORDS]: [[exports.JOIN_SEPARATOR, root]],
-        [CompoundWordsMethod.SEPARATE_WORDS]: [[exports.WORD_SEPARATOR, root]],
-    };
-    function* children(n) {
-        if (n.c) {
-            yield* n.c;
-        }
-        if (n.f) {
-            yield* roots[compoundingMethod];
-        }
-    }
-    let depth = 0;
-    const stack = [];
-    stack[depth] = { t: '', c: children(root) };
-    let ir;
-    while (depth >= 0) {
-        let baseText = stack[depth].t;
-        while (!(ir = stack[depth].c.next()).done) {
-            const [char, node] = ir.value;
-            const text = baseText + char;
-            const goDeeper = yield { text, node, depth };
-            if (goDeeper || goDeeper === undefined) {
-                depth++;
-                baseText = text;
-                stack[depth] = { t: text, c: children(node) };
-            }
-        }
-        depth -= 1;
-    }
-}
-exports.walker = walker;
-/**
- * Walks the Trie and yields a value at each node.
- * next(goDeeper: boolean):
- */
-function* hintedWalker(root, ignoreCase, hint, compoundingMethod) {
-    const _compoundingMethod = compoundingMethod !== null && compoundingMethod !== void 0 ? compoundingMethod : CompoundWordsMethod.NONE;
-    const compoundCharacter = root.compoundCharacter;
-    const noCaseCharacter = root.stripCaseAndAccentsPrefix;
-    const rawRoots = [root, ignoreCase ? root.c.get(noCaseCharacter) : undefined].filter(trie_util_1.isDefined);
-    const specialRootsPrefix = existMap([compoundCharacter, noCaseCharacter, root.forbiddenWordPrefix]);
-    function filterRoot(root) {
-        var _a;
-        const children = (_a = root.c) === null || _a === void 0 ? void 0 : _a.entries();
-        const c = children && [...children].filter(([v]) => !(v in specialRootsPrefix));
-        return {
-            c: c && new Map(c),
-        };
-    }
-    const roots = rawRoots.map(filterRoot);
-    const compoundRoots = rawRoots.map((r) => { var _a; return (_a = r.c) === null || _a === void 0 ? void 0 : _a.get(compoundCharacter); }).filter(trie_util_1.isDefined);
-    const rootsForCompoundMethods = roots.concat(compoundRoots);
-    const compoundMethodRoots = {
-        [CompoundWordsMethod.NONE]: [],
-        [CompoundWordsMethod.JOIN_WORDS]: [...rootsForCompoundMethods.map((r) => [exports.JOIN_SEPARATOR, r])],
-        [CompoundWordsMethod.SEPARATE_WORDS]: [...rootsForCompoundMethods.map((r) => [exports.WORD_SEPARATOR, r])],
-    };
-    function* children(n, hintOffset) {
-        if (n.c) {
-            const h = hint.slice(hintOffset, hintOffset + 3) + hint.slice(Math.max(0, hintOffset - 2), hintOffset);
-            const hints = new Set(h);
-            const c = n.c;
-            // First yield the hints
-            yield* [...hints]
-                .filter((a) => c.has(a))
-                .map((letter) => ({
-                letter,
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                node: c.get(letter),
-                hintOffset: hintOffset + 1,
-            }));
-            // We don't want to suggest the compound character.
-            hints.add(compoundCharacter);
-            // Then yield everything else.
-            yield* [...c]
-                .filter((a) => !hints.has(a[0]))
-                .map(([letter, node]) => ({
-                letter,
-                node,
-                hintOffset: hintOffset + 1,
-            }));
-            if (c.has(compoundCharacter)) {
-                for (const compoundRoot of compoundRoots) {
-                    yield* children(compoundRoot, hintOffset);
-                }
-            }
-        }
-        if (n.f) {
-            yield* [...compoundMethodRoots[_compoundingMethod]].map(([letter, node]) => ({
-                letter,
-                node,
-                hintOffset,
-            }));
-        }
-    }
-    for (const root of roots) {
-        let depth = 0;
-        const stack = [];
-        let baseText = '';
-        stack[depth] = children(root, depth);
-        let ir;
-        while (depth >= 0) {
-            while (!(ir = stack[depth].next()).done) {
-                const { letter: char, node, hintOffset } = ir.value;
-                const text = baseText + char;
-                const hinting = (yield { text, node, depth });
-                if (hinting && hinting.goDeeper) {
-                    depth++;
-                    baseText = text;
-                    stack[depth] = children(node, hintOffset);
-                }
-            }
-            depth -= 1;
-            baseText = baseText.slice(0, -1);
-        }
-    }
-}
-exports.hintedWalker = hintedWalker;
-function existMap(values) {
-    const m = Object.create(null);
-    for (const v of values) {
-        m[v] = true;
-    }
-    return m;
-}
+__exportStar(require("./suggestions/walker/index"), exports);
 //# sourceMappingURL=walker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-trie-lib",
-  "version": "5.18.0-alpha.0",
+  "version": "5.18.3",
   "description": "Trie Data Structure to support cspell.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "^5.18.0-alpha.0",
+    "@cspell/cspell-pipe": "^5.18.3",
     "fs-extra": "^10.0.0",
     "gensequence": "^3.1.1"
   },
@@ -45,13 +45,13 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-types": "^5.18.0-alpha.0",
-    "@cspell/dict-en_us": "^2.1.4",
+    "@cspell/cspell-types": "^5.18.3",
+    "@cspell/dict-en_us": "^2.1.5",
     "@cspell/dict-es-es": "^2.1.0",
     "@types/fs-extra": "^9.0.13",
-    "@types/node": "^17.0.13",
+    "@types/node": "^17.0.14",
     "jest": "^27.4.7",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "d3c6f34444f19e9d8e375d1cbea6f99d0f270716"
+  "gitHead": "c650c8d0d58fc0398a6f745a0ad48d46f982332f"
 }