cspell-dictionary 6.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Jason Dent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# CSpell Dictionary Library
+
+This library is useful for creating in-memory dictionaries used for spell checking.

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -0,0 +1,9 @@
+import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
+import { SpellingDictionary } from './SpellingDictionary';
+import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
+export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
+export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
+export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
+export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
+export declare function getDictionaryInternalSync(settings: CSpellSettingsInternal): SpellingDictionaryCollection;
+//# sourceMappingURL=Dictionaries.d.ts.map

package/dist/SpellingDictionary/Dictionaries.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
+const DictionarySettings_1 = require("../Settings/DictionarySettings");
+const util_1 = require("../util/util");
+const createSpellingDictionary_1 = require("./createSpellingDictionary");
+const DictionaryLoader_1 = require("./DictionaryLoader");
+const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
+function loadDictionaryDefs(defsToLoad) {
+    return defsToLoad.map(DictionaryLoader_1.loadDictionary);
+}
+exports.loadDictionaryDefs = loadDictionaryDefs;
+function loadDictionaryDefsSync(defsToLoad) {
+    return defsToLoad.map(DictionaryLoader_1.loadDictionarySync);
+}
+exports.loadDictionaryDefsSync = loadDictionaryDefsSync;
+function refreshDictionaryCache(maxAge) {
+    return (0, DictionaryLoader_1.refreshCacheEntries)(maxAge);
+}
+exports.refreshDictionaryCache = refreshDictionaryCache;
+const emptyWords = Object.freeze([]);
+async function getDictionaryInternal(settings) {
+    const spellDictionaries = await Promise.all(loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings)));
+    return _getDictionaryInternal(settings, spellDictionaries);
+}
+exports.getDictionaryInternal = getDictionaryInternal;
+function getDictionaryInternalSync(settings) {
+    const spellDictionaries = loadDictionaryDefsSync((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
+    return _getDictionaryInternal(settings, spellDictionaries);
+}
+exports.getDictionaryInternalSync = getDictionaryInternalSync;
+function _getDictionaryInternal(settings, spellDictionaries) {
+    const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
+    const settingsWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
+        caseSensitive: true,
+        weightMap: undefined,
+    });
+    const settingsUserWordsDictionary = userWords.length
+        ? (0, createSpellingDictionary_1.createSpellingDictionary)(userWords, '[userWords]', 'From Settings `userWords`', {
+            caseSensitive: true,
+            weightMap: undefined,
+        })
+        : undefined;
+    const ignoreWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`', {
+        caseSensitive: true,
+        noSuggest: true,
+        weightMap: undefined,
+    });
+    const flagWordsDictionary = (0, createSpellingDictionary_1.createForbiddenWordsDictionary)(flagWords, '[flagWords]', 'From Settings `flagWords`', {
+        weightMap: undefined,
+    });
+    const dictionaries = [
+        ...spellDictionaries,
+        settingsWordsDictionary,
+        settingsUserWordsDictionary,
+        ignoreWordsDictionary,
+        flagWordsDictionary,
+    ].filter(util_1.isDefined);
+    return (0, SpellingDictionaryCollection_1.createCollection)(dictionaries, 'dictionary collection');
+}
+//# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -0,0 +1,93 @@
+import type { ReplaceMap, DictionaryInformation } from '@cspell/cspell-types';
+import type { CompoundWordsMethod, SuggestionCollector, SuggestionResult, WeightMap } from 'cspell-trie-lib';
+export { CompoundWordsMethod, SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
+export interface SearchOptions {
+    useCompounds?: boolean | number | undefined;
+    ignoreCase?: boolean | undefined;
+}
+export interface SuggestOptions {
+    /**
+     * Compounding Mode.
+     * `NONE` is the best option.
+     */
+    compoundMethod?: CompoundWordsMethod;
+    /**
+     * The limit on the number of suggestions to generate. If `allowTies` is true, it is possible
+     * for more suggestions to be generated.
+     */
+    numSuggestions?: number;
+    /**
+     * Max number of changes / edits to the word to get to a suggestion matching suggestion.
+     */
+    numChanges?: number;
+    /**
+     * Allow for case-ingestive checking.
+     */
+    ignoreCase?: boolean;
+    /**
+     * If multiple suggestions have the same edit / change "cost", then included them even if
+     * it causes more than `numSuggestions` to be returned.
+     * @default false
+     */
+    includeTies?: boolean;
+    /**
+     * Maximum amount of time to allow for generating suggestions.
+     */
+    timeout?: number;
+}
+export declare type FindOptions = SearchOptions;
+export interface FindResult {
+    /** the text found, otherwise `false` */
+    found: string | false;
+    /** `true` if it is considered a forbidden word. */
+    forbidden: boolean;
+    /** `true` if it is a no-suggest word. */
+    noSuggest: boolean;
+}
+export declare type HasOptions = SearchOptions;
+export interface SpellingDictionaryOptions {
+    repMap?: ReplaceMap;
+    useCompounds?: boolean;
+    /**
+     * The dictionary is case aware.
+     */
+    caseSensitive?: boolean;
+    noSuggest?: boolean;
+    weightMap?: WeightMap | undefined;
+    dictionaryInformation?: DictionaryInformation;
+    /**
+     * Strip Case and Accents to allow for case insensitive searches and
+     * words without accents.
+     *
+     * Note: this setting only applies to word lists. It has no-impact on trie
+     * dictionaries.
+     *
+     * @default true
+     */
+    supportNonStrictSearches?: boolean;
+}
+export interface DictionaryInfo {
+    /** The name of the dictionary */
+    readonly name: string;
+    /** The source, filename or URI */
+    readonly source: string;
+    /** Options */
+    readonly options: SpellingDictionaryOptions;
+}
+export interface SpellingDictionary extends DictionaryInfo {
+    readonly type: string;
+    readonly containsNoSuggestWords: boolean;
+    has(word: string, options?: HasOptions): boolean;
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word: string, options?: SearchOptions): FindResult | undefined;
+    isForbidden(word: string): boolean;
+    isNoSuggestWord(word: string, options: HasOptions): boolean;
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    mapWord(word: string): string;
+    readonly size: number;
+    readonly isDictionaryCaseSensitive: boolean;
+    getErrors?(): Error[];
+}
+//# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionary.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompoundWordsMethod = void 0;
+var cspell_trie_lib_1 = require("cspell-trie-lib");
+Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: function () { return cspell_trie_lib_1.CompoundWordsMethod; } });
+//# sourceMappingURL=SpellingDictionary.js.map

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -0,0 +1,34 @@
+import { CompoundWordsMethod, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions } from './SpellingDictionary';
+declare function identityString(w: string): string;
+export declare class SpellingDictionaryCollection implements SpellingDictionary {
+    readonly dictionaries: SpellingDictionary[];
+    readonly name: string;
+    readonly options: SpellingDictionaryOptions;
+    readonly mapWord: typeof identityString;
+    readonly type = "SpellingDictionaryCollection";
+    readonly source: string;
+    readonly isDictionaryCaseSensitive: boolean;
+    readonly containsNoSuggestWords: boolean;
+    constructor(dictionaries: SpellingDictionary[], name: string);
+    has(word: string, hasOptions?: HasOptions): boolean;
+    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
+    isNoSuggestWord(word: string, options?: HasOptions): boolean;
+    isForbidden(word: string): boolean;
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    _suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    get size(): number;
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    getErrors(): Error[];
+    private _isForbiddenInDict;
+    private _isNoSuggestWord;
+}
+export declare function createCollection(dictionaries: SpellingDictionary[], name: string): SpellingDictionaryCollection;
+declare function isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptions): SpellingDictionary | undefined;
+declare function isWordForbiddenInAnyDictionary(dicts: SpellingDictionary[], word: string): SpellingDictionary | undefined;
+export declare const __testing__: {
+    isWordInAnyDictionary: typeof isWordInAnyDictionary;
+    isWordForbiddenInAnyDictionary: typeof isWordForbiddenInAnyDictionary;
+};
+export {};
+//# sourceMappingURL=SpellingDictionaryCollection.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const gensequence_1 = require("gensequence");
+const util_1 = require("../util/util");
+const clean_1 = require("../util/clean");
+const SpellingDictionary_1 = require("./SpellingDictionary");
+const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+function identityString(w) {
+    return w;
+}
+class SpellingDictionaryCollection {
+    constructor(dictionaries, name) {
+        this.dictionaries = dictionaries;
+        this.name = name;
+        this.options = { weightMap: undefined };
+        this.mapWord = identityString;
+        this.type = 'SpellingDictionaryCollection';
+        this._isForbiddenInDict = (word) => isWordForbiddenInAnyDictionary(this.dictionaries, word);
+        this._isNoSuggestWord = (word, options) => {
+            if (!this.containsNoSuggestWords)
+                return false;
+            return !!isNoSuggestWordInAnyDictionary(this.dictionaries, word, options || {});
+        };
+        this.dictionaries = this.dictionaries.sort((a, b) => b.size - a.size);
+        this.source = dictionaries.map((d) => d.name).join(', ');
+        this.isDictionaryCaseSensitive = this.dictionaries.reduce((a, b) => a || b.isDictionaryCaseSensitive, false);
+        this.containsNoSuggestWords = this.dictionaries.reduce((a, b) => a || b.containsNoSuggestWords, false);
+    }
+    has(word, hasOptions) {
+        const options = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        return !!isWordInAnyDictionary(this.dictionaries, word, options) && !this.isForbidden(word);
+    }
+    find(word, hasOptions) {
+        const options = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        const { found = false, forbidden = false, noSuggest = false, } = findInAnyDictionary(this.dictionaries, word, options) || {};
+        return { found, forbidden, noSuggest };
+    }
+    isNoSuggestWord(word, options) {
+        return this._isNoSuggestWord(word, options);
+    }
+    isForbidden(word) {
+        return !!this._isForbiddenInDict(word) && !this.isNoSuggestWord(word);
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
+        return this._suggest(word, suggestOptions);
+    }
+    _suggest(word, suggestOptions) {
+        const { numSuggestions = SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout } = suggestOptions;
+        const prefixNoCase = cspell_trie_lib_1.CASE_INSENSITIVE_PREFIX;
+        const filter = (word, _cost) => {
+            return ((ignoreCase || word[0] !== prefixNoCase) &&
+                !this.isForbidden(word) &&
+                !this.isNoSuggestWord(word, suggestOptions));
+        };
+        const collector = (0, SpellingDictionaryMethods_1.suggestionCollector)(word, (0, clean_1.clean)({
+            numSuggestions,
+            filter,
+            changeLimit: numChanges,
+            includeTies,
+            ignoreCase,
+            timeout,
+        }));
+        this.genSuggestions(collector, suggestOptions);
+        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
+    }
+    get size() {
+        return this.dictionaries.reduce((a, b) => a + b.size, 0);
+    }
+    genSuggestions(collector, suggestOptions) {
+        const _suggestOptions = { ...suggestOptions };
+        const { compoundMethod = SpellingDictionary_1.CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;
+        _suggestOptions.compoundMethod = this.options.useCompounds ? SpellingDictionary_1.CompoundWordsMethod.JOIN_WORDS : compoundMethod;
+        this.dictionaries.forEach((dict) => dict.genSuggestions(collector, _suggestOptions));
+    }
+    getErrors() {
+        return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
+    }
+}
+exports.SpellingDictionaryCollection = SpellingDictionaryCollection;
+function createCollection(dictionaries, name) {
+    return new SpellingDictionaryCollection(dictionaries, name);
+}
+exports.createCollection = createCollection;
+function isWordInAnyDictionary(dicts, word, options) {
+    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.has(word, options));
+}
+function findInAnyDictionary(dicts, word, options) {
+    const found = dicts.map((dict) => dict.find(word, options)).filter(util_1.isDefined);
+    if (!found.length)
+        return undefined;
+    return found.reduce((a, b) => ({
+        found: a.forbidden ? a.found : b.forbidden ? b.found : a.found || b.found,
+        forbidden: a.forbidden || b.forbidden,
+        noSuggest: a.noSuggest || b.noSuggest,
+    }));
+}
+function isNoSuggestWordInAnyDictionary(dicts, word, options) {
+    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isNoSuggestWord(word, options));
+}
+function isWordForbiddenInAnyDictionary(dicts, word) {
+    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isForbidden(word));
+}
+exports.__testing__ = {
+    isWordInAnyDictionary,
+    isWordForbiddenInAnyDictionary,
+};
+//# sourceMappingURL=SpellingDictionaryCollection.js.map

package/dist/SpellingDictionary/SpellingDictionaryError.d.ts

@@ -0,0 +1,10 @@
+import { LoadOptions } from './DictionaryLoader';
+export declare class SpellingDictionaryLoadError extends Error {
+    readonly uri: string;
+    readonly options: LoadOptions;
+    readonly cause: Error;
+    readonly name: string;
+    constructor(uri: string, options: LoadOptions, cause: Error, message: string);
+}
+export declare function isSpellingDictionaryLoadError(e: Error): e is SpellingDictionaryLoadError;
+//# sourceMappingURL=SpellingDictionaryError.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSpellingDictionaryLoadError = exports.SpellingDictionaryLoadError = void 0;
+class SpellingDictionaryLoadError extends Error {
+    constructor(uri, options, cause, message) {
+        super(message);
+        this.uri = uri;
+        this.options = options;
+        this.cause = cause;
+        this.name = options.name;
+    }
+}
+exports.SpellingDictionaryLoadError = SpellingDictionaryLoadError;
+function isSpellingDictionaryLoadError(e) {
+    return e instanceof SpellingDictionaryLoadError;
+}
+exports.isSpellingDictionaryLoadError = isSpellingDictionaryLoadError;
+//# sourceMappingURL=SpellingDictionaryError.js.map

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -0,0 +1,36 @@
+import type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
+import { CompoundWordsMethod, Trie } from 'cspell-trie-lib';
+import { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions } from './SpellingDictionary';
+export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
+    readonly trie: Trie;
+    readonly name: string;
+    readonly options: SpellingDictionaryOptions;
+    readonly source: string;
+    static readonly cachedWordsLimit = 50000;
+    private _size;
+    readonly knownWords: Set<string>;
+    readonly unknownWords: Set<string>;
+    readonly mapWord: (word: string) => string;
+    readonly type = "SpellingDictionaryFromTrie";
+    readonly isDictionaryCaseSensitive: boolean;
+    readonly containsNoSuggestWords: boolean;
+    readonly ignoreCharactersRegExp: RegExp | undefined;
+    private weightMap;
+    constructor(trie: Trie, name: string, options: SpellingDictionaryOptions, source?: string, size?: number);
+    get size(): number;
+    has(word: string, hasOptions?: HasOptions): boolean;
+    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
+    private resolveOptions;
+    private _find;
+    private findAnyForm;
+    private _findAnyForm;
+    isNoSuggestWord(word: string, options?: HasOptions): boolean;
+    isForbidden(word: string): boolean;
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    private _suggest;
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    getErrors(): Error[];
+}
+export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+//# sourceMappingURL=SpellingDictionaryFromTrie.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpellingDictionaryTrie = exports.SpellingDictionaryFromTrie = void 0;
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const repMap_1 = require("../util/repMap");
+const clean_1 = require("../util/clean");
+const charset_1 = require("./charset");
+const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+class SpellingDictionaryFromTrie {
+    constructor(trie, name, options, source = 'from trie', size) {
+        this.trie = trie;
+        this.name = name;
+        this.options = options;
+        this.source = source;
+        this._size = 0;
+        this.knownWords = new Set();
+        this.unknownWords = new Set();
+        this.type = 'SpellingDictionaryFromTrie';
+        this._find = (word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase);
+        this.mapWord = (0, repMap_1.createMapper)(options.repMap || []);
+        this.isDictionaryCaseSensitive = options.caseSensitive ?? !trie.isLegacy;
+        this.containsNoSuggestWords = options.noSuggest || false;
+        this._size = size || 0;
+        this.weightMap = options.weightMap || (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(options.dictionaryInformation);
+        this.ignoreCharactersRegExp = (0, charset_1.charsetToRegExp)(this.options.dictionaryInformation?.ignore);
+    }
+    get size() {
+        if (!this._size) {
+            // walk the trie and get the approximate size.
+            const i = this.trie.iterate();
+            let deeper = true;
+            let size = 0;
+            for (let r = i.next(); !r.done; r = i.next(deeper)) {
+                // count all nodes even though they are not words.
+                // because we are not going to all the leaves, this should give a good enough approximation.
+                size += 1;
+                deeper = r.value.text.length < 5;
+            }
+            this._size = size;
+        }
+        return this._size;
+    }
+    has(word, hasOptions) {
+        const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
+        const r = this._find(word, useCompounds, ignoreCase);
+        return !!r && !r.forbidden && !!r.found;
+    }
+    find(word, hasOptions) {
+        const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
+        const r = this._find(word, useCompounds, ignoreCase);
+        const { forbidden = this.isForbidden(word) } = r || {};
+        if (!r && !forbidden)
+            return undefined;
+        const { found = forbidden ? word : false } = r || {};
+        const noSuggest = found !== false && this.containsNoSuggestWords;
+        return { found, forbidden, noSuggest };
+    }
+    resolveOptions(hasOptions) {
+        const { useCompounds = this.options.useCompounds, ignoreCase = true } = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        return { useCompounds, ignoreCase };
+    }
+    findAnyForm(word, useCompounds, ignoreCase) {
+        const outerForms = new Set([word]);
+        if (this.ignoreCharactersRegExp) {
+            outerForms.add(word.replace(this.ignoreCharactersRegExp, ''));
+            outerForms.add(word.normalize('NFD').replace(this.ignoreCharactersRegExp, ''));
+            outerForms.add(word.normalize('NFC').replace(this.ignoreCharactersRegExp, ''));
+        }
+        for (const form of outerForms) {
+            const r = this._findAnyForm(form, useCompounds, ignoreCase);
+            if (r)
+                return r;
+        }
+        return undefined;
+    }
+    _findAnyForm(word, useCompounds, ignoreCase) {
+        const mWord = this.mapWord(word.normalize('NFC'));
+        const opts = { caseSensitive: !ignoreCase };
+        const findResult = this.trie.findWord(mWord, opts);
+        if (findResult.found !== false) {
+            return findResult;
+        }
+        const forms = (0, SpellingDictionaryMethods_1.wordSearchForms)(mWord, this.isDictionaryCaseSensitive, ignoreCase);
+        for (const w of forms) {
+            const findResult = this.trie.findWord(w, opts);
+            if (findResult.found !== false) {
+                return findResult;
+            }
+        }
+        if (useCompounds) {
+            opts.useLegacyWordCompounds = useCompounds;
+            for (const w of forms) {
+                const findResult = this.trie.findWord(w, opts);
+                if (findResult.found !== false) {
+                    return findResult;
+                }
+            }
+        }
+        return undefined;
+    }
+    isNoSuggestWord(word, options) {
+        return this.containsNoSuggestWords ? this.has(word, options) : false;
+    }
+    isForbidden(word) {
+        return this.trie.isForbiddenWord(word);
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
+        return this._suggest(word, suggestOptions);
+    }
+    _suggest(word, suggestOptions) {
+        const { numSuggestions = SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, includeTies, ignoreCase, timeout } = suggestOptions;
+        function filter(_word) {
+            return true;
+        }
+        const collector = (0, cspell_trie_lib_1.suggestionCollector)(word, (0, clean_1.clean)({
+            numSuggestions,
+            filter,
+            changeLimit: numChanges,
+            includeTies,
+            ignoreCase,
+            timeout,
+            weightMap: this.weightMap,
+        }));
+        this.genSuggestions(collector, suggestOptions);
+        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
+    }
+    genSuggestions(collector, suggestOptions) {
+        if (this.options.noSuggest)
+            return;
+        const _compoundMethod = suggestOptions.compoundMethod ??
+            (this.options.useCompounds ? cspell_trie_lib_1.CompoundWordsMethod.JOIN_WORDS : cspell_trie_lib_1.CompoundWordsMethod.NONE);
+        (0, SpellingDictionaryMethods_1.wordSuggestFormsArray)(collector.word).forEach((w) => this.trie.genSuggestions((0, SpellingDictionaryMethods_1.impersonateCollector)(collector, w), _compoundMethod));
+    }
+    getErrors() {
+        return [];
+    }
+}
+exports.SpellingDictionaryFromTrie = SpellingDictionaryFromTrie;
+SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
+function createSpellingDictionaryTrie(data, name, source, options) {
+    const trieNode = (0, cspell_trie_lib_1.importTrie)(data);
+    const trie = new cspell_trie_lib_1.Trie(trieNode);
+    return new SpellingDictionaryFromTrie(trie, name, options, source);
+}
+exports.createSpellingDictionaryTrie = createSpellingDictionaryTrie;
+//# sourceMappingURL=SpellingDictionaryFromTrie.js.map

package/dist/SpellingDictionary/SpellingDictionaryMethods.d.ts

@@ -0,0 +1,29 @@
+import { DictionaryInformation } from '@cspell/cspell-types';
+import { CompoundWordsMethod, SuggestionResult, WeightMap } from 'cspell-trie-lib';
+import { HasOptions, SearchOptions, SpellingDictionary, SuggestOptions } from './SpellingDictionary';
+export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
+export declare type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
+export declare type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
+export declare const defaultNumSuggestions = 10;
+declare function wordSearchFormsArray(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): string[];
+export declare function wordSearchForms(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): Set<string>;
+export declare function wordSuggestFormsArray(word: string): string[];
+export declare function wordSuggestForms(word: string): Set<string>;
+interface DictionaryWordForm {
+    w: string;
+    p: string;
+}
+declare function wordDictionaryForms(word: string, prefixNoCase: string): IterableIterator<DictionaryWordForm>;
+export declare function wordDictionaryFormsCollector(prefixNoCase: string): (word: string) => Iterable<string>;
+export declare function hasOptionToSearchOption(opt: HasOptions | undefined): SearchOptions;
+export declare function suggestArgsToSuggestOptions(args: SuggestArgs): SuggestOptions;
+export declare function createWeightMapFromDictionaryInformation(di: undefined): undefined;
+export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation): WeightMap;
+export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation | undefined): WeightMap | undefined;
+export declare const __testMethods__: {
+    wordSearchForms: typeof wordSearchForms;
+    wordSearchFormsArray: typeof wordSearchFormsArray;
+    wordDictionaryForms: typeof wordDictionaryForms;
+    wordDictionaryFormsCollector: typeof wordDictionaryFormsCollector;
+};
+//# sourceMappingURL=SpellingDictionaryMethods.d.ts.map