cspell-dictionary 9.3.2 → 9.6.0

package/dist/SpellingDictionary/CachingDictionary.d.ts

@@ -1,3 +1,4 @@
+import type { SuggestionResult } from 'cspell-trie-lib';
 import type { CacheStats } from '../util/AutoCache.js';
 import type { PreferredSuggestion, SearchOptions, SpellingDictionary } from './SpellingDictionary.js';
 import type { SpellingDictionaryCollection } from './SpellingDictionaryCollection.js';
@@ -21,7 +22,7 @@ export interface CachingDictionary {
     isForbidden(word: string): boolean;
     stats(): CallStats;
     getPreferredSuggestions(word: string): PreferredSuggestion[] | undefined;
-    suggest(word: string, suggestOptions?: SuggestOptionsRO): import('cspell-trie-lib').SuggestionResult[];
+    suggest(word: string, suggestOptions?: SuggestOptionsRO): SuggestionResult[];
 }
 interface LogEntryBase extends SearchOptions {
     time: number;
@@ -32,6 +33,7 @@ interface LogEntryBase extends SearchOptions {
 interface LogEntryHas extends LogEntryBase {
     method: 'has';
     value: boolean;
+    miss: boolean;
 }
 export type LogEntry = LogEntryHas;
 /**
@@ -41,7 +43,23 @@ export type LogEntry = LogEntryHas;
  * @returns CachingDictionary
  */
 export declare function createCachingDictionary(dict: SpellingDictionary | SpellingDictionaryCollection, options: SearchOptions): CachingDictionary;
-export declare function enableLogging(enabled?: boolean): void;
-export declare function getLog(): LogEntryBase[];
+/**
+ * Enable or disable logging of dictionary requests. Every call to `has` will be logged.
+ *
+ * This should be set prior to creating any caching dictionaries to ensure all requests are logged.
+ *
+ * @param enabled - optional - if undefined, it will toggle the setting.
+ * @returns the current state of logging.
+ */
+export declare function dictionaryCacheEnableLogging(enabled?: boolean): boolean;
+/**
+ * Get the log of dictionary requests.
+ * @returns the log
+ */
+export declare function dictionaryCacheGetLog(): readonly Readonly<LogEntryBase>[];
+/**
+ * Clear the log of dictionary requests.
+ */
+export declare function dictionaryCacheClearLog(): void;
 export {};
 //# sourceMappingURL=CachingDictionary.d.ts.map

package/dist/SpellingDictionary/CachingDictionary.js

@@ -19,8 +19,12 @@ class CachedDict {
         const has = autoCache((word) => this.dict.has(word, this.options), DefaultAutoCacheSize);
         const hasAndLog = (word) => {
             const time = performance.now() - startTime;
+            const misses = has.misses;
             const value = has(word);
-            log.push({ time, method: 'has', word, value });
+            if (logRequests) {
+                const miss = has.misses > misses;
+                log.push({ time, method: 'has', word, value, miss });
+            }
             return value;
         };
         this.#has = has;
@@ -63,10 +67,32 @@ export function createCachingDictionary(dict, options) {
     knownOptions.set(dict, cached);
     return cached;
 }
-export function enableLogging(enabled = !logRequests) {
+/**
+ * Enable or disable logging of dictionary requests. Every call to `has` will be logged.
+ *
+ * This should be set prior to creating any caching dictionaries to ensure all requests are logged.
+ *
+ * @param enabled - optional - if undefined, it will toggle the setting.
+ * @returns the current state of logging.
+ */
+export function dictionaryCacheEnableLogging(enabled = !logRequests) {
+    if (enabled && !logRequests) {
+        knownDicts.clear();
+    }
     logRequests = enabled;
+    return logRequests;
 }
-export function getLog() {
+/**
+ * Get the log of dictionary requests.
+ * @returns the log
+ */
+export function dictionaryCacheGetLog() {
     return log;
 }
+/**
+ * Clear the log of dictionary requests.
+ */
+export function dictionaryCacheClearLog() {
+    log.length = 0;
+}
 //# sourceMappingURL=CachingDictionary.js.map

package/dist/SpellingDictionary/FlagWordsDictionary.d.ts

@@ -1,4 +1,59 @@
-import type { SpellingDictionary } from './SpellingDictionary.js';
+import type { CompoundWordsMethod, ITrie, SuggestionResult } from 'cspell-trie-lib';
+import type { FindResult, HasOptions, IgnoreCaseOption, PreferredSuggestion, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary.js';
+import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.js';
+import type { SuggestOptions } from './SuggestOptions.js';
+import type { TyposDictionary } from './TyposDictionary.js';
+export declare class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
+    readonly name: string;
+    readonly source: string;
+    readonly containsNoSuggestWords = false;
+    readonly options: SpellingDictionaryOptions;
+    constructor(trie: ITrie, name: string, source: string);
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param _word - the word
+     * @param _options - options
+     * @returns always false
+     */
+    has(_word: string, _options?: HasOptions): boolean;
+    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    genSuggestions(): void;
+    readonly isDictionaryCaseSensitive: boolean;
+    terms(): Iterable<string>;
+}
+export declare class FlagWordsDictionary implements SpellingDictionary {
+    readonly name: string;
+    readonly source: string;
+    private dictTypos;
+    private dictTrie;
+    readonly containsNoSuggestWords = false;
+    readonly options: SpellingDictionaryOptions;
+    readonly type = "flag-words";
+    readonly mapWord: undefined;
+    constructor(name: string, source: string, dictTypos: TyposDictionary, dictTrie: FlagWordsDictionaryTrie | undefined);
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param word - the word
+     * @param options - options
+     * @returns always false
+     */
+    has(word: string, options?: HasOptions): boolean;
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word: string, options?: HasOptions): FindResult | undefined;
+    isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+    isNoSuggestWord(word: string, options: HasOptions): boolean;
+    suggest(word: string, suggestOptions?: SuggestOptions): SuggestionResult[];
+    getPreferredSuggestions(word: string): PreferredSuggestion[];
+    genSuggestions(): void;
+    get size(): number;
+    readonly isDictionaryCaseSensitive: boolean;
+    getErrors?(): Error[];
+    terms(): Iterable<string>;
+}
 /**
  * Create a dictionary where all words are to be forbidden.
  * @param wordList - list of words

package/dist/SpellingDictionary/FlagWordsDictionary.js

@@ -1,11 +1,10 @@
-import { opMap, pipe } from '@cspell/cspell-pipe/sync';
-import { buildITrieFromWords, parseDictionaryLines } from 'cspell-trie-lib';
+import { parseDictionary, parseDictionaryLines } from 'cspell-trie-lib';
 import { createAutoResolveWeakCache } from '../util/AutoResolve.js';
 import * as Defaults from './defaults.js';
 import { defaultOptions } from './SpellingDictionary.js';
 import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.js';
 import { createTyposDictionary } from './TyposDictionary.js';
-class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
+export class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
     name;
     source;
     containsNoSuggestWords = false;
@@ -38,8 +37,11 @@ class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
         return;
     }
     isDictionaryCaseSensitive = true;
+    terms() {
+        return this.trie.words();
+    }
 }
-class FlagWordsDictionary {
+export class FlagWordsDictionary {
     name;
     source;
     dictTypos;
@@ -47,6 +49,7 @@ class FlagWordsDictionary {
     containsNoSuggestWords = false;
     options = {};
     type = 'flag-words';
+    mapWord = undefined;
     constructor(name, source, dictTypos, dictTrie) {
         this.name = name;
         this.source = source;
@@ -89,9 +92,6 @@ class FlagWordsDictionary {
     genSuggestions() {
         return;
     }
-    mapWord(word) {
-        return word;
-    }
     get size() {
         return this.dictTypos.size + (this.dictTrie?.size || 0);
     }
@@ -99,6 +99,13 @@ class FlagWordsDictionary {
     getErrors() {
         return [];
     }
+    *terms() {
+        if (this.dictTrie) {
+            yield* this.dictTrie.terms();
+            return;
+        }
+        return;
+    }
 }
 const createCache = createAutoResolveWeakCache();
 /**
@@ -113,18 +120,14 @@ export function createFlagWordsDictionary(wordList, name, source) {
     return createCache.get(wordList, () => {
         const testSpecialCharacters = /[~*+]/;
         const { t: specialWords, f: typoWords } = bisect(parseDictionaryLines(wordList, { stripCaseAndAccents: false }), (line) => testSpecialCharacters.test(line));
-        const trieDict = specialWords.size ? buildTrieDict(specialWords, name, source) : undefined;
+        const trie = parseDictionary(specialWords, { stripCaseAndAccents: false, makeWordsForbidden: true });
+        const trieDict = new FlagWordsDictionaryTrie(trie, name, source);
         const typosDict = createTyposDictionary(typoWords, name, source);
-        if (!trieDict)
+        if (!specialWords.size)
             return typosDict;
         return new FlagWordsDictionary(name, source, typosDict, trieDict);
     });
 }
-const regExpCleanIgnore = /^(!!)+/;
-function buildTrieDict(words, name, source) {
-    const trie = buildITrieFromWords(pipe(words, opMap((w) => '!' + w), opMap((w) => w.replace(regExpCleanIgnore, ''))));
-    return new FlagWordsDictionaryTrie(trie, name, source);
-}
 function bisect(values, predicate) {
     const t = new Set();
     const f = new Set();

package/dist/SpellingDictionary/IgnoreWordsDictionary.js

@@ -12,6 +12,7 @@ class IgnoreWordsDictionary {
     containsNoSuggestWords = true;
     options = {};
     type = 'ignore';
+    mapWord = undefined;
     constructor(name, source, words) {
         this.name = name;
         this.source = source;
@@ -62,9 +63,6 @@ class IgnoreWordsDictionary {
     genSuggestions() {
         return;
     }
-    mapWord(word) {
-        return word;
-    }
     get size() {
         return this.dict.size;
     }

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -15,7 +15,12 @@ export interface SearchOptions {
     ignoreCase?: boolean | undefined;
 }
 export type SearchOptionsRO = Readonly<SearchOptions>;
-export type FindOptions = SearchOptions;
+export interface FindOptions extends SearchOptions {
+    /**
+     * Separate compound words using the specified separator.
+     */
+    compoundSeparator?: string | undefined;
+}
 export type FindOptionsRO = Readonly<FindOptions>;
 export interface Suggestion {
     word: string;
@@ -86,12 +91,14 @@ export interface DictionaryInfo {
     /** Options */
     readonly options: SpellingDictionaryOptions;
 }
+export type MapWordSingleFn = (word: string) => string;
+export type MapWordMultipleFn = (word: string) => string[];
 export interface SpellingDictionary extends DictionaryInfo {
     readonly type: string;
     readonly containsNoSuggestWords: boolean;
     has(word: string, options?: HasOptionsRO): boolean;
     /** A more detailed search for a word, might take longer than `has` */
-    find(word: string, options?: SearchOptionsRO): FindResult | undefined;
+    find(word: string, options?: FindOptionsRO): FindResult | undefined;
     /**
      * Checks if a word is forbidden.
      * @param word - word to check.
@@ -113,17 +120,32 @@ export interface SpellingDictionary extends DictionaryInfo {
     suggest(word: string, suggestOptions?: SuggestOptionsRO): SuggestionResult[];
     getPreferredSuggestions?: (word: string) => PreferredSuggestion[];
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptionsRO): void;
-    mapWord(word: string): string;
+    mapWord?: MapWordSingleFn | undefined;
     /**
      * Generates all possible word combinations by applying `repMap`.
      * This acts a bit like brace expansions in globs.
      * @param word - the word to map
      * @returns array of adjusted words.
      */
-    remapWord?: (word: string) => string[];
+    remapWord?: MapWordMultipleFn | undefined;
     readonly size: number;
     readonly isDictionaryCaseSensitive: boolean;
     getErrors?(): Error[];
+    /**
+     * Get all the terms in the dictionary, they may be formatted according to the dictionary options.
+     * @returns the terms in the dictionary.
+     */
+    terms?: () => Iterable<string>;
+}
+export interface SuggestDictionary extends SpellingDictionary {
+    getPreferredSuggestions: (word: string) => PreferredSuggestion[];
+    /**
+     * Determine if the word can appear in a list of suggestions.
+     * @param word - word
+     * @param ignoreCaseAndAccents - ignore case.
+     * @returns true if a word is suggested, otherwise false.
+     */
+    isSuggestedWord(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
 }
 export declare const defaultOptions: SpellingDictionaryOptions;
 //# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -2,14 +2,11 @@ import { CASE_INSENSITIVE_PREFIX, CompoundWordsMethod } from 'cspell-trie-lib';
 import { isDefined } from '../util/util.js';
 import * as Defaults from './defaults.js';
 import { defaultNumSuggestions, hasOptionToSearchOption, suggestionCollector } from './SpellingDictionaryMethods.js';
-function identityString(w) {
-    return w;
-}
 class SpellingDictionaryCollectionImpl {
     dictionaries;
     name;
     options = { weightMap: undefined };
-    mapWord = identityString;
+    mapWord = undefined;
     type = 'SpellingDictionaryCollection';
     source;
     isDictionaryCaseSensitive;

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -1,6 +1,6 @@
-import type { Buffer } from 'node:buffer';
 import type { ITrie, SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
-import type { FindResult, HasOptionsRO, SpellingDictionary, SpellingDictionaryOptionsRO } from './SpellingDictionary.js';
+import type { RepMapper } from '../util/repMap.js';
+import type { FindOptionsRO, FindResult, HasOptionsRO, MapWordMultipleFn, MapWordSingleFn, PreferredSuggestion, SpellingDictionary, SpellingDictionaryOptionsRO } from './SpellingDictionary.js';
 import type { SuggestOptions } from './SuggestOptions.js';
 export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     #private;
@@ -11,8 +11,9 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     private _size;
     readonly knownWords: Set<string>;
     readonly unknownWords: Set<string>;
-    readonly mapWord: (word: string) => string;
-    readonly remapWord: (word: string) => string[];
+    readonly mapWord: MapWordSingleFn | undefined;
+    readonly remapWord: MapWordMultipleFn | undefined;
+    readonly repMapper: RepMapper | undefined;
     readonly type = "SpellingDictionaryFromTrie";
     readonly isDictionaryCaseSensitive: boolean;
     readonly containsNoSuggestWords: boolean;
@@ -20,7 +21,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     constructor(trie: ITrie, name: string, options: SpellingDictionaryOptionsRO, source?: string, size?: number);
     get size(): number;
     has(word: string, hasOptions?: HasOptionsRO): boolean;
-    find(word: string, hasOptions?: HasOptionsRO): FindResult | undefined;
+    find(word: string, hasOptions?: FindOptionsRO): FindResult | undefined;
     private resolveOptions;
     private _find;
     private findAnyForm;
@@ -30,6 +31,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     suggest(word: string, suggestOptions?: SuggestOptions): SuggestionResult[];
     private _suggest;
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    getPreferredSuggestions(word: string): PreferredSuggestion[];
     getErrors(): Error[];
 }
 /**
@@ -40,8 +42,8 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
  * @param options - options.
  * @returns SpellingDictionary
  */
-export declare function createSpellingDictionaryFromTrieFile(data: string | Buffer, name: string, source: string, options: SpellingDictionaryOptionsRO): SpellingDictionary;
-declare function outerWordForms(word: string, mapWord: (word: string) => string[]): Iterable<string>;
+export declare function createSpellingDictionaryFromTrieFile(data: string | Uint8Array<ArrayBuffer>, name: string, source: string, options: SpellingDictionaryOptionsRO): SpellingDictionary;
+declare function outerWordForms(word: string, repMapper: RepMapper | undefined): Iterable<string>;
 export declare const __testing__: {
     outerWordForms: typeof outerWordForms;
 };

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -1,5 +1,6 @@
 import { CompoundWordsMethod, decodeTrie, suggestionCollector } from 'cspell-trie-lib';
 import { clean } from '../util/clean.js';
+import { measurePerf } from '../util/performance.js';
 import { createMapper, createRepMapper } from '../util/repMap.js';
 import * as Defaults from './defaults.js';
 import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOptionToSearchOption, impersonateCollector, wordSearchForms, wordSuggestForms, } from './SpellingDictionaryMethods.js';
@@ -13,6 +14,7 @@ export class SpellingDictionaryFromTrie {
     unknownWords = new Set();
     mapWord;
     remapWord;
+    repMapper;
     type = 'SpellingDictionaryFromTrie';
     isDictionaryCaseSensitive;
     containsNoSuggestWords;
@@ -25,9 +27,12 @@ export class SpellingDictionaryFromTrie {
         this.name = name;
         this.options = options;
         this.source = source;
-        this.mapWord = createMapper(options.repMap, options.dictionaryInformation?.ignore);
-        this.remapWord = createRepMapper(options.repMap, options.dictionaryInformation?.ignore);
-        this.isDictionaryCaseSensitive = options.caseSensitive ?? trie.isCaseAware;
+        const mapWord = createMapper(options.repMap, options.dictionaryInformation?.ignore);
+        const repMapper = createRepMapper(options.repMap, options.dictionaryInformation?.ignore);
+        this.mapWord = mapWord?.fn;
+        this.remapWord = repMapper?.fn;
+        this.repMapper = repMapper;
+        this.isDictionaryCaseSensitive = options.caseSensitive ?? true;
         this.containsNoSuggestWords = options.noSuggest || false;
         this._size = size || 0;
         this.weightMap = options.weightMap || createWeightMapFromDictionaryInformation(options.dictionaryInformation);
@@ -55,12 +60,12 @@ export class SpellingDictionaryFromTrie {
     }
     has(word, hasOptions) {
         const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
-        const r = this._find(word, useCompounds, ignoreCase);
+        const r = this._find(word, useCompounds, ignoreCase, undefined);
         return (r && !r.forbidden && !!r.found) || false;
     }
     find(word, hasOptions) {
         const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
-        const r = this._find(word, useCompounds, ignoreCase);
+        const r = this._find(word, useCompounds, ignoreCase, hasOptions?.compoundSeparator);
         const { forbidden = this.#isForbidden(word) } = r || {};
         if (this.#ignoreForbiddenWords && forbidden) {
             return undefined;
@@ -75,20 +80,23 @@ export class SpellingDictionaryFromTrie {
         const { useCompounds = this.options.useCompounds, ignoreCase = Defaults.ignoreCase } = hasOptionToSearchOption(hasOptions);
         return { useCompounds, ignoreCase };
     }
-    _find = (word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase);
-    findAnyForm(word, useCompounds, ignoreCase) {
-        const outerForms = outerWordForms(word, this.remapWord || ((word) => [this.mapWord(word)]));
+    _find = (word, useCompounds, ignoreCase, compoundSeparator) => this.findAnyForm(word, useCompounds, ignoreCase, compoundSeparator);
+    findAnyForm(word, useCompounds, ignoreCase, compoundSeparator) {
+        const outerForms = outerWordForms(word, this.repMapper);
         for (const form of outerForms) {
-            const r = this._findAnyForm(form, useCompounds, ignoreCase);
+            const r = this._findAnyForm(form, useCompounds, ignoreCase, compoundSeparator);
             if (r)
                 return r;
         }
         return undefined;
     }
-    _findAnyForm(mWord, useCompounds, ignoreCase) {
-        const opts = ignoreCase
+    _findAnyForm(mWord, useCompounds, ignoreCase, compoundSeparator) {
+        let opts = ignoreCase
             ? this.#findWordOptionsNotCaseSensitive
             : this.#findWordOptionsCaseSensitive;
+        if (compoundSeparator) {
+            opts = { ...opts, compoundSeparator };
+        }
         const findResult = this.trie.findWord(mWord, opts);
         if (findResult.found !== false) {
             return findResult;
@@ -149,6 +157,12 @@ export class SpellingDictionaryFromTrie {
             this.trie.genSuggestions(impersonateCollector(collector, w), _compoundMethod);
         }
     }
+    getPreferredSuggestions(word) {
+        if (!this.trie.hasPreferredSuggestions)
+            return [];
+        const sugs = [...this.trie.getPreferredSuggestions(word)];
+        return sugs.map((sug, i) => ({ word: sug, cost: i + 1, isPreferred: true }));
+    }
     getErrors() {
         return [];
     }
@@ -162,25 +176,49 @@ export class SpellingDictionaryFromTrie {
  * @returns SpellingDictionary
  */
 export function createSpellingDictionaryFromTrieFile(data, name, source, options) {
+    const endPerf = measurePerf('createSpellingDictionaryFromTrieFile');
     const trie = decodeTrie(data);
-    return new SpellingDictionaryFromTrie(trie, name, options, source);
+    const d = new SpellingDictionaryFromTrie(trie, name, options, source);
+    endPerf();
+    return d;
 }
-function* outerWordForms(word, mapWord) {
+// eslint-disable-next-line no-control-regex
+const isAsciiRange = /^[\u0000-\u007F]*$/;
+function* outerWordForms(word, repMapper) {
     // Only generate the needed forms.
     const sent = new Set();
     let w = word;
     const ww = w;
     yield w;
-    sent.add(w);
-    w = word.normalize('NFC');
-    if (w !== ww) {
-        yield w;
+    // this function is called for every word lookup, so needs to be efficient.
+    // Check to see if it is a pure ascii word.
+    if (!isAsciiRange.test(w)) {
         sent.add(w);
+        w = word.normalize('NFC');
+        if (w !== ww) {
+            yield w;
+            sent.add(w);
+        }
+        w = word.normalize('NFD');
+        if (w !== ww && !sent.has(w)) {
+            yield w;
+            sent.add(w);
+        }
     }
-    w = word.normalize('NFD');
-    if (w !== ww && !sent.has(w)) {
-        yield w;
-        sent.add(w);
+    if (!repMapper)
+        return;
+    const mapWord = repMapper.fn;
+    // nothing was added to the set, just do the map.
+    if (!sent.size) {
+        if (!repMapper.test.test(ww))
+            return;
+        for (const m of mapWord(ww)) {
+            if (m !== ww && !sent.has(m)) {
+                yield m;
+                sent.add(m);
+            }
+        }
+        return;
     }
     for (const f of sent) {
         for (const m of mapWord(f)) {

package/dist/SpellingDictionary/SuggestDictionary.d.ts

@@ -1,14 +1,8 @@
-import type { IgnoreCaseOption, PreferredSuggestion, SpellingDictionary } from './SpellingDictionary.js';
+import type { SuggestionResult } from 'cspell-trie-lib';
+import type { SuggestDictionary } from './SpellingDictionary.js';
 import { type TypoEntry, type TyposDef } from './Typos/index.js';
-export interface SuggestDictionary extends SpellingDictionary {
-    getPreferredSuggestions: (word: string) => PreferredSuggestion[];
-    /**
-     * Determine if the word can appear in a list of suggestions.
-     * @param word - word
-     * @param ignoreCaseAndAccents - ignore case.
-     * @returns true if a word is suggested, otherwise false.
-     */
-    isSuggestedWord(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+export interface PreferredSuggestionResult extends SuggestionResult {
+    isPreferred: true;
 }
 /**
  * Create a dictionary where all words are to be forbidden.

package/dist/SpellingDictionary/SuggestDictionary.js

@@ -12,6 +12,7 @@ class SuggestDictionaryImpl {
     options = {};
     type = 'suggest';
     size;
+    mapWord = undefined;
     /**
      * Note: ignoreWordsLower is only suggestions with the case and accents removed.
      * The logic is that if someone explicity ignored an upper case version, it does not
@@ -89,9 +90,6 @@ class SuggestDictionaryImpl {
         const sugs = this.suggest(collector.word);
         sugs.forEach((result) => collector.add(result));
     }
-    mapWord(word) {
-        return word;
-    }
     isDictionaryCaseSensitive = true;
     getErrors() {
         return [];

package/dist/SpellingDictionary/Typos/typosParser.d.ts

@@ -1,4 +1,5 @@
 import type { TypoEntry, TyposDef } from './typos.js';
+export declare function isSuggestion(v: string): boolean;
 export declare function createTyposDefFromEntries(entries: Iterable<TypoEntry>): TyposDef;
 export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string, unknown> | unknown): TyposDef | undefined;
 /**

package/dist/SpellingDictionary/Typos/typosParser.js

@@ -1,13 +1,16 @@
-import assert from 'node:assert';
-import { appendToDef, createTyposDef } from './util.js';
+import { appendToDef, assert, createTyposDef } from './util.js';
 function assertString(v) {
     assert(typeof v === 'string', 'A string was expected.');
     return true;
 }
 const suggestionsSeparator = /[,]/;
-const typoSuggestionsSeparator = /:|->/;
+// const typoSuggestionsSeparator = /:|->/;
 const typoEntrySeparator = /[\n;]/;
 const inlineComment = /#.*/gm;
+const sugFormatRegex = /^\s*(?:[!~:])*(?<word>.*?)(?<separator>(->|:([0-9a-f]{1,2}:)?))(?<sugs>.*)$/;
+export function isSuggestion(v) {
+    return sugFormatRegex.test(v);
+}
 export function createTyposDefFromEntries(entries) {
     const def = Object.create(null);
     for (const entry of entries) {
@@ -116,11 +119,33 @@ export function parseTyposLine(line) {
     }
     return sanitizeIntoTypoDef(line);
 }
+/**
+ * Split text into multiple lines
+ * @param content - text content
+ * @returns
+ */
 function splitIntoLines(content) {
     return trimAndFilter(normalize(content).split(typoEntrySeparator));
 }
+/**
+ * Split a typo entry into key and value
+ * Entry format:
+ * - `word:suggestion`
+ * - `word->suggestion`
+ * - `word: first, second, third suggestions`
+ * - sequencing values are ignored, e.g.: `:0:`, `:1:`, `:a:`
+ *   - `word:0:first`
+ *   - `word:1:second`
+ * @param line - the line of text
+ * @returns
+ */
 function splitEntry(line) {
-    return line.split(typoSuggestionsSeparator, 2);
+    // Remove any sequencing values like `:1:` or `:a:`
+    const m = line.match(sugFormatRegex);
+    if (!m?.groups) {
+        return [line.trim(), undefined];
+    }
+    return [m.groups.word.trim(), m.groups.sugs.trim()];
 }
 export function parseTyposFile(content) {
     const lines = splitIntoLines(content.replaceAll(inlineComment, ''));

package/dist/SpellingDictionary/Typos/util.d.ts

@@ -28,4 +28,5 @@ export declare function extractAllSuggestions(typosDef: TyposDef): Set<string>;
  * @returns set of ignored words with the prefix removed.
  */
 export declare function extractIgnoreValues(typosDef: TyposDef, ignorePrefix: string): Set<string>;
+export declare function assert(condition: unknown, message?: string): asserts condition;
 //# sourceMappingURL=util.d.ts.map

package/dist/SpellingDictionary/Typos/util.js

@@ -103,4 +103,9 @@ function isArray(v) {
 function hasSuggestions(v) {
     return isString(v) || isArray(v);
 }
+export function assert(condition, message = 'Assert Failed') {
+    if (condition)
+        return;
+    throw new Error(message);
+}
 //# sourceMappingURL=util.js.map

package/dist/SpellingDictionary/TyposDictionary.js

@@ -12,6 +12,7 @@ class TyposDictionaryImpl {
     options = {};
     type = 'typos';
     size;
+    mapWord = undefined;
     ignoreWords;
     /**
      * Note: ignoreWordsLower is only suggestions with the case and accents removed.
@@ -122,9 +123,6 @@ class TyposDictionaryImpl {
     getPreferredSuggestions(word) {
         return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
     }
-    mapWord(word) {
-        return word;
-    }
     isDictionaryCaseSensitive = true;
     getErrors() {
         return [];

package/dist/SpellingDictionary/createSpellingDictionary.d.ts

@@ -8,7 +8,7 @@ import type { DictionaryInfo, SpellingDictionary, SpellingDictionaryOptions } fr
  * @param options - dictionary options
  * @returns a Spelling Dictionary
  */
-export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
+export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options?: SpellingDictionaryOptions | undefined, disableSuggestionsHandling?: boolean): SpellingDictionary;
 export interface SpellingDictionaryLoadError extends Error {
     /** The Error Name */
     readonly name: string;

package/dist/SpellingDictionary/createSpellingDictionary.js

@@ -1,6 +1,7 @@
 import { fileURLToPath } from 'node:url';
 import { buildITrieFromWords, parseDictionaryLines } from 'cspell-trie-lib';
 import { deepEqual } from 'fast-equals';
+import { measurePerf } from '../util/performance.js';
 import { AutoWeakCache, SimpleCache } from '../util/simpleCache.js';
 import { defaultOptions } from './SpellingDictionary.js';
 import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.js';
@@ -16,8 +17,14 @@ const cachedParamsByWordList = new SimpleCache(64);
  * @param options - dictionary options
  * @returns a Spelling Dictionary
  */
-export function createSpellingDictionary(wordList, name, source, options) {
-    const params = [wordList, name, source.toString(), options];
+export function createSpellingDictionary(wordList, name, source, options, disableSuggestionsHandling) {
+    const params = [
+        wordList,
+        name,
+        source.toString(),
+        options,
+        disableSuggestionsHandling,
+    ];
     if (!Array.isArray(wordList)) {
         return _createSpellingDictionary(params);
     }
@@ -34,16 +41,20 @@ export function createSpellingDictionary(wordList, name, source, options) {
     return cachedDictionaries.get(params);
 }
 function _createSpellingDictionary(params) {
-    const [wordList, name, source, options] = params;
+    const n = ''; // ':' + params[1]; // Add name to perf name for easier debugging.
+    const endPerf = measurePerf('createSpellingDictionary' + n);
+    const [wordList, name, source, options, disableSuggestionHandling = false] = params;
     // console.log(`createSpellingDictionary ${name} ${source}`);
-    const parseOptions = { stripCaseAndAccents: options?.supportNonStrictSearches ?? true };
+    const parseOptions = { stripCaseAndAccents: options?.supportNonStrictSearches ?? true, disableSuggestionHandling };
     const words = parseDictionaryLines(wordList, parseOptions);
     const trie = buildITrieFromWords(words);
     const opts = { ...(options || defaultOptions) };
     if (opts.weightMap === undefined && opts.dictionaryInformation) {
         opts.weightMap = createWeightMapFromDictionaryInformation(opts.dictionaryInformation);
     }
-    return new SpellingDictionaryFromTrie(trie, name, opts, source);
+    const d = new SpellingDictionaryFromTrie(trie, name, opts, source);
+    endPerf();
+    return d;
 }
 export function createFailedToLoadDictionary(name, sourceUrl, error, options) {
     const sourceHref = typeof sourceUrl === 'string' ? sourceUrl : sourceUrl.href;
@@ -59,7 +70,7 @@ export function createFailedToLoadDictionary(name, sourceUrl, error, options) {
         isNoSuggestWord: () => false,
         isForbidden: () => false,
         suggest: () => [],
-        mapWord: (a) => a,
+        mapWord: undefined,
         genSuggestions: () => {
             return;
         },

package/dist/SpellingDictionary/index.d.ts

@@ -3,7 +3,7 @@ export { createInlineSpellingDictionary } from './createInlineSpellingDictionary
 export { createFailedToLoadDictionary, createSpellingDictionary } from './createSpellingDictionary.js';
 export { createFlagWordsDictionary, createFlagWordsDictionary as createForbiddenWordsDictionary, } from './FlagWordsDictionary.js';
 export { createIgnoreWordsDictionary } from './IgnoreWordsDictionary.js';
-export type { DictionaryDefinitionInline, FindOptions, FindResult, HasOptions, PreferredSuggestion, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, } from './SpellingDictionary.js';
+export type { DictionaryDefinitionInline, FindOptions, FindResult, HasOptions, PreferredSuggestion, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, Suggestion, } from './SpellingDictionary.js';
 export { createCollection, SpellingDictionaryCollection } from './SpellingDictionaryCollection.js';
 export { createSpellingDictionaryFromTrieFile } from './SpellingDictionaryFromTrie.js';
 export { createSuggestDictionary } from './SuggestDictionary.js';

package/dist/index.d.ts

@@ -1,11 +1,4 @@
-import { enableLogging as cacheDictionaryEnableLogging, getLog as cacheDictionaryGetLog } from './SpellingDictionary/CachingDictionary.js';
-export type { CachingDictionary, FindOptions, FindResult, HasOptions, PreferredSuggestion, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary/index.js';
+export { dictionaryCacheClearLog, dictionaryCacheEnableLogging, dictionaryCacheGetLog, } from './SpellingDictionary/CachingDictionary.js';
+export type { CachingDictionary, FindOptions, FindResult, HasOptions, PreferredSuggestion, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, Suggestion, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary/index.js';
 export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createFlagWordsDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, createSuggestDictionary, createSuggestOptions, } from './SpellingDictionary/index.js';
-/**
- * Debugging utilities.
- */
-export declare const _debug: {
-    cacheDictionaryEnableLogging: typeof cacheDictionaryEnableLogging;
-    cacheDictionaryGetLog: typeof cacheDictionaryGetLog;
-};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,10 +1,3 @@
-import { enableLogging as cacheDictionaryEnableLogging, getLog as cacheDictionaryGetLog, } from './SpellingDictionary/CachingDictionary.js';
+export { dictionaryCacheClearLog, dictionaryCacheEnableLogging, dictionaryCacheGetLog, } from './SpellingDictionary/CachingDictionary.js';
 export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createFlagWordsDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, createSuggestDictionary, createSuggestOptions, } from './SpellingDictionary/index.js';
-/**
- * Debugging utilities.
- */
-export const _debug = {
-    cacheDictionaryEnableLogging,
-    cacheDictionaryGetLog,
-};
 //# sourceMappingURL=index.js.map

package/dist/util/performance.d.ts

@@ -0,0 +1,9 @@
+export declare function measurePerfStart(name: string): void;
+export declare function measurePerfEnd(name: string): void;
+/**
+ * Creates performance marks and measures the time taken between them.
+ * @param name - name of the performance entry
+ * @returns a function to stop the timer.
+ */
+export declare function measurePerf(name: string): () => void;
+//# sourceMappingURL=performance.d.ts.map

package/dist/util/performance.js

@@ -0,0 +1,19 @@
+export function measurePerfStart(name) {
+    performance.mark(name + '-start');
+}
+export function measurePerfEnd(name) {
+    performance.mark(name + '-end');
+    performance.measure(name, name + '-start', name + '-end');
+}
+/**
+ * Creates performance marks and measures the time taken between them.
+ * @param name - name of the performance entry
+ * @returns a function to stop the timer.
+ */
+export function measurePerf(name) {
+    measurePerfStart(name);
+    return () => {
+        measurePerfEnd(name);
+    };
+}
+//# sourceMappingURL=performance.js.map

package/dist/util/repMap.d.ts

@@ -1,6 +1,9 @@
 import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
-export type ReplaceMapper = (src: string) => string;
-export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper;
+export interface ReplaceMapper {
+    test?: RegExp;
+    fn: (src: string) => string;
+}
+export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper | undefined;
 declare function charsetToRepMapRegEx(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
 declare function createMapperRegExp(repMap: ReplaceMap): RegExp;
 interface RepTrieNode {
@@ -12,7 +15,11 @@ interface Edit {
     e: number;
     r: string;
 }
-export declare function createRepMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): (word: string) => string[];
+export interface RepMapper {
+    test: RegExp;
+    fn: (word: string) => string[];
+}
+export declare function createRepMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): RepMapper | undefined;
 declare function applyEdits(word: string, edits: Edit[]): string[];
 declare function calcAllEdits(root: RepTrieNode, word: string): Edit[];
 declare function createTrie(repMap: ReplaceMap | undefined, ignoreCharset?: string): RepTrieNode;

package/dist/util/repMap.js

@@ -3,7 +3,7 @@ import { escapeRegEx } from './regexHelper.js';
 import { isDefined } from './util.js';
 export function createMapper(repMap, ignoreCharset) {
     if (!repMap && !ignoreCharset)
-        return (a) => a;
+        return undefined;
     repMap = repMap || [];
     const charsetMap = charsetToRepMapRegEx(ignoreCharset);
     if (charsetMap) {
@@ -11,7 +11,7 @@ export function createMapper(repMap, ignoreCharset) {
     }
     const filteredMap = repMap.filter(([match, _]) => !!match);
     if (!filteredMap.length) {
-        return (a) => a;
+        return undefined;
     }
     const regEx = createMapperRegExp(repMap);
     const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
@@ -19,8 +19,12 @@ export function createMapper(repMap, ignoreCharset) {
         const index = matches.findIndex((a) => !!a);
         return 0 <= index && index < values.length ? values[index] : m;
     }
-    return function (s) {
+    function fn(s) {
         return s.replace(regEx, resolve);
+    }
+    return {
+        test: regexpRemoveFlags(regEx, 'gm'),
+        fn,
     };
 }
 function charsetToRepMapRegEx(charset, replaceWith = '') {
@@ -68,13 +72,22 @@ function createMapperRegExp(repMap) {
     return regEx;
 }
 export function createRepMapper(repMap, ignoreCharset) {
-    if (!repMap && !ignoreCharset)
-        return (word) => [word];
+    if (!repMap?.length && !ignoreCharset)
+        return undefined;
+    let tRepMap = repMap || [];
+    const charsetMap = charsetToRepMapRegEx(ignoreCharset);
+    if (charsetMap) {
+        tRepMap = [...tRepMap, ...charsetMap];
+    }
+    const regEx = createMapperRegExp(tRepMap);
     const trie = createTrie(repMap, ignoreCharset);
     // const root = createTrie(repMap, ignoreCharset);
-    return (word) => {
-        const edits = calcAllEdits(trie, word);
-        return applyEdits(word, edits);
+    return {
+        test: regexpRemoveFlags(regEx, 'gm'),
+        fn: (word) => {
+            const edits = calcAllEdits(trie, word);
+            return applyEdits(word, edits);
+        },
     };
 }
 function applyEdits(word, edits) {
@@ -143,6 +156,11 @@ function addToTrie(node, match, replaceWith) {
     s.add(replaceWith);
     node.rep = [...s];
 }
+function regexpRemoveFlags(re, flagsToRemove) {
+    const toRemove = new Set(flagsToRemove);
+    const flags = [...re.flags].filter((f) => !toRemove.has(f)).join('');
+    return new RegExp(re.source, flags);
+}
 export const __testing__ = {
     charsetToRepMap: charsetToRepMapRegEx,
     createMapperRegExp,

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.3.2",
+  "version": "9.6.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "type": "module",
   "sideEffects": false,
@@ -54,14 +54,15 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "9.3.2",
-    "@cspell/cspell-types": "9.3.2",
-    "cspell-trie-lib": "9.3.2",
-    "fast-equals": "^5.3.3"
+    "@cspell/cspell-pipe": "9.6.0",
+    "@cspell/cspell-types": "9.6.0",
+    "cspell-trie-lib": "9.6.0",
+    "fast-equals": "^6.0.0"
   },
   "devDependencies": {
+    "@cspell/dict-de-de": "^4.1.2",
     "gensequence": "^8.0.8",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "595bde79b4a5abf3256b71129995ec3601454b02"
+  "gitHead": "163793ddf2a0ad90bc7c90351698a106003297af"
 }