cspell-trie-lib 10.0.1 → 10.1.1

package/dist/index.d.ts

@@ -1,33 +1,32 @@
 import { DictionaryDefinitionAugmented, SuggestionCostMapDef } from "@cspell/cspell-types";
-
 //#region src/lib/BuildOptions.d.ts
 interface BuildOptions {
   /**
-  * Optimize the trie for size by merging duplicate sub-tries and using a String Table.
-  * @default false
-  */
+   * Optimize the trie for size by merging duplicate sub-tries and using a String Table.
+   * @default false
+   */
   optimize?: boolean | undefined;
   /**
-  * Use a string table to reduce memory usage.
-  * @default false
-  */
+   * Use a string table to reduce memory usage.
+   * @default false
+   */
   useStringTable?: boolean | undefined;
 }
 //#endregion
 //#region src/lib/distance/weightedMaps.d.ts
 /**
-* Costs are minimized while penalties are maximized.
-*/
+ * Costs are minimized while penalties are maximized.
+ */
 interface Cost$1 {
   /**
-  * The cost of an operation
-  * `c'' = min(c, c')`
-  */
+   * The cost of an operation
+   * `c'' = min(c, c')`
+   */
   c?: number | undefined;
   /**
-  * The penalties applied
-  * `p'' = max(p, p')`
-  */
+   * The penalties applied
+   * `p'' = max(p, p')`
+   */
   p?: number | undefined;
 }
 interface TrieCost extends Cost$1 {
@@ -57,35 +56,35 @@ interface PenaltyAdjustment {
 //#endregion
 //#region src/lib/distance/distance.d.ts
 /**
-* 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.
-*/
+ * 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.
+ */
 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
-*/
+ * 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
+ */
 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.
-*/
+ * Collect Map definitions into a single weighted map.
+ * @param defs - list of definitions
+ * @returns A Weighted Map to be used with distance calculations.
+ */
 declare function createWeightedMap(defs: SuggestionCostMapDef[]): WeightMap;
 //#endregion
 //#region src/lib/types.d.ts
 /**
-* Make all properties in T optional and Possibly undefined
-*/
-type PartialWithUndefined<T> = { [P in keyof T]?: T[P] | undefined };
+ * Make all properties in T optional and Possibly undefined
+ */
+type PartialWithUndefined<T> = { [P in keyof T]?: T[P] | undefined; };
 //#endregion
 //#region src/lib/ITrieNode/TrieInfo.d.ts
 interface TrieInfo {
@@ -109,41 +108,41 @@ interface FindResult$1 {
   compoundUsed: boolean;
   caseMatched: boolean;
   /**
-  * Is the word explicitly forbidden.
-  * - `true` - word is in the forbidden list.
-  * - `false` - word is not in the forbidden list.
-  * - `undefined` - unknown - was not checked.
-  */
+   * Is the word explicitly forbidden.
+   * - `true` - word is in the forbidden list.
+   * - `false` - word is not in the forbidden list.
+   * - `undefined` - unknown - was not checked.
+   */
   forbidden: boolean | undefined;
 }
 interface FindFullResult$1 extends FindResult$1 {
   /**
-  * Is the word explicitly forbidden.
-  * - `true` - word is in the forbidden list.
-  * - `false` - word is not in the forbidden list.
-  * - `undefined` - unknown - was not checked.
-  */
+   * Is the word explicitly forbidden.
+   * - `true` - word is in the forbidden list.
+   * - `false` - word is not in the forbidden list.
+   * - `undefined` - unknown - was not checked.
+   */
   forbidden: boolean | undefined;
 }
 /**
-* ITrieNode instances are not unique. It is possible for multiple ITrieNode instances to
-* represent the same node.
-* `id` is used to see if two instances refer to the same node.
-* The type is obscured because it is up the the backing structure to provide the best value.
-* Note, only nodes from the same root are guaranteed to be unique. It is possible for two
-* different ITrieNode instances to have the same `id` value if they come from different roots.
-*/
+ * ITrieNode instances are not unique. It is possible for multiple ITrieNode instances to
+ * represent the same node.
+ * `id` is used to see if two instances refer to the same node.
+ * The type is obscured because it is up the the backing structure to provide the best value.
+ * Note, only nodes from the same root are guaranteed to be unique. It is possible for two
+ * different ITrieNode instances to have the same `id` value if they come from different roots.
+ */
 type ITrieNodeId = object | number | string | bigint;
 type Entry = readonly [string, ITrieNode];
 interface ITrieNode {
   /**
-  * ITrieNode instances are not unique. It is possible for multiple ITrieNode instances to
-  * represent the same node.
-  * `id` is used to see if two instances refer to the same node.
-  * The type is obscured because it is up the the backing structure to provide the best value.
-  * Note, only nodes from the same root are guaranteed to be unique. It is possible for two
-  * different ITrieNode instances to have the same `id` value if they come from different roots.
-  */
+   * ITrieNode instances are not unique. It is possible for multiple ITrieNode instances to
+   * represent the same node.
+   * `id` is used to see if two instances refer to the same node.
+   * The type is obscured because it is up the the backing structure to provide the best value.
+   * Note, only nodes from the same root are guaranteed to be unique. It is possible for two
+   * different ITrieNode instances to have the same `id` value if they come from different roots.
+   */
   readonly id: ITrieNodeId;
   /** flag End of Word */
   readonly eow: boolean;
@@ -167,17 +166,17 @@ interface ITrieNode {
 interface ITrieNodeRoot extends ITrieNode {
   readonly info: Readonly<TrieInfo>;
   /**
-  * converts an `id` into a node.
-  * @param id an of a ITrieNode in this Trie
-  */
+   * converts an `id` into a node.
+   * @param id an of a ITrieNode in this Trie
+   */
   resolveId(id: ITrieNodeId): ITrieNode;
   findExact: ((word: string) => boolean) | undefined;
   /**
-  * Try to find a word.
-  * @param word - the normalized word to look up.
-  * @param strict - if `true` the case and accents must match.
-  * @returns undefined if it did not try to find the word, otherwise a FindResult.
-  */
+   * Try to find a word.
+   * @param word - the normalized word to look up.
+   * @param strict - if `true` the case and accents must match.
+   * @returns undefined if it did not try to find the word, otherwise a FindResult.
+   */
   find?: ((word: string, strict: boolean) => FindResult$1 | undefined) | undefined;
   isForbidden?: ((word: string) => boolean) | undefined;
   readonly forbidPrefix: string;
@@ -215,16 +214,16 @@ interface YieldResult {
 }
 declare const CompoundWordsMethodEnum: {
   /**
-  * Do not compound words.
-  */
+   * Do not compound words.
+   */
   readonly NONE: 0;
   /**
-  * Create word compounds separated by spaces.
-  */
+   * Create word compounds separated by spaces.
+   */
   readonly SEPARATE_WORDS: 1;
   /**
-  * Create word compounds without separation.
-  */
+   * Create word compounds without separation.
+   */
   readonly JOIN_WORDS: 2;
 };
 type CompoundWordsMethodEnum = typeof CompoundWordsMethodEnum;
@@ -245,17 +244,17 @@ interface YieldResult$1 {
 }
 type FalseToNotGoDeeper = boolean;
 /**
-* By default a Walker Iterator will go depth first. To prevent the
-* walker from going deeper use `iterator.next(false)`.
-*/
+ * By default a Walker Iterator will go depth first. To prevent the
+ * walker from going deeper use `iterator.next(false)`.
+ */
 type WalkerIterator$1 = Generator<YieldResult$1, void, FalseToNotGoDeeper | undefined>;
 //#endregion
 //#region src/lib/walker/hintedWalker.d.ts
 /**
-* 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.
-*/
+ * 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.
+ */
 type HintedWalkerIterator = Generator<YieldResult, void, Hinting | undefined>;
 declare function hintedWalker(root: TrieRoot, ignoreCase: boolean, hint: string, compoundingMethod: CompoundWordsMethod | undefined, emitWordSeparator?: string): HintedWalkerIterator;
 interface Hinting {
@@ -268,23 +267,23 @@ declare function walker(root: TrieNode, compoundingMethod?: CompoundWordsMethod)
 //#region src/lib/suggestions/genSuggestionsOptions.d.ts
 interface GenSuggestionOptionsStrict {
   /**
-  * Controls forcing compound words.
-  * @default CompoundWordsMethod.NONE
-  */
+   * Controls forcing compound words.
+   * @default CompoundWordsMethod.NONE
+   */
   compoundMethod?: CompoundWordsMethod;
   /**
-  * ignore case when searching.
-  */
+   * ignore case when searching.
+   */
   ignoreCase: boolean;
   /**
-  * Maximum number of "edits" allowed.
-  * 3 is a good number. Above 5 can be very slow.
-  */
+   * Maximum number of "edits" allowed.
+   * 3 is a good number. Above 5 can be very slow.
+   */
   changeLimit: number;
   /**
-  * Inserts a compound character between compounded word segments.
-  * @default ""
-  */
+   * Inserts a compound character between compounded word segments.
+   * @default ""
+   */
   compoundSeparator?: string;
 }
 type GenSuggestionOptionsStrictRO = Readonly<GenSuggestionOptionsStrict>;
@@ -292,26 +291,26 @@ type GenSuggestionOptions = Partial<GenSuggestionOptionsStrict>;
 type GenSuggestionOptionsRO = Readonly<GenSuggestionOptions>;
 interface SuggestionOptionsStrict extends GenSuggestionOptionsStrict {
   /**
-  * Maximum number of suggestions to make.
-  */
+   * Maximum number of suggestions to make.
+   */
   numSuggestions: number;
   /**
-  * Allow ties when making suggestions.
-  * if `true` it is possible to have more than `numSuggestions`.
-  */
+   * Allow ties when making suggestions.
+   * if `true` it is possible to have more than `numSuggestions`.
+   */
   includeTies: boolean;
   /**
-  * Time alloted in milliseconds to generate suggestions.
-  */
+   * Time alloted in milliseconds to generate suggestions.
+   */
   timeout: number;
   /**
-  * Optional filter function.
-  * return true to keep the candidate.
-  */
+   * Optional filter function.
+   * return true to keep the candidate.
+   */
   filter?: (word: string, cost: number) => boolean;
   /**
-  * Apply weights to improve the suggestions.
-  */
+   * Apply weights to improve the suggestions.
+   */
   weightMap?: WeightMap | undefined;
 }
 type SuggestionOptions = Partial<SuggestionOptionsStrict>;
@@ -326,9 +325,9 @@ interface SuggestionResultBase {
   /** The edit cost 100 = 1 edit */
   cost: Cost;
   /**
-  * This suggestion is the preferred suggestion.
-  * Setting this to `true` implies that an auto fix is possible.
-  */
+   * This suggestion is the preferred suggestion.
+   * Setting this to `true` implies that an auto fix is possible.
+   */
   isPreferred?: boolean | undefined;
 }
 interface SuggestionResult extends SuggestionResultBase {
@@ -340,36 +339,36 @@ interface Progress {
   /** Number of Completed Tasks so far */
   completed: number;
   /**
-  * Number of tasks remaining, this number is allowed to increase over time since
-  * completed tasks can generate new tasks.
-  */
+   * Number of tasks remaining, this number is allowed to increase over time since
+   * completed tasks can generate new tasks.
+   */
   remaining: number;
 }
 type GenerateNextParam = MaxCost | symbol | undefined;
 type GenerateSuggestionResult = SuggestionResultBase | Progress | undefined;
 /**
-* Ask for the next result.
-* maxCost - sets the max cost for following suggestions
-* This is used to limit which suggestions are emitted.
-* If the `iterator.next()` returns `undefined`, it is to request a value for maxCost.
-*
-* The SuggestionIterator is generally the
-*/
+ * Ask for the next result.
+ * maxCost - sets the max cost for following suggestions
+ * This is used to limit which suggestions are emitted.
+ * If the `iterator.next()` returns `undefined`, it is to request a value for maxCost.
+ *
+ * The SuggestionIterator is generally the
+ */
 type SuggestionGenerator = Generator<GenerateSuggestionResult, void, GenerateNextParam>;
 //#endregion
 //#region src/lib/suggestions/suggestCollector.d.ts
 type FilterWordFn = (word: string, cost: number) => boolean;
 interface SuggestionCollector {
   /**
-  * Collection suggestions from a SuggestionIterator
-  * @param src - the SuggestionIterator used to generate suggestions.
-  * @param timeout - the amount of time in milliseconds to allow for suggestions.
-  * before sending `symbolStopProcessing`
-  * Iterator implementation:
-  * @example
-  * r = yield(suggestion);
-  * if (r === collector.symbolStopProcessing) // ...stop generating suggestions.
-  */
+   * Collection suggestions from a SuggestionIterator
+   * @param src - the SuggestionIterator used to generate suggestions.
+   * @param timeout - the amount of time in milliseconds to allow for suggestions.
+   * before sending `symbolStopProcessing`
+   * Iterator implementation:
+   * @example
+   * r = yield(suggestion);
+   * if (r === collector.symbolStopProcessing) // ...stop generating suggestions.
+   */
   collect: (src: SuggestionGenerator, timeout?: number, filter?: FilterWordFn) => void;
   add: (suggestion: SuggestionResultBase) => SuggestionCollector;
   readonly suggestions: SuggestionResult[];
@@ -381,56 +380,56 @@ interface SuggestionCollector {
   readonly ignoreCase: boolean;
   readonly genSuggestionOptions: GenSuggestionOptionsRO;
   /**
-  * Possible value sent to the SuggestionIterator telling it to stop processing.
-  */
+   * Possible value sent to the SuggestionIterator telling it to stop processing.
+   */
   readonly symbolStopProcessing: symbol;
 }
 interface SuggestionCollectorOptions extends Omit<GenSuggestionOptionsStrictRO, "ignoreCase" | "changeLimit"> {
   /**
-  * number of best matching suggestions.
-  * @default 10
-  */
+   * number of best matching suggestions.
+   * @default 10
+   */
   numSuggestions: number;
   /**
-  * An optional filter function that can be used to limit remove unwanted suggestions.
-  * I.E. to remove forbidden terms.
-  * @default () => true
-  */
+   * An optional filter function that can be used to limit remove unwanted suggestions.
+   * I.E. to remove forbidden terms.
+   * @default () => true
+   */
   filter?: FilterWordFn | undefined;
   /**
-  * The number of letters that can be changed when looking for a match
-  * @default 5
-  */
+   * The number of letters that can be changed when looking for a match
+   * @default 5
+   */
   changeLimit: number | undefined;
   /**
-  * Include suggestions with tied cost even if the number is greater than `numSuggestions`.
-  * @default true
-  */
+   * Include suggestions with tied cost even if the number is greater than `numSuggestions`.
+   * @default true
+   */
   includeTies?: boolean | undefined;
   /**
-  * specify if case / accents should be ignored when looking for suggestions.
-  * @default true
-  */
+   * specify if case / accents should be ignored when looking for suggestions.
+   * @default true
+   */
   ignoreCase: boolean | undefined;
   /**
-  * the total amount of time to allow for suggestions.
-  * @default 1000
-  */
+   * the total amount of time to allow for suggestions.
+   * @default 1000
+   */
   timeout?: number | undefined;
   /**
-  * Used to improve the sorted results.
-  */
+   * Used to improve the sorted results.
+   */
   weightMap?: WeightMap | undefined;
 }
 type SuggestionCollectorOptionsRO = Readonly<SuggestionCollectorOptions>;
 declare function suggestionCollector(wordToMatch: string, options: SuggestionCollectorOptionsRO): 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
-*/
+ * 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
+ */
 declare function impersonateCollector(collector: SuggestionCollector, word: string): SuggestionCollector;
 //#endregion
 //#region src/lib/TrieData.d.ts
@@ -442,9 +441,9 @@ interface TrieData extends TrieDataFundamentals, Readonly<TrieCharacteristics> {
   /** Method used to split words into individual characters. */
   wordToCharacters(word: string): readonly string[];
   /**
-  * get an iterable for all the words in the dictionary.
-  * @param prefix - optional prefix to filter the words returned. The words will be prefixed with this value.
-  */
+   * get an iterable for all the words in the dictionary.
+   * @param prefix - optional prefix to filter the words returned. The words will be prefixed with this value.
+   */
   words(prefix?: string): Iterable<string>;
   getRoot(): ITrieNodeRoot;
   getNode(prefix: string): ITrieNode | undefined;
@@ -461,117 +460,117 @@ interface TrieData extends TrieDataFundamentals, Readonly<TrieCharacteristics> {
 interface ITrie {
   readonly data: TrieData;
   /**
-  * Approximate number of words in the Trie, the first call to this method might be expensive.
-  * Use `size` to get the number of nodes.
-  *
-  * It does NOT count natural compound words. Natural compounds are words that are composed of appending
-  * multiple words to make a new word. This is common in languages like German and Dutch.
-  */
+   * Approximate number of words in the Trie, the first call to this method might be expensive.
+   * Use `size` to get the number of nodes.
+   *
+   * It does NOT count natural compound words. Natural compounds are words that are composed of appending
+   * multiple words to make a new word. This is common in languages like German and Dutch.
+   */
   numWords(): number;
   /**
-  * Used to check if the number of words has been calculated.
-  */
+   * Used to check if the number of words has been calculated.
+   */
   isNumWordsKnown(): boolean;
   /**
-  * The number of nodes in the Trie. There is a rough corelation between the size and the number of words.
-  */
+   * The number of nodes in the Trie. There is a rough corelation between the size and the number of words.
+   */
   readonly size: number;
   readonly info: Readonly<TrieInfo>;
   /**
-  * @param text - text to find in the Trie
-  */
+   * @param text - text to find in the Trie
+   */
   find(text: string): ITrieNode | undefined;
   /**
-  * A case sensitive search for the word.
-  * @param word - the word to search for.
-  * @returns true if the word is found and not forbidden.
-  */
+   * A case sensitive search for the word.
+   * @param word - the word to search for.
+   * @returns true if the word is found and not forbidden.
+   */
   has(word: string): boolean;
   /**
-  * The legacy case insensitive search for the word.
-  * @param word - the word to search for.
-  * @param minLegacyCompoundLength - minimum length of legacy compounds to consider.
-  * @returns true if the word is found and not forbidden.
-  * @deprecated use hasWord or findWord instead. Support for this method signature may be removed in the future.
-  */
+   * The legacy case insensitive search for the word.
+   * @param word - the word to search for.
+   * @param minLegacyCompoundLength - minimum length of legacy compounds to consider.
+   * @returns true if the word is found and not forbidden.
+   * @deprecated use hasWord or findWord instead. Support for this method signature may be removed in the future.
+   */
   has(word: string, minLegacyCompoundLength: boolean | number): boolean;
   /**
-  * Determine if a word is in the dictionary.
-  * @param word - the exact word to search for - must be normalized.
-  * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
-  * @returns true if the word was found and is not forbidden.
-  */
+   * Determine if a word is in the dictionary.
+   * @param word - the exact word to search for - must be normalized.
+   * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
+   * @returns true if the word was found and is not forbidden.
+   */
   hasWord(word: string, caseSensitive: boolean): boolean;
   findWord(word: string, options?: FindWordOptionsRO): FindFullResult$1;
   /**
-  * Determine if a word is in the forbidden word list.
-  * @param word the word to lookup.
-  */
+   * Determine if a word is in the forbidden word list.
+   * @param word the word to lookup.
+   */
   isForbiddenWord(word: string): boolean;
   /**
-  * Provides an ordered sequence of words with the prefix of text.
-  */
+   * Provides an ordered sequence of words with the prefix of text.
+   */
   completeWord(text: string): Iterable<string>;
   /**
-  * Checks to see if there are preferred suggestions for the given text.
-  *
-  * @param word
-  */
+   * Checks to see if there are preferred suggestions for the given text.
+   *
+   * @param word
+   */
   wordHasPreferredSuggestions(word: string): boolean;
   /**
-  * Get preferred suggestions for the given text.
-  * @param text - the exact word to search for.
-  */
+   * Get preferred suggestions for the given text.
+   * @param text - the exact word to search for.
+   */
   getPreferredSuggestions(text: string): Iterable<string>;
   /**
-  * Get a list of all preferred suggestions in the trie.
-  * They are returned in order and in the following format:
-  * ```
-  * <word1>:<suggestion1>
-  * <word1>:<suggestion2>
-  * <word2>:<suggestion1>
-  * ```
-  *
-  * If `startingWith` is provided, only words that start with the prefix are returned.
-  *
-  * @param startingWith - optional prefix to filter the words returned.
-  */
+   * Get a list of all preferred suggestions in the trie.
+   * They are returned in order and in the following format:
+   * ```
+   * <word1>:<suggestion1>
+   * <word1>:<suggestion2>
+   * <word2>:<suggestion1>
+   * ```
+   *
+   * If `startingWith` is provided, only words that start with the prefix are returned.
+   *
+   * @param startingWith - optional prefix to filter the words returned.
+   */
   getAllPreferredSuggestions(startingWith?: string): Iterable<string>;
   /**
-  * Checks to see if the trie contains preferred suggestions for any words.
-  */
+   * Checks to see if the trie contains preferred suggestions for any words.
+   */
   readonly hasPreferredSuggestions: boolean;
   /**
-  * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
-  * @param text - the text to search for
-  * @param options - Controls the generated suggestions:
-  * - ignoreCase - Ignore Case and Accents
-  * - numSuggestions - the maximum number of suggestions to return.
-  * - compoundMethod - Use to control splitting words.
-  * - changeLimit - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
-  *                      the lower the value, the faster results are returned. Values less than 4 are best.
-  */
+   * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+   * @param text - the text to search for
+   * @param options - Controls the generated suggestions:
+   * - ignoreCase - Ignore Case and Accents
+   * - numSuggestions - the maximum number of suggestions to return.
+   * - compoundMethod - Use to control splitting words.
+   * - changeLimit - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
+   *                      the lower the value, the faster results are returned. Values less than 4 are best.
+   */
   suggest(text: string, options: SuggestionOptions): string[];
   /**
-  * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
-  * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
-  */
+   * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+   * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
+   */
   suggestWithCost(text: string, options: SuggestionOptions): SuggestionResult[];
   /**
-  * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
-  * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
-  * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
-  */
+   * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
+   * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
+   * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
+   */
   genSuggestions(collector: SuggestionCollector, compoundMethod?: CompoundWordsMethod): void;
   /**
-  * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
-  * @param prefix - optional prefix to filter the words returned. The words will be prefixed with this value.
-  */
+   * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
+   * @param prefix - optional prefix to filter the words returned. The words will be prefixed with this value.
+   */
   words(prefix?: string): Iterable<string>;
   /**
-  * Allows iteration over the entire tree.
-  * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
-  */
+   * Allows iteration over the entire tree.
+   * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
+   */
   iterate(): WalkerIterator$1;
   readonly weightMap: WeightMap | undefined;
   readonly hasForbiddenWords: boolean;
@@ -583,8 +582,8 @@ interface FindWordOptions {
   useLegacyWordCompounds?: boolean | number;
   checkForbidden?: boolean;
   /**
-  * Separate compound words with the given string.
-  */
+   * Separate compound words with the given string.
+   */
   compoundSeparator?: string;
 }
 type FindWordOptionsRO = Readonly<FindWordOptions>;
@@ -594,9 +593,9 @@ declare function buildITrieFromWords(words: Iterable<string>, info?: PartialTrie
 //#endregion
 //#region src/lib/consolidate.d.ts
 /**
-* Consolidate to DAWG
-* @param root the root of the Trie tree
-*/
+ * Consolidate to DAWG
+ * @param root the root of the Trie tree
+ */
 declare function consolidate(root: TrieRoot): TrieRoot;
 //#endregion
 //#region src/lib/constants.d.ts
@@ -617,11 +616,11 @@ interface FindResult {
 }
 interface FindFullResult extends FindResult {
   /**
-  * Is the word explicitly forbidden.
-  * - `true` - word is in the forbidden list.
-  * - `false` - word is not in the forbidden list.
-  * - `undefined` - unknown - was not checked.
-  * */
+   * Is the word explicitly forbidden.
+   * - `true` - word is in the forbidden list.
+   * - `false` - word is not in the forbidden list.
+   * - `undefined` - unknown - was not checked.
+   * */
   forbidden: boolean | undefined;
 }
 //#endregion
@@ -637,75 +636,75 @@ declare class Trie {
   private count;
   constructor(root: TrieRoot, count?: number);
   /**
-  * Number of words in the Trie
-  */
+   * Number of words in the Trie
+   */
   size(): number;
   isSizeKnown(): boolean;
   get options(): Readonly<TrieInfo>;
   /**
-  * @param text - text to find in the Trie
-  * @param minCompoundLength - deprecated - allows words to be glued together
-  */
+   * @param text - text to find in the Trie
+   * @param minCompoundLength - deprecated - allows words to be glued together
+   */
   find(text: string, minCompoundLength?: boolean | number): TrieNode | undefined;
   /**
-  * A case sensitive search for the word.
-  * @param word - the word to search for.
-  * @returns true if the word is found and not forbidden.
-  */
+   * A case sensitive search for the word.
+   * @param word - the word to search for.
+   * @returns true if the word is found and not forbidden.
+   */
   has(word: string): boolean;
   /**
-  * A case insensitive search for the word.
-  * @param word - the word to search for.
-  * @param minLegacyCompoundLength - minimum length of legacy compounds to consider.
-  * @returns true if the word is found and not forbidden.
-  * @deprecated use hasWord or findWord instead. Support for this method signature may be removed in the future.
-  */
+   * A case insensitive search for the word.
+   * @param word - the word to search for.
+   * @param minLegacyCompoundLength - minimum length of legacy compounds to consider.
+   * @returns true if the word is found and not forbidden.
+   * @deprecated use hasWord or findWord instead. Support for this method signature may be removed in the future.
+   */
   has(word: string, minLegacyCompoundLength: boolean | number): boolean;
   /**
-  * Determine if a word is in the dictionary.
-  * @param word - the exact word to search for - must be normalized.
-  * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
-  * @returns true if the word was found and is not forbidden.
-  */
+   * Determine if a word is in the dictionary.
+   * @param word - the exact word to search for - must be normalized.
+   * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
+   * @returns true if the word was found and is not forbidden.
+   */
   hasWord(word: string, caseSensitive: boolean): boolean;
   findWord(word: string, options?: FindWordOptionsRO): FindFullResult;
   /**
-  * Determine if a word is in the forbidden word list.
-  * @param word the word to lookup.
-  */
+   * Determine if a word is in the forbidden word list.
+   * @param word the word to lookup.
+   */
   isForbiddenWord(word: string): boolean;
   /**
-  * Provides an ordered sequence of words with the prefix of text.
-  */
+   * Provides an ordered sequence of words with the prefix of text.
+   */
   completeWord(text: string): Iterable<string>;
   /**
-  * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
-  * @param text - the text to search for
-  * @param maxNumSuggestions - the maximum number of suggestions to return.
-  * @param compoundMethod - Use to control splitting words.
-  * @param numChanges - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
-  *                      the lower the value, the faster results are returned. Values less than 4 are best.
-  */
+   * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+   * @param text - the text to search for
+   * @param maxNumSuggestions - the maximum number of suggestions to return.
+   * @param compoundMethod - Use to control splitting words.
+   * @param numChanges - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
+   *                      the lower the value, the faster results are returned. Values less than 4 are best.
+   */
   suggest(text: string, options: SuggestionOptionsRO): string[];
   /**
-  * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
-  * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
-  */
+   * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+   * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
+   */
   suggestWithCost(text: string, options: SuggestionOptionsRO): SuggestionResult[];
   /**
-  * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
-  * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
-  * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
-  */
+   * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
+   * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
+   * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
+   */
   genSuggestions(collector: SuggestionCollector, compoundMethod?: CompoundWordsMethod): void;
   /**
-  * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
-  */
+   * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
+   */
   words(prefix?: string): Iterable<string>;
   /**
-  * Allows iteration over the entire tree.
-  * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
-  */
+   * Allows iteration over the entire tree.
+   * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
+   */
   iterate(): WalkerIterator;
   insert(word: string): this;
   private calcIsLegacy;
@@ -722,97 +721,97 @@ interface ParseDictionaryOptions extends BuildOptions {
   forbiddenPrefix: string;
   caseInsensitivePrefix: string;
   /**
-  * Start of a single-line comment.
-  * @default "#"
-  */
+   * Start of a single-line comment.
+   * @default "#"
+   */
   commentCharacter: string;
   /**
-  * If word starts with prefix, do not strip case or accents.
-  * @default false;
-  */
+   * If word starts with prefix, do not strip case or accents.
+   * @default false;
+   */
   keepExactPrefix: string;
   /**
-  * Tell the parser to automatically create case / accent insensitive forms.
-  * @default true
-  */
+   * Tell the parser to automatically create case / accent insensitive forms.
+   * @default true
+   */
   stripCaseAndAccents: boolean;
   /**
-  * Tell the parser to keep non-case/accent version in both forms.
-  * @default false
-  */
+   * Tell the parser to keep non-case/accent version in both forms.
+   * @default false
+   */
   stripCaseAndAccentsKeepDuplicate: boolean;
   /**
-  * Tell the parser to keep non-case/accent version in both forms.
-  * @default false
-  */
+   * Tell the parser to keep non-case/accent version in both forms.
+   * @default false
+   */
   stripCaseAndAccentsOnForbidden: boolean;
   /**
-  * Tell the parser to split into words along spaces.
-  * @default false
-  */
+   * Tell the parser to split into words along spaces.
+   * @default false
+   */
   split: boolean;
   /**
-  * When splitting tells the parser to output both the split and non-split versions of the line.
-  * @default false
-  */
+   * When splitting tells the parser to output both the split and non-split versions of the line.
+   * @default false
+   */
   splitKeepBoth: boolean;
   /**
-  * Specify the separator for splitting words.
-  */
+   * Specify the separator for splitting words.
+   */
   splitSeparator: RegExp | string;
   /**
-  * Do not normalize the compound character.
-  */
+   * Do not normalize the compound character.
+   */
   keepOptionalCompoundCharacter: boolean;
   /**
-  * The character used to denote suggestion prefixes.
-  * An empty string or whitespace disables suggestion handling.
-  * @default ":"
-  */
+   * The character used to denote suggestion prefixes.
+   * An empty string or whitespace disables suggestion handling.
+   * @default ":"
+   */
   suggestionPrefix: string;
   /**
-  * Disable suggestion handling. The suggestions prefixes will be treated as normal characters.
-  * This will override the `suggestionPrefix` setting.
-  * @default false
-  */
+   * Disable suggestion handling. The suggestions prefixes will be treated as normal characters.
+   * This will override the `suggestionPrefix` setting.
+   * @default false
+   */
   disableSuggestionHandling: boolean;
   /**
-  * If true, all words will be made forbidden words unless they are already marked as forbidden,
-  * in that case they will be made normal words.
-  * @default false
-  */
+   * If true, all words will be made forbidden words unless they are already marked as forbidden,
+   * in that case they will be made normal words.
+   * @default false
+   */
   makeWordsForbidden?: boolean;
   /**
-  * Optimize the trie for size by merging duplicate sub-tries and using a String Table.
-  * @default false
-  */
+   * Optimize the trie for size by merging duplicate sub-tries and using a String Table.
+   * @default false
+   */
   optimize?: boolean;
   /**
-  * Use a string table to reduce memory usage.
-  * @default false
-  */
+   * Use a string table to reduce memory usage.
+   * @default false
+   */
   useStringTable?: boolean;
   /**
-  * The number of lines to batch before sorting.
-  * Set to 0 to disable sorting.
-  * @default 0
-  */
+   * The number of lines to batch before sorting.
+   * Set to 0 to disable sorting.
+   * @default 0
+   */
   sortBatchSize?: number;
 }
 /**
-* Normalizes a dictionary words based upon prefix / suffixes.
-* Case insensitive versions are also generated.
-* @param options - defines prefixes used when parsing lines.
-* @returns words that have been normalized.
-*/
+ * Normalizes a dictionary words based upon prefix / suffixes.
+ * Case insensitive versions are also generated.
+ * @param options - defines prefixes used when parsing lines.
+ * @returns words that have been normalized.
+ */
 declare function createDictionaryLineParserMapper(options?: Partial<ParseDictionaryOptions>): OperatorSync<string>;
 /**
-* Normalizes a dictionary words based upon prefix / suffixes.
-* Case insensitive versions are also generated.
-* @param lines - one word per line
-* @param _options - defines prefixes used when parsing lines.
-* @returns words that have been normalized.
-*/
+ * Normalizes a dictionary words based upon prefix / suffixes.
+ * Case insensitive versions are also generated.
+ * @param lines - one word per line
+ * @param _options - defines prefixes used when parsing lines.
+ * @returns words that have been normalized.
+ */
 declare function parseDictionaryLines(lines: Iterable<string> | string, options?: Partial<ParseDictionaryOptions>): Iterable<string>;
 declare function parseDictionaryLegacy(text: string | string[], options?: Partial<ParseDictionaryOptions>): Trie;
 declare function parseDictionary(text: string | Iterable<string>, options?: Partial<ParseDictionaryOptions>): ITrie;
@@ -821,12 +820,12 @@ declare function parseDictionary(text: string | Iterable<string>, options?: Part
 declare function decodeTrie(raw: string | ArrayBufferView<ArrayBuffer> | Uint8Array<ArrayBuffer>): ITrie;
 interface FileResource {
   /**
-  * The URL of the File
-  */
+   * The URL of the File
+   */
   readonly url: URL;
   /**
-  * The contents of the file
-  */
+   * The contents of the file
+   */
   readonly content: string | Uint8Array<ArrayBuffer>;
 }
 declare function decodeFile(file: FileResource, options?: Partial<ParseDictionaryOptions>): Promise<ITrie>;
@@ -839,30 +838,30 @@ declare class GTrieNode<K, V> {
   constructor(value?: V, children?: Map<K, GTrieNode<K, V>>);
 }
 /**
-* ### Generic Tries
-*
-* This is a Trie class that can contain any data. It is used in optimizing the dictionary and storing lookup data.
-* The performance is "good enough" for most uses, but may need to be optimized for large data sets.
-*
-* K - Key type
-* V - Value type
-*/
+ * ### Generic Tries
+ *
+ * This is a Trie class that can contain any data. It is used in optimizing the dictionary and storing lookup data.
+ * The performance is "good enough" for most uses, but may need to be optimized for large data sets.
+ *
+ * K - Key type
+ * V - Value type
+ */
 declare class GTrie<K, V> {
   root: GTrieNode<K, V>;
   constructor();
   /**
-  *
-  * @param keys - the path to the child node
-  * @param value - the value to set / insert
-  * @return the previous value if one existed
-  */
+   *
+   * @param keys - the path to the child node
+   * @param value - the value to set / insert
+   * @return the previous value if one existed
+   */
   insert(keys: Iterable<K>, value: V): V | undefined;
   /**
-  * Insert nodes for the given keys into the trie.
-  * Existing nodes are reused.
-  * @param keys
-  * @returns the final node inserted or found
-  */
+   * Insert nodes for the given keys into the trie.
+   * Existing nodes are reused.
+   * @param keys
+   * @returns the final node inserted or found
+   */
   insertNode(keys: Iterable<K>): GTrieNode<K, V>;
   findNode(keys: Iterable<K>): GTrieNode<K, V> | undefined;
   has(keys: Iterable<K>): boolean;
@@ -879,11 +878,11 @@ interface ExportOptions {
   addLineBreaksToImproveDiffs?: boolean;
 }
 /**
-* Serialize a TrieNode.
-* Note: This is destructive.  The node will no longer be usable.
-* Even though it is possible to preserve the trie, dealing with very large tries can consume a lot of memory.
-* Considering this is the last step before exporting, it was decided to let this be destructive.
-*/
+ * Serialize a TrieNode.
+ * Note: This is destructive.  The node will no longer be usable.
+ * Even though it is possible to preserve the trie, dealing with very large tries can consume a lot of memory.
+ * Considering this is the last step before exporting, it was decided to let this be destructive.
+ */
 declare function serializeTrie(root: TrieRoot, options?: ExportOptions | number): Iterable<string>;
 declare function importTrie(input: Iterable<string> | IterableIterator<string> | string[] | string): TrieRoot;
 //#endregion
@@ -899,17 +898,17 @@ declare function encodeTrieDataToBTrie(data: TrieData, buildOptions?: BuildOptio
 //#endregion
 //#region src/lib/TrieBuilder.d.ts
 /**
-* Builds an optimized Trie from a Iterable<string>. It attempts to reduce the size of the trie
-* by finding common endings.
-* @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
-* @param trieOptions options for the Trie
-*/
+ * Builds an optimized Trie from a Iterable<string>. It attempts to reduce the size of the trie
+ * by finding common endings.
+ * @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
+ * @param trieOptions options for the Trie
+ */
 declare function buildTrie(words: Iterable<string>, trieOptions?: PartialTrieOptions): Trie;
 /**
-* Builds a Trie from a Iterable<string>. NO attempt a reducing the size of the Trie is done.
-* @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
-* @param trieOptions options for the Trie
-*/
+ * Builds a Trie from a Iterable<string>. NO attempt a reducing the size of the Trie is done.
+ * @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
+ * @param trieOptions options for the Trie
+ */
 declare function buildTrieFast(words: Iterable<string>, trieOptions?: PartialTrieOptions): Trie;
 declare class TrieBuilder {
   #private;
@@ -930,8 +929,8 @@ declare class TrieBuilder {
   insertWord(word: string): void;
   insert(words: Iterable<string>): void;
   /**
-  * Resets the builder
-  */
+   * Resets the builder
+   */
   reset(): void;
   build(consolidateSuffixes?: boolean): Trie;
 }
@@ -940,17 +939,17 @@ declare class TrieBuilder {
 declare function insert(word: string, root?: TrieNode): TrieNode;
 declare function isWordTerminationNode(node: TrieNode): boolean;
 /**
-* Sorts the nodes in a trie in place.
-*/
+ * Sorts the nodes in a trie in place.
+ */
 declare function orderTrie(node: TrieNode): void;
 /**
-* Generator an iterator that will walk the Trie parent then children in a depth first fashion that preserves sorted order.
-*/
+ * Generator an iterator that will walk the Trie parent then children in a depth first fashion that preserves sorted order.
+ */
 declare function walk(node: TrieNode): Iterable<YieldResult>;
 declare const iterateTrie: typeof walk;
 /**
-* Generate a Iterator that can walk a Trie and yield the words.
-*/
+ * Generate a Iterator that can walk a Trie and yield the words.
+ */
 declare function iteratorTrieWords(node: TrieNode): Iterable<string>;
 declare function createTrieRoot(options?: PartialTrieInfoRO): TrieRoot;
 declare function createTrieRootFromList(words: Iterable<string>, options?: PartialTrieInfo): TrieRoot;
@@ -966,12 +965,12 @@ declare function isDefined<T>(t: T | undefined): t is T;
 //#endregion
 //#region src/lib/utils/mergeDefaults.d.ts
 /**
-* Creates a new object of type T based upon the field values from `value`.
-* n[k] = value[k] ?? default[k] where k must be a field in default.
-* Note: it will remove fields not in defaultValue!
-* @param value
-* @param defaultValue
-*/
+ * Creates a new object of type T based upon the field values from `value`.
+ * n[k] = value[k] ?? default[k] where k must be a field in default.
+ * Note: it will remove fields not in defaultValue!
+ * @param value
+ * @param defaultValue
+ */
 declare function mergeDefaults<T extends object>(value: Readonly<PartialWithUndefined<T>> | undefined, defaultValue: T): T;
 //#endregion
 //#region src/lib/utils/mergeOptionalWithDefaults.d.ts
@@ -981,38 +980,38 @@ declare function mergeOptionalWithDefaults(options: ROPartialTrieOptions, ...mor
 //#endregion
 //#region src/lib/utils/normalizeWord.d.ts
 /**
-* Normalize word unicode.
-* @param text - text to normalize
-* @returns returns a word normalized to `NFC`
-*/
+ * Normalize word unicode.
+ * @param text - text to normalize
+ * @returns returns a word normalized to `NFC`
+ */
 declare const normalizeWord: (text: string) => string;
 /**
-* converts text to lower case and removes any accents.
-* @param text - text to convert
-* @returns lowercase word without accents
-* @deprecated true
-*/
+ * converts text to lower case and removes any accents.
+ * @param text - text to convert
+ * @returns lowercase word without accents
+ * @deprecated true
+ */
 declare const normalizeWordToLowercase: (text: string) => string;
 /**
-* generate case insensitive forms of a word
-* @param text - text to convert
-* @returns the forms of the word.
-*/
+ * generate case insensitive forms of a word
+ * @param text - text to convert
+ * @returns the forms of the word.
+ */
 declare const normalizeWordForCaseInsensitive: (text: string) => string[];
 //#endregion
 //#region src/lib/utils/text.d.ts
 /**
-* Expand a line into a set of characters.
-*
-* Example:
-* - `a-c` -> `<a,b,c>`
-* - `ac-` -> `<a,c,->`
-* - `-abz` -> `<-,a,b,z>`
-* - `\u0300-\u0308` -> `<accents>`
-*
-* @param line - set of characters
-* @param rangeChar - the character to indicate ranges, set to empty to not have ranges.
-*/
+ * Expand a line into a set of characters.
+ *
+ * Example:
+ * - `a-c` -> `<a,b,c>`
+ * - `ac-` -> `<a,c,->`
+ * - `-abz` -> `<-,a,b,z>`
+ * - `\u0300-\u0308` -> `<accents>`
+ *
+ * @param line - set of characters
+ * @param rangeChar - the character to indicate ranges, set to empty to not have ranges.
+ */
 declare function expandCharacterSet(line: string, rangeChar?: string): Set<string>;
 //#endregion
 export { CASE_INSENSITIVE_PREFIX, COMPOUND_FIX, type ChildMap, CompoundWordsMethod, type ExportOptions, FLAG_WORD, FORBID_PREFIX, type FindFullResult, type FindWordOptions, GTrie, GTrieNode, type HintedWalkerIterator, type Hinting, type ITrie, JOIN_SEPARATOR, type MaxCost, OPTIONAL_COMPOUND_FIX, type PartialTrieOptions, type SuggestionCollector, type SuggestionCostMapDef, type SuggestionResult, Trie, TrieBuilder, type TrieNode, type TrieOptions, type TrieOptionsRO, type TrieRoot, WORD_SEPARATOR, type WalkerIterator, type WeightMap, type YieldResult, buildITrieFromWords, buildTrie, buildTrieFast, consolidate, convertToBTrie, countNodes, countWords, createDictionaryLineParserMapper as createDictionaryLineParser, createTrieRoot, createTrieRootFromList, createWeightedMap, decodeFile, decodeTrie, defaultTrieInfo, defaultTrieInfo as defaultTrieOptions, editDistance, editDistanceWeighted, encodeITrieToBTrie, encodeTrieDataToBTrie, expandCharacterSet, findNode, has, hintedWalker, impersonateCollector, importTrie, insert, isCircular, isDefined, isWordTerminationNode, iterateTrie, iteratorTrieWords, mapDictionaryInformationToWeightMap, mergeDefaults, mergeOptionalWithDefaults, normalizeWord, normalizeWordForCaseInsensitive, normalizeWordToLowercase, orderTrie, parseDictionary, parseDictionaryLegacy, parseDictionaryLines, serializeTrie, suggestionCollector, trieNodeToRoot, walk, walker };