cspell-dictionary 6.14.3 → 6.15.0

package/dist/SpellingDictionary/{ForbiddenWordsDictionary.d.ts → FlagWordsDictionary.d.ts}

@@ -5,7 +5,7 @@ import { SpellingDictionary } from './SpellingDictionary';
  * @param name
  * @param source
  * @param options
- * @returns
+ * @returns SpellingDictionary
  */
-export declare function createForbiddenWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
-//# sourceMappingURL=ForbiddenWordsDictionary.d.ts.map
+export declare function createFlagWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
+//# sourceMappingURL=FlagWordsDictionary.d.ts.map

package/dist/SpellingDictionary/FlagWordsDictionary.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFlagWordsDictionary = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const createSpellingDictionary_1 = require("./createSpellingDictionary");
+const Defaults = __importStar(require("./defaults"));
+const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
+const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+const TyposDictionary_1 = require("./TyposDictionary");
+class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie {
+    constructor(trie, name, source) {
+        super(trie, name, createSpellingDictionary_1.defaultOptions, source);
+        this.name = name;
+        this.source = source;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.isDictionaryCaseSensitive = true;
+    }
+    /**
+     * 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;
+    }
+    find(word, hasOptions) {
+        const f = super.find(word, hasOptions);
+        if (!f || !f.forbidden)
+            return undefined;
+        return f;
+    }
+    suggest() {
+        return [];
+    }
+    genSuggestions() {
+        return;
+    }
+}
+class FlagWordsDictionary {
+    constructor(name, source, dictTypos, dictTrie) {
+        this.name = name;
+        this.source = source;
+        this.dictTypos = dictTypos;
+        this.dictTrie = dictTrie;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.type = 'flag-words';
+        this.isDictionaryCaseSensitive = true;
+    }
+    /**
+     * 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 this.dictTypos.has(word, options) || this.dictTrie?.has(word, options) || false;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, options) {
+        const findTypos = this.dictTypos.find(word, options);
+        if (findTypos)
+            return findTypos;
+        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
+        if (this.dictTypos.isSuggestedWord(word, ignoreCase))
+            return undefined;
+        return this.dictTrie?.find(word, options);
+    }
+    isForbidden(word, ignoreCaseAndAccents = Defaults.isForbiddenIgnoreCaseAndAccents) {
+        const findResult = this.find(word, { ignoreCase: ignoreCaseAndAccents });
+        return findResult?.forbidden || false;
+    }
+    isNoSuggestWord(word, options) {
+        return this.dictTrie?.isNoSuggestWord(word, options) || this.dictTypos.isNoSuggestWord(word, options);
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
+        return this.dictTypos.suggest(word, suggestOptions);
+    }
+    genSuggestions() {
+        return;
+    }
+    mapWord(word) {
+        return word;
+    }
+    get size() {
+        return this.dictTypos.size + (this.dictTrie?.size || 0);
+    }
+    getErrors() {
+        return [];
+    }
+}
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param wordList - list of words
+ * @param name
+ * @param source
+ * @param options
+ * @returns SpellingDictionary
+ */
+function createFlagWordsDictionary(wordList, name, source) {
+    const testSpecialCharacters = /[~*+]/;
+    const { t: specialWords, f: typoWords } = bisect((0, cspell_trie_lib_1.parseDictionaryLines)(wordList, { stripCaseAndAccents: false }), (line) => testSpecialCharacters.test(line));
+    const trieDict = specialWords.size ? buildTrieDict(specialWords, name, source) : undefined;
+    const typosDict = (0, TyposDictionary_1.createTyposDictionary)(typoWords, name, source);
+    if (!trieDict)
+        return typosDict;
+    return new FlagWordsDictionary(name, source, typosDict, trieDict);
+}
+exports.createFlagWordsDictionary = createFlagWordsDictionary;
+const regExpCleanIgnore = /^(!!)+/;
+function buildTrieDict(words, name, source) {
+    const trie = (0, cspell_trie_lib_1.buildTrieFast)((0, sync_1.pipe)(words, (0, sync_1.opMap)((w) => '!' + w), (0, sync_1.opMap)((w) => w.replace(regExpCleanIgnore, ''))));
+    return new FlagWordsDictionaryTrie(trie, name, source);
+}
+function bisect(values, predicate) {
+    const t = new Set();
+    const f = new Set();
+    for (const v of values) {
+        if (predicate(v)) {
+            t.add(v);
+        }
+        else {
+            f.add(v);
+        }
+    }
+    return { t, f };
+}
+//# sourceMappingURL=FlagWordsDictionary.js.map

package/dist/SpellingDictionary/IgnoreWordsDictionary.js

@@ -72,7 +72,7 @@ class IgnoreWordsDictionary {
             return { found: nWord, forbidden: false, noSuggest: true };
         return (this.dictNonStrict.has(lcWord) && { found: lcWord, forbidden: false, noSuggest: true }) || undefined;
     }
-    isForbidden(_word) {
+    isForbidden(_word, _ignoreCase) {
         return false;
     }
     isNoSuggestWord(word, options) {

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -2,7 +2,15 @@ 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 {
+    /**
+     * Legacy compounds have been deprecated.
+     *
+     * @deprecated
+     */
     useCompounds?: boolean | number | undefined;
+    /**
+     * Ignore Case and Accents
+     */
     ignoreCase?: boolean | undefined;
 }
 export interface SuggestOptions {
@@ -45,6 +53,7 @@ export interface FindResult {
     noSuggest: boolean;
 }
 export type HasOptions = SearchOptions;
+export type IgnoreCaseOption = boolean;
 export interface SpellingDictionaryOptions {
     repMap?: ReplaceMap;
     /**
@@ -94,9 +103,33 @@ export interface SpellingDictionary extends DictionaryInfo {
     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;
+    /**
+     * 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;
@@ -104,4 +137,5 @@ export interface SpellingDictionary extends DictionaryInfo {
     readonly isDictionaryCaseSensitive: boolean;
     getErrors?(): Error[];
 }
+export type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
 //# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -6,7 +6,7 @@ export interface SpellingDictionaryCollection extends SpellingDictionary {
 }
 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;
+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;

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -1,10 +1,34 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.isSpellingDictionaryCollection = exports.createCollection = 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 util_1 = require("../util/util");
+const Defaults = __importStar(require("./defaults"));
 const SpellingDictionary_1 = require("./SpellingDictionary");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 function identityString(w) {
@@ -17,7 +41,6 @@ class SpellingDictionaryCollectionImpl {
         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;
@@ -34,14 +57,14 @@ class SpellingDictionaryCollectionImpl {
     }
     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 };
+        return findInAnyDictionary(this.dictionaries, word, options);
     }
     isNoSuggestWord(word, options) {
         return this._isNoSuggestWord(word, options);
     }
-    isForbidden(word) {
-        return !!this._isForbiddenInDict(word) && !this.isNoSuggestWord(word);
+    isForbidden(word, ignoreCaseAndAccents) {
+        const ignoreCase = ignoreCaseAndAccents ?? Defaults.isForbiddenIgnoreCaseAndAccents;
+        return !!this._isForbiddenInDict(word, ignoreCase) && !this.isNoSuggestWord(word, { ignoreCase });
     }
     suggest(...args) {
         const [word] = args;
@@ -79,6 +102,9 @@ class SpellingDictionaryCollectionImpl {
     getErrors() {
         return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
     }
+    _isForbiddenInDict(word, ignoreCase) {
+        return isWordForbiddenInAnyDictionary(this.dictionaries, word, ignoreCase);
+    }
 }
 function createCollection(dictionaries, name) {
     return new SpellingDictionaryCollectionImpl(dictionaries, name);
@@ -100,8 +126,8 @@ function findInAnyDictionary(dicts, word, options) {
 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));
+function isWordForbiddenInAnyDictionary(dicts, word, ignoreCase) {
+    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isForbidden(word, ignoreCase));
 }
 function isSpellingDictionaryCollection(dict) {
     return dict instanceof SpellingDictionaryCollectionImpl;

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -24,7 +24,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     private findAnyForm;
     private _findAnyForm;
     isNoSuggestWord(word: string, options?: HasOptions): boolean;
-    isForbidden(word: string): 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[];

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -24,13 +24,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.createSpellingDictionaryFromTrieFile = exports.SpellingDictionaryFromTrie = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const repMap_1 = require("../util/repMap");
-const clean_1 = require("../util/clean");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 const AutoCache_1 = require("../util/AutoCache");
-const sync_1 = require("@cspell/cspell-pipe/sync");
+const clean_1 = require("../util/clean");
+const repMap_1 = require("../util/repMap");
 const Defaults = __importStar(require("./defaults"));
+const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
 const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
 class SpellingDictionaryFromTrie {
@@ -124,7 +124,7 @@ class SpellingDictionaryFromTrie {
     isNoSuggestWord(word, options) {
         return this.containsNoSuggestWords ? this.has(word, options) : false;
     }
-    isForbidden(word) {
+    isForbidden(word, _ignoreCaseAndAccents) {
         return this._isForbidden(word);
     }
     suggest(...args) {

package/dist/SpellingDictionary/SpellingDictionaryMethods.d.ts

@@ -1,9 +1,8 @@
 import { DictionaryInformation } from '@cspell/cspell-types';
-import { CompoundWordsMethod, SuggestionResult, WeightMap } from 'cspell-trie-lib';
-import { HasOptions, SearchOptions, SpellingDictionary, SuggestOptions } from './SpellingDictionary';
+import { SuggestionResult, WeightMap } from 'cspell-trie-lib';
+import { HasOptions, SearchOptions, SuggestArgs, SuggestOptions } from './SpellingDictionary';
 export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
 export type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
-export 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>;

package/dist/SpellingDictionary/Terms/index.d.ts

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

package/dist/SpellingDictionary/Terms/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/SpellingDictionary/Terms/terms.d.ts

@@ -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.ts.map

package/dist/SpellingDictionary/Terms/terms.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=terms.js.map

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

@@ -1,18 +1,18 @@
-type NoSuggestion = null | undefined;
-type SingleSuggestion = string;
-type MultipleSuggestions = string[];
-export type TyposDefValue = MultipleSuggestions | SingleSuggestion | NoSuggestion;
-export type TyposDefKey = string;
+import type { TermsDefKey, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions } from '../Terms';
+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 TypoNoSuggestions = string;
+type TypoWithNoSuggestions = string;
 type TypoWithSuggestionsArray = [forbidWord: string, ...suggestions: string[]];
 type TypoWithSuggestionsObj = TyposDef;
 type TypoWithSuggestions = TypoWithSuggestionsArray | TypoWithSuggestionsObj;
-export type TypoEntry = TypoNoSuggestions | TypoWithSuggestions;
+export type TypoEntry = TypoWithNoSuggestions | TypoWithSuggestions;
 export {};
 //# sourceMappingURL=typos.d.ts.map

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

@@ -6,7 +6,7 @@ export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string,
  * @param entries - entries to process
  * @returns a TyposDef
  */
-export declare function processEntriesToTyposDef(entries: TyposDef | readonly TypoEntry[] | Record<string, unknown>): TyposDef;
+export declare function processEntriesToTyposDef(entries: Iterable<TypoEntry> | TyposDef | Record<string, unknown>): TyposDef;
 /**
  * Tries to parse an entry.
  * @param line - any valid TypoEntry.

package/dist/SpellingDictionary/Typos/typosParser.js

@@ -33,7 +33,7 @@ function trimAndFilter(lines) {
 }
 function cleanSugs(rawSugs) {
     const sugs = trimAndFilter(rawSugs);
-    return sugs.length === 1 ? sugs[0] : sugs.length ? sugs : null;
+    return sugs.length === 1 ? sugs[0] : sugs.length ? sugs : false;
 }
 function splitSuggestionsValue(value) {
     return cleanSugs(value.split(suggestionsSeparator));
@@ -55,8 +55,8 @@ function sanitizeIntoTypoDef(dirtyDef) {
             def[key] = sugs;
             continue;
         }
-        (0, assert_1.default)(value === null || value === undefined, 'Unexpected suggestion type.');
-        def[key] = null;
+        (0, assert_1.default)(value === false, 'Unexpected suggestion type.');
+        def[key] = false;
     }
     return def;
 }
@@ -67,7 +67,7 @@ exports.sanitizeIntoTypoDef = sanitizeIntoTypoDef;
  * @returns a TyposDef
  */
 function processEntriesToTyposDef(entries) {
-    const def = Array.isArray(entries) ? reduceToTyposDef(entries) : entries;
+    const def = isIterable(entries) ? reduceToTyposDef(entries) : entries;
     const result = sanitizeIntoTypoDef(def);
     (0, assert_1.default)(result);
     return result;
@@ -120,4 +120,7 @@ function parseTyposFile(content) {
     return reduceToTyposDef(lines);
 }
 exports.parseTyposFile = parseTyposFile;
+function isIterable(v) {
+    return Symbol.iterator in v;
+}
 //# sourceMappingURL=typosParser.js.map

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

@@ -7,6 +7,17 @@ import { TypoEntry, TyposDef, TyposDefKey, TyposDefValue } from './typos';
  */
 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.ts.map

package/dist/SpellingDictionary/Typos/util.js

@@ -12,7 +12,7 @@ function appendToDef(def, entry) {
     if (!entry)
         return def;
     if (typeof entry === 'string') {
-        def[entry] = null;
+        def[entry] = false;
         return def;
     }
     if (Array.isArray(entry)) {
@@ -20,7 +20,7 @@ function appendToDef(def, entry) {
         if (!key)
             return def;
         const s = sugs.map((s) => s.trim()).filter((s) => !!s);
-        def[key] = !s.length ? null : s.length === 1 ? s[0] : s;
+        def[key] = !s.length ? false : s.length === 1 ? s[0] : s;
         return def;
     }
     Object.assign(def, entry);
@@ -32,26 +32,44 @@ function createTyposDef(entries) {
     if (!entries)
         return def;
     for (const [key, value] of entries) {
-        def[key] = value;
+        def[key] = isDefined(value) ? value : false;
     }
     return def;
 }
 exports.createTyposDef = createTyposDef;
+/**
+ * Extract all suggestions.
+ * @param typosDef - the def
+ * @returns the set of suggestions.
+ */
 function extractAllSuggestions(typosDef) {
-    const allSugs = (0, sync_1.pipe)(Object.values(typosDef), (0, sync_1.opFilter)(isDefined), (0, sync_1.opConcatMap)((v) => (Array.isArray(v) ? v : [v])));
+    const allSugs = (0, sync_1.pipe)(Object.values(typosDef), (0, sync_1.opFilter)(hasSuggestions), (0, sync_1.opConcatMap)((v) => (Array.isArray(v) ? v : [v])));
     return new Set(allSugs);
 }
 exports.extractAllSuggestions = extractAllSuggestions;
+/**
+ * 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.
+ */
 function extractIgnoreValues(typosDef, ignorePrefix) {
-    const sugs = extractAllSuggestions(typosDef);
     const pfxLen = ignorePrefix.length;
-    const ignoreKeys = Object.keys(typosDef)
+    return new Set(Object.keys(typosDef)
         .filter((k) => k.startsWith(ignorePrefix))
-        .map((k) => k.slice(pfxLen));
-    return (0, sync_1.reduce)(ignoreKeys, (sugs, word) => sugs.add(word), sugs);
+        .map((k) => k.slice(pfxLen)));
 }
 exports.extractIgnoreValues = extractIgnoreValues;
 function isDefined(v) {
     return v !== undefined && v !== null;
 }
+function isString(v) {
+    return typeof v === 'string';
+}
+function isArray(v) {
+    return Array.isArray(v);
+}
+function hasSuggestions(v) {
+    return isString(v) || isArray(v);
+}
 //# sourceMappingURL=util.js.map

package/dist/SpellingDictionary/TyposDictionary.d.ts

@@ -1,12 +1,21 @@
-import { SpellingDictionary } from './SpellingDictionary';
+import { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary';
 import { type TypoEntry, type TyposDef } from './Typos';
+export interface TyposDictionary extends SpellingDictionary {
+    isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+    /**
+     * 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
- * @param source
- * @param options
+ * @param name - name of dictionary
+ * @param source - source
  * @returns
  */
-export declare function createTyposDictionary(entries: string[] | TyposDef | readonly TypoEntry[], name: string, source: string): SpellingDictionary;
+export declare function createTyposDictionary(entries: readonly string[] | TyposDef | Iterable<TypoEntry>, name: string, source: string): TyposDictionary;
 //# sourceMappingURL=TyposDictionary.d.ts.map

package/dist/SpellingDictionary/TyposDictionary.js

@@ -1,21 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTyposDictionary = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
+const textMappers_1 = require("../util/textMappers");
+const defaults = __importStar(require("./defaults"));
 const Typos_1 = require("./Typos");
 const util_1 = require("./Typos/util");
-const symIgnore = Symbol('ignored');
-class TyposDictionary {
+class TyposDictionaryImpl {
     constructor(name, source, typosDef, ignoreList) {
         this.name = name;
         this.source = source;
         this.typosDef = typosDef;
-        this.containsNoSuggestWords = false;
         this.options = {};
         this.type = 'typos';
         this.isDictionaryCaseSensitive = true;
         this.size = Object.keys(typosDef).length;
-        this.ignoreWords = new Set((0, sync_1.pipe)((0, util_1.extractIgnoreValues)(typosDef, '!'), (0, sync_1.opAppend)(ignoreList || [])));
+        this.explicitIgnoreWords = (0, util_1.extractIgnoreValues)(typosDef, '!');
+        this.suggestions = (0, util_1.extractAllSuggestions)(typosDef);
+        this.ignoreWords = new Set((0, sync_1.pipe)(this.explicitIgnoreWords, (0, sync_1.opAppend)(ignoreList || [])));
+        this.suggestionsLower = new Set((0, sync_1.pipe)(this.suggestions, textMappers_1.mapperRemoveCaseAndAccents));
+        this.containsNoSuggestWords = this.ignoreWords.size > 0;
     }
     /**
      * A Forbidden word list does not "have" valid words.
@@ -28,32 +55,54 @@ class TyposDictionary {
         return false;
     }
     /** A more detailed search for a word, might take longer than `has` */
-    find(word, _options) {
-        const found = this._findForms(word);
-        return typeof found === 'string' ? { found, forbidden: true, noSuggest: false } : undefined;
+    find(word, options) {
+        const result = this._findForms(word, options?.ignoreCase ?? defaults.ignoreCase);
+        if (result === false)
+            return undefined;
+        const { found, ignore } = result;
+        return { found, forbidden: !ignore, noSuggest: ignore };
     }
-    _findForms(word) {
-        const f = this._find(word);
-        if (f !== false)
-            return f;
+    _findForms(word, ignoreCaseAndAccents) {
         const lcWord = word.toLowerCase();
-        if (lcWord === word)
+        if (this.ignoreWords.has(word)) {
+            return { found: word, ignore: true };
+        }
+        if (this.suggestions.has(word)) {
             return false;
-        return this._find(lcWord);
-    }
-    _find(word) {
-        if (this.ignoreWords.has(word))
-            return symIgnore;
+        }
+        if (ignoreCaseAndAccents) {
+            if (this.suggestionsLower.has(lcWord)) {
+                return false;
+            }
+            if (this.ignoreWords.has(lcWord)) {
+                return { found: lcWord, ignore: true };
+            }
+        }
         if (word in this.typosDef)
-            return word;
+            return { found: word, ignore: false };
+        if (lcWord in this.typosDef)
+            return { found: lcWord, ignore: false };
         return false;
     }
-    isForbidden(word) {
-        const found = this._findForms(word);
-        return typeof found === 'string';
+    isForbidden(word, ignoreCaseAndAccents = defaults.isForbiddenIgnoreCaseAndAccents) {
+        const found = this._findForms(word, ignoreCaseAndAccents);
+        return found !== false && !found.ignore;
     }
-    isNoSuggestWord(_word, _options) {
-        return false;
+    isNoSuggestWord(word, options) {
+        const result = this.find(word, options);
+        return result?.noSuggest ?? 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()) || [];
@@ -91,14 +140,13 @@ class TyposDictionary {
 /**
  * Create a dictionary where all words are to be forbidden.
  * @param entries - list of Typos Entries
- * @param name
- * @param source
- * @param options
+ * @param name - name of dictionary
+ * @param source - source
  * @returns
  */
 function createTyposDictionary(entries, name, source) {
     const def = (0, Typos_1.processEntriesToTyposDef)(entries);
-    return new TyposDictionary(name, source, def);
+    return new TyposDictionaryImpl(name, source, def);
 }
 exports.createTyposDictionary = createTyposDictionary;
 //# sourceMappingURL=TyposDictionary.js.map

package/dist/SpellingDictionary/defaults.d.ts

@@ -1,2 +1,3 @@
-export declare const ignoreCase = true;
+export declare const ignoreCase: true;
+export declare const isForbiddenIgnoreCaseAndAccents: false;
 //# sourceMappingURL=defaults.d.ts.map

package/dist/SpellingDictionary/defaults.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ignoreCase = void 0;
+exports.isForbiddenIgnoreCaseAndAccents = exports.ignoreCase = void 0;
 exports.ignoreCase = true;
+exports.isForbiddenIgnoreCaseAndAccents = false;
 //# sourceMappingURL=defaults.js.map

package/dist/SpellingDictionary/index.d.ts

@@ -1,8 +1,9 @@
 export { CachingDictionary, createCachingDictionary } from './CachingDictionary';
-export { createSpellingDictionary, createFailedToLoadDictionary } from './createSpellingDictionary';
-export { createForbiddenWordsDictionary } from './ForbiddenWordsDictionary';
+export { createFailedToLoadDictionary, createSpellingDictionary } from './createSpellingDictionary';
+export { createFlagWordsDictionary, createFlagWordsDictionary as createForbiddenWordsDictionary, } from './FlagWordsDictionary';
 export { createIgnoreWordsDictionary } from './IgnoreWordsDictionary';
 export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
 export { createCollection, SpellingDictionaryCollection } from './SpellingDictionaryCollection';
 export { createSpellingDictionaryFromTrieFile } from './SpellingDictionaryFromTrie';
+export { createTyposDictionary } from './TyposDictionary';
 //# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/index.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionaryFromTrieFile = exports.createCollection = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = exports.createFailedToLoadDictionary = exports.createSpellingDictionary = exports.createCachingDictionary = void 0;
+exports.createTyposDictionary = exports.createSpellingDictionaryFromTrieFile = exports.createCollection = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = exports.createFlagWordsDictionary = exports.createSpellingDictionary = exports.createFailedToLoadDictionary = exports.createCachingDictionary = void 0;
 var CachingDictionary_1 = require("./CachingDictionary");
 Object.defineProperty(exports, "createCachingDictionary", { enumerable: true, get: function () { return CachingDictionary_1.createCachingDictionary; } });
 var createSpellingDictionary_1 = require("./createSpellingDictionary");
-Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createSpellingDictionary; } });
 Object.defineProperty(exports, "createFailedToLoadDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createFailedToLoadDictionary; } });
-var ForbiddenWordsDictionary_1 = require("./ForbiddenWordsDictionary");
-Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return ForbiddenWordsDictionary_1.createForbiddenWordsDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createSpellingDictionary; } });
+var FlagWordsDictionary_1 = require("./FlagWordsDictionary");
+Object.defineProperty(exports, "createFlagWordsDictionary", { enumerable: true, get: function () { return FlagWordsDictionary_1.createFlagWordsDictionary; } });
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return FlagWordsDictionary_1.createFlagWordsDictionary; } });
 var IgnoreWordsDictionary_1 = require("./IgnoreWordsDictionary");
 Object.defineProperty(exports, "createIgnoreWordsDictionary", { enumerable: true, get: function () { return IgnoreWordsDictionary_1.createIgnoreWordsDictionary; } });
 var SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
 Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionaryCollection_1.createCollection; } });
 var SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
 Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return SpellingDictionaryFromTrie_1.createSpellingDictionaryFromTrieFile; } });
+var TyposDictionary_1 = require("./TyposDictionary");
+Object.defineProperty(exports, "createTyposDictionary", { enumerable: true, get: function () { return TyposDictionary_1.createTyposDictionary; } });
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, SpellingDictionaryCollection, } from './SpellingDictionary';
-export type { CachingDictionary, FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
+export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createFlagWordsDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from './SpellingDictionary';
+export type { CachingDictionary, FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionaryFromTrieFile = exports.createSpellingDictionary = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = exports.createFailedToLoadDictionary = exports.createCollection = exports.createCachingDictionary = void 0;
+exports.createSpellingDictionaryFromTrieFile = exports.createSpellingDictionary = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = exports.createFlagWordsDictionary = exports.createFailedToLoadDictionary = exports.createCollection = exports.createCachingDictionary = void 0;
 var SpellingDictionary_1 = require("./SpellingDictionary");
 Object.defineProperty(exports, "createCachingDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createCachingDictionary; } });
 Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionary_1.createCollection; } });
 Object.defineProperty(exports, "createFailedToLoadDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createFailedToLoadDictionary; } });
+Object.defineProperty(exports, "createFlagWordsDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createFlagWordsDictionary; } });
 Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createForbiddenWordsDictionary; } });
 Object.defineProperty(exports, "createIgnoreWordsDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createIgnoreWordsDictionary; } });
 Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionary; } });

package/dist/util/textMappers.d.ts

@@ -0,0 +1,3 @@
+export declare function mapperNormalizeNFC(words: Iterable<string>): Iterable<string>;
+export declare function mapperRemoveCaseAndAccents(words: Iterable<string>): Iterable<string>;
+//# sourceMappingURL=textMappers.d.ts.map

package/dist/util/textMappers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapperRemoveCaseAndAccents = exports.mapperNormalizeNFC = void 0;
+const text_1 = require("./text");
+function* mapperNormalizeNFC(words) {
+    for (const word of words) {
+        yield word.normalize('NFC');
+    }
+}
+exports.mapperNormalizeNFC = mapperNormalizeNFC;
+function* mapperRemoveCaseAndAccents(words) {
+    for (const word of words) {
+        const lc = word.toLowerCase();
+        yield lc;
+        const woAccents = (0, text_1.removeAccents)(lc);
+        if (lc !== woAccents)
+            yield woAccents;
+    }
+}
+exports.mapperRemoveCaseAndAccents = mapperRemoveCaseAndAccents;
+//# sourceMappingURL=textMappers.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.14.3",
+  "version": "6.15.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -43,11 +43,11 @@
     "ts-jest": "^29.0.3"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.14.3",
-    "@cspell/cspell-types": "6.14.3",
-    "cspell-trie-lib": "6.14.3",
+    "@cspell/cspell-pipe": "6.15.0",
+    "@cspell/cspell-types": "6.15.0",
+    "cspell-trie-lib": "6.15.0",
     "fast-equals": "^4.0.3",
     "gensequence": "^4.0.2"
   },
-  "gitHead": "df0efdbb0dc7b084579130ba5fe97441c0ab67ca"
+  "gitHead": "8bbc20a6fabe0b95caafb7dac2035764cc73ba13"
 }

package/dist/SpellingDictionary/ForbiddenWordsDictionary.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createForbiddenWordsDictionary = void 0;
-const cspell_trie_lib_1 = require("cspell-trie-lib");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
-class ForbiddenWordsDictionaryTrie extends SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie {
-    constructor(trie, name, source) {
-        super(trie, name, createSpellingDictionary_1.defaultOptions, source);
-        this.name = name;
-        this.source = source;
-        this.containsNoSuggestWords = false;
-        this.options = {};
-        this.isDictionaryCaseSensitive = true;
-    }
-    /**
-     * 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;
-    }
-    find(word, hasOptions) {
-        const f = super.find(word, hasOptions);
-        if (!f || !f.forbidden)
-            return undefined;
-        return f;
-    }
-    suggest() {
-        return [];
-    }
-    genSuggestions() {
-        return;
-    }
-}
-class ForbiddenWordsDictionary {
-    constructor(name, source, words) {
-        this.name = name;
-        this.source = source;
-        this.containsNoSuggestWords = false;
-        this.options = {};
-        this.type = 'forbidden';
-        this.isDictionaryCaseSensitive = true;
-        this.dict = new Set(words);
-        this.dictIgnore = new Set(words.filter((w) => w.startsWith('!')).map((w) => w.slice(1)));
-    }
-    /**
-     * 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) {
-        const forbidden = this.isForbidden(word);
-        return forbidden ? { found: word, forbidden, noSuggest: false } : undefined;
-    }
-    isForbidden(word) {
-        return (this.dict.has(word) || this.dict.has(word.toLowerCase())) && !this.dictIgnore.has(word);
-    }
-    isNoSuggestWord(_word, _options) {
-        return false;
-    }
-    suggest() {
-        return [];
-    }
-    genSuggestions() {
-        return;
-    }
-    mapWord(word) {
-        return word;
-    }
-    get size() {
-        return this.dict.size;
-    }
-    getErrors() {
-        return [];
-    }
-}
-/**
- * Create a dictionary where all words are to be forbidden.
- * @param wordList - list of words
- * @param name
- * @param source
- * @param options
- * @returns
- */
-function createForbiddenWordsDictionary(wordList, name, source) {
-    const testSpecialCharacters = /[~*+]/;
-    const regExpCleanIgnore = /^(!!)+/;
-    const words = [...(0, cspell_trie_lib_1.parseDictionaryLines)(wordList, { stripCaseAndAccents: false })];
-    const hasSpecial = words.findIndex((word) => testSpecialCharacters.test(word)) >= 0;
-    if (hasSpecial) {
-        const trie = (0, cspell_trie_lib_1.buildTrieFast)(words.map((w) => '!' + w).map((w) => w.replace(regExpCleanIgnore, '')));
-        return new ForbiddenWordsDictionaryTrie(trie, name, source);
-    }
-    return new ForbiddenWordsDictionary(name, source, words);
-}
-exports.createForbiddenWordsDictionary = createForbiddenWordsDictionary;
-//# sourceMappingURL=ForbiddenWordsDictionary.js.map