cspell-dictionary 6.28.0 → 6.29.1

package/dist/esm/SpellingDictionary/SpellingDictionary.d.mts

@@ -0,0 +1,150 @@
+import type { DictionaryInformation, ReplaceMap } from '@cspell/cspell-types';
+import type { CompoundWordsMethod, SuggestionCollector, SuggestionResult, WeightMap } from 'cspell-trie-lib';
+export type { DictionaryDefinitionInline } from '@cspell/cspell-types';
+export { CompoundWordsMethod, type SuggestionCollector, type SuggestionResult } from 'cspell-trie-lib';
+export interface SearchOptions {
+    /**
+     * Legacy compounds have been deprecated.
+     *
+     * @deprecated
+     */
+    useCompounds?: boolean | number | undefined;
+    /**
+     * Ignore Case and Accents
+     */
+    ignoreCase?: boolean | undefined;
+}
+export interface SuggestOptions {
+    /**
+     * Compounding Mode.
+     * `NONE` is the best option.
+     */
+    compoundMethod?: CompoundWordsMethod | undefined;
+    /**
+     * The limit on the number of suggestions to generate. If `allowTies` is true, it is possible
+     * for more suggestions to be generated.
+     */
+    numSuggestions?: number | undefined;
+    /**
+     * Max number of changes / edits to the word to get to a suggestion matching suggestion.
+     */
+    numChanges?: number | undefined;
+    /**
+     * Allow for case-ingestive checking.
+     */
+    ignoreCase?: boolean | undefined;
+    /**
+     * 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 | undefined;
+    /**
+     * Maximum amount of time to allow for generating suggestions.
+     */
+    timeout?: number | undefined;
+}
+export 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 type HasOptions = SearchOptions;
+export type IgnoreCaseOption = boolean;
+export interface SpellingDictionaryOptions {
+    repMap?: ReplaceMap;
+    /**
+     * The dictionary is case aware.
+     */
+    caseSensitive?: boolean;
+    /**
+     * This is a NO Suggest dictionary used for words to be ignored.
+     */
+    noSuggest?: boolean;
+    /**
+     * Extra dictionary information used in improving suggestions
+     * based upon locale.
+     */
+    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;
+    /**
+     * Turns on legacy word compounds.
+     * @deprecated
+     */
+    useCompounds?: boolean;
+    /**
+     * Optional WeightMap used to improve suggestions.
+     */
+    weightMap?: WeightMap | undefined;
+}
+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;
+    /**
+     * Checks if a word is forbidden.
+     * @param word - word to check.
+     */
+    isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+    /**
+     * No Suggest words are considered correct but will not be listed when
+     * suggestions are generated.
+     * No Suggest words and "Ignored" words are equivalent. Ignored / no suggest words override forbidden words.
+     * @param word - word to check
+     * @param options - options
+     */
+    isNoSuggestWord(word: string, options: HasOptions): boolean;
+    /**
+     * Generate suggestions for a word.
+     * @param word - word
+     * @param numSuggestions - max number of suggestions to generate.
+     * @param compoundMethod - Default NONE.
+     * @param numChanges - Default 5
+     * @param ignoreCase - true
+     */
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    /**
+     * Generate suggestions for a word
+     * @param word - word
+     * @param suggestOptions - options
+     */
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    mapWord(word: string): string;
+    /**
+     * 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[];
+    readonly size: number;
+    readonly isDictionaryCaseSensitive: boolean;
+    getErrors?(): Error[];
+}
+export type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
+export declare const defaultOptions: SpellingDictionaryOptions;
+//# sourceMappingURL=SpellingDictionary.d.mts.map

package/dist/esm/SpellingDictionary/SpellingDictionary.mjs

@@ -0,0 +1,4 @@
+export { CompoundWordsMethod } from 'cspell-trie-lib';
+export const defaultOptions = Object.freeze({
+    weightMap: undefined,
+});

package/dist/esm/SpellingDictionary/SpellingDictionaryCollection.d.mts

@@ -0,0 +1,16 @@
+import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.mjs';
+export interface SpellingDictionaryCollection extends SpellingDictionary {
+    readonly type: 'SpellingDictionaryCollection';
+    readonly dictionaries: SpellingDictionary[];
+    getErrors(): Error[];
+}
+export declare function createCollection(dictionaries: SpellingDictionary[], name: string, source?: string): SpellingDictionaryCollection;
+declare function isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptions): SpellingDictionary | undefined;
+declare function isWordForbiddenInAnyDictionary(dicts: SpellingDictionary[], word: string, ignoreCase: boolean | undefined): SpellingDictionary | undefined;
+export declare function isSpellingDictionaryCollection(dict: SpellingDictionary): dict is SpellingDictionaryCollection;
+export declare const __testing__: {
+    isWordInAnyDictionary: typeof isWordInAnyDictionary;
+    isWordForbiddenInAnyDictionary: typeof isWordForbiddenInAnyDictionary;
+};
+export {};
+//# sourceMappingURL=SpellingDictionaryCollection.d.mts.map

package/dist/esm/SpellingDictionary/SpellingDictionaryCollection.mjs

@@ -0,0 +1,111 @@
+import { CASE_INSENSITIVE_PREFIX } from 'cspell-trie-lib';
+import { genSequence } from 'gensequence';
+import { isDefined } from '../util/util.mjs';
+import * as Defaults from './defaults.mjs';
+import { CompoundWordsMethod } from './SpellingDictionary.mjs';
+import { defaultNumSuggestions, hasOptionToSearchOption, suggestArgsToSuggestOptions, suggestionCollector, } from './SpellingDictionaryMethods.mjs';
+function identityString(w) {
+    return w;
+}
+class SpellingDictionaryCollectionImpl {
+    constructor(dictionaries, name, source) {
+        this.dictionaries = dictionaries;
+        this.name = name;
+        this.options = { weightMap: undefined };
+        this.mapWord = identityString;
+        this.type = 'SpellingDictionaryCollection';
+        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 = 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 = hasOptionToSearchOption(hasOptions);
+        return !!isWordInAnyDictionary(this.dictionaries, word, options) && !this.isForbidden(word);
+    }
+    find(word, hasOptions) {
+        const options = hasOptionToSearchOption(hasOptions);
+        return findInAnyDictionary(this.dictionaries, word, options);
+    }
+    isNoSuggestWord(word, options) {
+        return this._isNoSuggestWord(word, options);
+    }
+    isForbidden(word, ignoreCaseAndAccents) {
+        const ignoreCase = ignoreCaseAndAccents ?? Defaults.isForbiddenIgnoreCaseAndAccents;
+        return !!this._isForbiddenInDict(word, ignoreCase) && !this.isNoSuggestWord(word, { ignoreCase });
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = suggestArgsToSuggestOptions(args);
+        return this._suggest(word, suggestOptions);
+    }
+    _suggest(word, suggestOptions) {
+        const { numSuggestions = defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout } = suggestOptions;
+        const prefixNoCase = CASE_INSENSITIVE_PREFIX;
+        const filter = (word, _cost) => {
+            return ((ignoreCase || word[0] !== prefixNoCase) &&
+                !this.isForbidden(word) &&
+                !this.isNoSuggestWord(word, suggestOptions));
+        };
+        const collectorOptions = {
+            numSuggestions,
+            filter,
+            changeLimit: numChanges,
+            includeTies,
+            ignoreCase,
+            timeout,
+        };
+        const collector = suggestionCollector(word, collectorOptions);
+        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 = CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;
+        _suggestOptions.compoundMethod = this.options.useCompounds ? CompoundWordsMethod.JOIN_WORDS : compoundMethod;
+        this.dictionaries.forEach((dict) => dict.genSuggestions(collector, _suggestOptions));
+    }
+    getErrors() {
+        return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
+    }
+    _isForbiddenInDict(word, ignoreCase) {
+        return isWordForbiddenInAnyDictionary(this.dictionaries, word, ignoreCase);
+    }
+}
+export function createCollection(dictionaries, name, source) {
+    return new SpellingDictionaryCollectionImpl(dictionaries, name, source);
+}
+function isWordInAnyDictionary(dicts, word, options) {
+    return genSequence(dicts).first((dict) => dict.has(word, options));
+}
+function findInAnyDictionary(dicts, word, options) {
+    const found = dicts.map((dict) => dict.find(word, options)).filter(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 genSequence(dicts).first((dict) => dict.isNoSuggestWord(word, options));
+}
+function isWordForbiddenInAnyDictionary(dicts, word, ignoreCase) {
+    return genSequence(dicts).first((dict) => dict.isForbidden(word, ignoreCase));
+}
+export function isSpellingDictionaryCollection(dict) {
+    return dict instanceof SpellingDictionaryCollectionImpl;
+}
+export const __testing__ = {
+    isWordInAnyDictionary,
+    isWordForbiddenInAnyDictionary,
+};

package/dist/esm/SpellingDictionary/SpellingDictionaryFromTrie.d.mts

@@ -0,0 +1,50 @@
+import type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
+import { CompoundWordsMethod, Trie } from 'cspell-trie-lib';
+import type { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions } from './SpellingDictionary.mjs';
+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 remapWord: (word: string) => string[];
+    readonly type = "SpellingDictionaryFromTrie";
+    readonly isDictionaryCaseSensitive: boolean;
+    readonly containsNoSuggestWords: boolean;
+    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, _ignoreCaseAndAccents?: boolean): boolean;
+    private _isForbidden;
+    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[];
+}
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+export declare function createSpellingDictionaryFromTrieFile(data: Iterable<string> | string, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+declare function outerWordForms(word: string, mapWord: (word: string) => string[]): Set<string>;
+export declare const __testing__: {
+    outerWordForms: typeof outerWordForms;
+};
+export {};
+//# sourceMappingURL=SpellingDictionaryFromTrie.d.mts.map

package/dist/esm/SpellingDictionary/SpellingDictionaryFromTrie.mjs

@@ -0,0 +1,172 @@
+import { opConcatMap, pipe } from '@cspell/cspell-pipe/sync';
+import { CompoundWordsMethod, importTrie, suggestionCollector, Trie } from 'cspell-trie-lib';
+import { autoCache, createCache01 } from '../util/AutoCache.mjs';
+import { clean } from '../util/clean.mjs';
+import { createMapper, createRepMapper } from '../util/repMap.mjs';
+import * as Defaults from './defaults.mjs';
+import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOptionToSearchOption, impersonateCollector, suggestArgsToSuggestOptions, wordSearchForms, wordSuggestFormsArray, } from './SpellingDictionaryMethods.mjs';
+const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
+const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
+export 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 = findCache((word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase));
+        this._isForbidden = autoCache((word) => {
+            return this.trie.isForbiddenWord(word);
+        });
+        this.mapWord = createMapper(options.repMap, options.dictionaryInformation?.ignore);
+        this.remapWord = createRepMapper(options.repMap, options.dictionaryInformation?.ignore);
+        this.isDictionaryCaseSensitive = options.caseSensitive ?? !trie.isLegacy;
+        this.containsNoSuggestWords = options.noSuggest || false;
+        this._size = size || 0;
+        this.weightMap = options.weightMap || createWeightMapFromDictionaryInformation(options.dictionaryInformation);
+    }
+    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 = Defaults.ignoreCase } = hasOptionToSearchOption(hasOptions);
+        return { useCompounds, ignoreCase };
+    }
+    findAnyForm(word, useCompounds, ignoreCase) {
+        const outerForms = outerWordForms(word, this.remapWord ? this.remapWord : (word) => [this.mapWord(word)]);
+        for (const form of outerForms) {
+            const r = this._findAnyForm(form, useCompounds, ignoreCase);
+            if (r)
+                return r;
+        }
+        return undefined;
+    }
+    _findAnyForm(mWord, useCompounds, ignoreCase) {
+        const opts = ignoreCase ? findWordOptionsNotCaseSensitive : findWordOptionsCaseSensitive;
+        const findResult = this.trie.findWord(mWord, opts);
+        if (findResult.found !== false) {
+            return findResult;
+        }
+        const forms = 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) {
+            const optsUseCompounds = { ...opts, useLegacyWordCompounds: useCompounds };
+            for (const w of forms) {
+                const findResult = this.trie.findWord(w, optsUseCompounds);
+                if (findResult.found !== false) {
+                    return findResult;
+                }
+            }
+        }
+        return undefined;
+    }
+    isNoSuggestWord(word, options) {
+        return this.containsNoSuggestWords ? this.has(word, options) : false;
+    }
+    isForbidden(word, _ignoreCaseAndAccents) {
+        return this._isForbidden(word);
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = suggestArgsToSuggestOptions(args);
+        return this._suggest(word, suggestOptions);
+    }
+    _suggest(word, suggestOptions) {
+        const { numSuggestions = defaultNumSuggestions, numChanges, includeTies, ignoreCase, timeout } = suggestOptions;
+        function filter(_word) {
+            return true;
+        }
+        const collector = suggestionCollector(word, 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 ? CompoundWordsMethod.JOIN_WORDS : CompoundWordsMethod.NONE);
+        wordSuggestFormsArray(collector.word).forEach((w) => this.trie.genSuggestions(impersonateCollector(collector, w), _compoundMethod));
+    }
+    getErrors() {
+        return [];
+    }
+}
+SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+export function createSpellingDictionaryFromTrieFile(data, name, source, options) {
+    data = typeof data === 'string' ? data.split('\n') : data;
+    const trieNode = importTrie(data);
+    const trie = new Trie(trieNode);
+    return new SpellingDictionaryFromTrie(trie, name, options, source);
+}
+function findCache(fn, size = 2000) {
+    const cache = createCache01(size);
+    function find(word, useCompounds, ignoreCase) {
+        const r = cache.get(word);
+        if (r !== undefined) {
+            if (r.useCompounds === useCompounds && r.ignoreCase === ignoreCase) {
+                return r.findResult;
+            }
+        }
+        const findResult = fn(word, useCompounds, ignoreCase);
+        cache.set(word, { useCompounds, ignoreCase, findResult });
+        return findResult;
+    }
+    return find;
+}
+function outerWordForms(word, mapWord) {
+    const forms = pipe([word], opConcatMap((word) => [word, word.normalize('NFC'), word.normalize('NFD')]), opConcatMap((word) => [word, ...mapWord(word)]));
+    return new Set(forms);
+}
+export const __testing__ = { outerWordForms };

package/dist/esm/SpellingDictionary/SpellingDictionaryMethods.d.mts

@@ -0,0 +1,26 @@
+import type { DictionaryInformation } from '@cspell/cspell-types';
+import type { SuggestionResult, WeightMap } from 'cspell-trie-lib';
+import type { HasOptions, SearchOptions, SuggestArgs, SuggestOptions } from './SpellingDictionary.mjs';
+export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
+export type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
+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>;
+export declare function hasOptionToSearchOption(opt: HasOptions | undefined): SearchOptions;
+/**
+ * Find the canonical form for SearchOptions. Useful Maps and WeakMaps.
+ * @param opt - options to normalize
+ * @returns SearchOptions - the canonical form
+ */
+export declare function canonicalSearchOptions(opt: SearchOptions): 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;
+};
+//# sourceMappingURL=SpellingDictionaryMethods.d.mts.map

package/dist/esm/SpellingDictionary/SpellingDictionaryMethods.mjs

@@ -0,0 +1,96 @@
+import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
+import { isUpperCase, removeUnboundAccents, ucFirst } from '../util/text.mjs';
+export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
+export const defaultNumSuggestions = 10;
+function wordSearchFormsArray(word, isDictionaryCaseSensitive, ignoreCase) {
+    return [...wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase)];
+}
+export function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
+    const forms = new Set();
+    word = word.normalize('NFC');
+    const wordLc = word.toLowerCase();
+    if (ignoreCase) {
+        if (isDictionaryCaseSensitive) {
+            forms.add(wordLc);
+        }
+        else {
+            forms.add(wordLc);
+            // Legacy remove any unbound accents
+            forms.add(removeUnboundAccents(wordLc));
+        }
+    }
+    else {
+        if (isDictionaryCaseSensitive) {
+            forms.add(word);
+            forms.add(wordLc);
+            // HOUSE -> House, house
+            if (isUpperCase(word)) {
+                forms.add(ucFirst(wordLc));
+            }
+        }
+        else {
+            forms.add(wordLc);
+            // Legacy remove any unbound accents
+            forms.add(removeUnboundAccents(wordLc));
+        }
+    }
+    return forms;
+}
+export function wordSuggestFormsArray(word) {
+    return [...wordSuggestForms(word)];
+}
+export function wordSuggestForms(word) {
+    word = word.normalize('NFC');
+    const forms = new Set([word]);
+    const wordLc = word.toLowerCase();
+    forms.add(wordLc);
+    return forms;
+}
+const DEFAULT_HAS_OPTIONS = Object.freeze({});
+export function hasOptionToSearchOption(opt) {
+    return canonicalSearchOptions(!opt ? DEFAULT_HAS_OPTIONS : opt);
+}
+const canonicalSearchOptionsMap = new Map();
+const knownCanonicalOptions = new WeakMap();
+/**
+ * Find the canonical form for SearchOptions. Useful Maps and WeakMaps.
+ * @param opt - options to normalize
+ * @returns SearchOptions - the canonical form
+ */
+export function canonicalSearchOptions(opt) {
+    const known = knownCanonicalOptions.get(opt);
+    if (known)
+        return known;
+    const { ignoreCase, useCompounds } = opt;
+    const foundLevel1Map = canonicalSearchOptionsMap.get(ignoreCase);
+    const useLevel1Map = foundLevel1Map || new Map();
+    if (!foundLevel1Map) {
+        canonicalSearchOptionsMap.set(ignoreCase, useLevel1Map);
+    }
+    const foundCanOpts = useLevel1Map.get(useCompounds);
+    const canOpts = foundCanOpts || Object.freeze({ ignoreCase, useCompounds });
+    if (!foundCanOpts) {
+        useLevel1Map.set(useCompounds, canOpts);
+    }
+    knownCanonicalOptions.set(opt, canOpts);
+    return canOpts;
+}
+export function suggestArgsToSuggestOptions(args) {
+    const [_word, options, compoundMethod, numChanges, ignoreCase] = args;
+    const suggestOptions = typeof options === 'object'
+        ? options
+        : {
+            numSuggestions: options,
+            compoundMethod,
+            numChanges,
+            ignoreCase,
+        };
+    return suggestOptions;
+}
+export function createWeightMapFromDictionaryInformation(di) {
+    return di ? mapDictionaryInformationToWeightMap(di) : undefined;
+}
+export const __testMethods__ = {
+    wordSearchForms,
+    wordSearchFormsArray,
+};

package/dist/esm/SpellingDictionary/SuggestDictionary.d.mts

@@ -0,0 +1,20 @@
+import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.mjs';
+import { type TypoEntry, type TyposDef } from './Typos/index.mjs';
+export interface SuggestDictionary extends SpellingDictionary {
+    /**
+     * 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;
+}
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param entries - list of Typos Entries
+ * @param name - name of dictionary
+ * @param source - source
+ * @returns
+ */
+export declare function createSuggestDictionary(entries: readonly string[] | TyposDef | Iterable<TypoEntry>, name: string, source: string): SuggestDictionary;
+//# sourceMappingURL=SuggestDictionary.d.mts.map