cspell-dictionary 6.27.0 → 6.29.0

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

package/dist/esm/SpellingDictionary/SuggestDictionary.mjs

@@ -0,0 +1,97 @@
+import { pipe } from '@cspell/cspell-pipe/sync';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
+import { mapperRemoveCaseAndAccents } from '../util/textMappers.mjs';
+import * as defaults from './defaults.mjs';
+import { processEntriesToTyposDef } from './Typos/index.mjs';
+import { extractAllSuggestions } from './Typos/util.mjs';
+class SuggestDictionaryImpl {
+    constructor(name, source, typosDef) {
+        this.name = name;
+        this.source = source;
+        this.typosDef = typosDef;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.type = 'suggest';
+        this.isDictionaryCaseSensitive = true;
+        this.size = Object.keys(typosDef).length;
+        this.suggestions = extractAllSuggestions(typosDef);
+        this.suggestionsLower = new Set(pipe(this.suggestions, mapperRemoveCaseAndAccents));
+    }
+    /**
+     * 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, _options) {
+        return false;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(_word, _options) {
+        return undefined;
+    }
+    isForbidden(_word, _ignoreCaseAndAccents) {
+        return false;
+    }
+    isNoSuggestWord(_word, _options) {
+        return false;
+    }
+    /**
+     * 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, ignoreCaseAndAccents = defaults.isForbiddenIgnoreCaseAndAccents) {
+        if (this.suggestions.has(word))
+            return true;
+        const lcWord = word.toLowerCase();
+        return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
+    }
+    suggest(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
+    _suggest(word) {
+        if (!(word in this.typosDef))
+            return undefined;
+        const sug = this.typosDef[word];
+        const isPreferred = true;
+        if (!sug)
+            return [];
+        if (typeof sug === 'string') {
+            return [
+                {
+                    word: sug,
+                    cost: 1,
+                    isPreferred,
+                },
+            ];
+        }
+        return sug.map((word, index) => ({ word, cost: index + 1, isPreferred }));
+    }
+    genSuggestions(collector) {
+        const sugs = this.suggest(collector.word);
+        sugs.forEach((result) => collector.add(result));
+    }
+    mapWord(word) {
+        return word;
+    }
+    getErrors() {
+        return [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * 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 function createSuggestDictionary(entries, name, source) {
+    return createCache.get(entries, () => {
+        const def = processEntriesToTyposDef(entries);
+        return new SuggestDictionaryImpl(name, source, def);
+    });
+}

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

@@ -0,0 +1,2 @@
+export { TermsDef, TermsDefKey, TermsDefValue, TermValueIgnoreWord, TermValueOk, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions, } from './terms.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/esm/SpellingDictionary/Terms/index.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,12 @@
+export type TermValueTypoNoSuggestions = false;
+type TermValueTypoSingleSuggestion = string;
+type TermValueTypoMultipleSuggestions = string[];
+export type TermValueTypoWithSuggestions = TermValueTypoSingleSuggestion | TermValueTypoMultipleSuggestions;
+export type TermValueTypo = TermValueTypoWithSuggestions | TermValueTypoNoSuggestions;
+export type TermValueIgnoreWord = null;
+export type TermValueOk = true;
+export type TermsDefValue = TermValueTypo | TermValueIgnoreWord | TermValueOk;
+export type TermsDefKey = string;
+export type TermsDef = Record<TermsDefKey, TermsDefValue>;
+export {};
+//# sourceMappingURL=terms.d.mts.map

package/dist/esm/SpellingDictionary/Terms/terms.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export type { TypoEntry, TyposDef } from './typos.mjs';
+export { parseTyposFile, parseTyposLine, processEntriesToTyposDef } from './typosParser.mjs';
+export { createTyposDef, extractAllSuggestions } from './util.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/esm/SpellingDictionary/Typos/index.mjs

@@ -0,0 +1,2 @@
+export { parseTyposFile, parseTyposLine, processEntriesToTyposDef } from './typosParser.mjs';
+export { createTyposDef, extractAllSuggestions } from './util.mjs';

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

@@ -0,0 +1,18 @@
+import type { TermsDefKey, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions } from '../Terms/index.mjs';
+export type TypoValueNoSuggestions = TermValueTypoNoSuggestions;
+export type TypoValueWithSuggestions = TermValueTypoWithSuggestions;
+export type TyposDefValue = TermValueTypo;
+export type TyposDefKey = TermsDefKey;
+/**
+ * Typos Definition
+ *   key - the incorrect word
+ *   value - the suggestions.
+ */
+export type TyposDef = Record<TyposDefKey, TyposDefValue>;
+type TypoWithNoSuggestions = string;
+type TypoWithSuggestionsArray = [forbidWord: string, ...suggestions: string[]];
+type TypoWithSuggestionsObj = TyposDef;
+type TypoWithSuggestions = TypoWithSuggestionsArray | TypoWithSuggestionsObj;
+export type TypoEntry = TypoWithNoSuggestions | TypoWithSuggestions;
+export {};
+//# sourceMappingURL=typos.d.mts.map

package/dist/esm/SpellingDictionary/Typos/typos.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,34 @@
+import type { TypoEntry, TyposDef } from './typos.mjs';
+export declare function createTyposDefFromEntries(entries: Iterable<TypoEntry>): TyposDef;
+export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string, unknown> | unknown): TyposDef | undefined;
+/**
+ * Parse Typos Entries
+ *
+ * Format:
+ * - `word:suggestion`
+ * - `word->suggestion`
+ * - `word: first, second, third suggestions`
+ *
+ * Note:
+ * ```plaintext
+ * yellow:blue, green
+ * ```
+ * Is the same as multiple entries with the same key and different suggestions.
+ * ```plaintext
+ * yellow:blue
+ * yellow:green
+ * ```
+ *
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+export declare function processEntriesToTyposDef(entries: Iterable<TypoEntry> | TyposDef | Record<string, unknown>): TyposDef;
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+export declare function parseTyposLine(line: TypoEntry): TypoEntry | undefined;
+export declare function parseTyposFile(content: string): TyposDef;
+//# sourceMappingURL=typosParser.d.mts.map

package/dist/esm/SpellingDictionary/Typos/typosParser.mjs

@@ -0,0 +1,131 @@
+import assert from 'assert';
+import { appendToDef, createTyposDef } from './util.mjs';
+function assertString(v) {
+    assert(typeof v === 'string', 'A string was expected.');
+    return true;
+}
+const suggestionsSeparator = /[,]/;
+const typoSuggestionsSeparator = /:|->/;
+const typoEntrySeparator = /[\n;]/;
+const inlineComment = /#.*/gm;
+export function createTyposDefFromEntries(entries) {
+    const def = Object.create(null);
+    for (const entry of entries) {
+        appendToDef(def, entry);
+    }
+    return def;
+}
+function normalize(s) {
+    return s.normalize();
+}
+function trimAndFilter(lines) {
+    return lines
+        .map((s) => s.trim())
+        .filter((s) => !!s)
+        .map(normalize);
+}
+function cleanSugs(rawSugs) {
+    const sugs = trimAndFilter(rawSugs);
+    return sugs.length === 1 ? sugs[0] : sugs.length ? sugs : false;
+}
+function splitSuggestionsValue(value) {
+    return cleanSugs(value.split(suggestionsSeparator));
+}
+export function sanitizeIntoTypoDef(dirtyDef) {
+    if (!dirtyDef || typeof dirtyDef !== 'object')
+        return undefined;
+    const def = createTyposDef();
+    for (const [rawKey, value] of Object.entries(dirtyDef)) {
+        const key = normalize(rawKey.trim());
+        if (!key)
+            continue;
+        if (typeof value === 'string') {
+            def[key] = splitSuggestionsValue(value);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const sugs = cleanSugs(value.filter(assertString));
+            def[key] = sugs;
+            continue;
+        }
+        assert(value === false, 'Unexpected suggestion type.');
+        def[key] = false;
+    }
+    return def;
+}
+/**
+ * Parse Typos Entries
+ *
+ * Format:
+ * - `word:suggestion`
+ * - `word->suggestion`
+ * - `word: first, second, third suggestions`
+ *
+ * Note:
+ * ```plaintext
+ * yellow:blue, green
+ * ```
+ * Is the same as multiple entries with the same key and different suggestions.
+ * ```plaintext
+ * yellow:blue
+ * yellow:green
+ * ```
+ *
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+export function processEntriesToTyposDef(entries) {
+    const def = isIterable(entries) ? reduceToTyposDef(entries) : entries;
+    const result = sanitizeIntoTypoDef(def);
+    assert(result);
+    return result;
+}
+function reduceToTyposDef(entries) {
+    const def = createTyposDef();
+    for (const entry of entries) {
+        appendToDef(def, parseTyposLine(entry));
+    }
+    return def;
+}
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+export function parseTyposLine(line) {
+    if (!line)
+        return undefined;
+    if (typeof line === 'string') {
+        const def = createTyposDef();
+        for (const subEntry of splitIntoLines(line)) {
+            const [left, right] = splitEntry(subEntry);
+            const typo = left.trim();
+            if (!right)
+                return typo;
+            const sugs = splitSuggestionsValue(right);
+            def[typo] = sugs;
+        }
+        return def;
+    }
+    if (Array.isArray(line)) {
+        const [key, ...sugs] = line.filter(assertString).map((s) => s.trim());
+        if (!key)
+            return undefined;
+        return [key, ...sugs];
+    }
+    return sanitizeIntoTypoDef(line);
+}
+function splitIntoLines(content) {
+    return trimAndFilter(normalize(content).split(typoEntrySeparator));
+}
+function splitEntry(line) {
+    return line.split(typoSuggestionsSeparator, 2);
+}
+export function parseTyposFile(content) {
+    const lines = splitIntoLines(content.replace(inlineComment, ''));
+    return reduceToTyposDef(lines);
+}
+function isIterable(v) {
+    return Symbol.iterator in v;
+}

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

@@ -0,0 +1,31 @@
+import type { TypoEntry, TyposDef, TyposDefKey, TyposDefValue } from './typos.mjs';
+export declare function mergeDefEntry(targetDef: TyposDef, key: string, value: TyposDefValue): TyposDef;
+/**
+ * Merge in place the entries `fromDef` into `targetDef`
+ * @param targetDef - the target
+ * @param fromDef - the source
+ * @returns the target
+ */
+export declare function mergeDef(targetDef: TyposDef, fromDef: TyposDef): TyposDef;
+/**
+ * Append an entry to a TyposDef.
+ * @param def - modified in place
+ * @param entry- entry to add.
+ * @returns def
+ */
+export declare function appendToDef(def: TyposDef, entry: TypoEntry | undefined): TyposDef;
+export declare function createTyposDef(entries?: Iterable<[TyposDefKey, TyposDefValue]>): TyposDef;
+/**
+ * Extract all suggestions.
+ * @param typosDef - the def
+ * @returns the set of suggestions.
+ */
+export declare function extractAllSuggestions(typosDef: TyposDef): Set<string>;
+/**
+ * Extract all words that have been explicitly ignore because they contains the `ignorePrefix`.
+ * @param typosDef - the def
+ * @param ignorePrefix - prefix
+ * @returns set of ignored words with the prefix removed.
+ */
+export declare function extractIgnoreValues(typosDef: TyposDef, ignorePrefix: string): Set<string>;
+//# sourceMappingURL=util.d.mts.map