cspell-dictionary 6.14.2 → 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

@@ -35,7 +35,7 @@ class IgnoreWordsDictionary {
         this.source = source;
         this.containsNoSuggestWords = true;
         this.options = {};
-        this.type = 'forbidden';
+        this.type = 'ignore';
         this.isDictionaryCaseSensitive = true;
         this.dict = new Set(words);
         this.dictNonStrict = new Set((0, sync_1.pipe)(this.dict, (0, sync_1.opFilter)((w) => w.startsWith('~')), (0, sync_1.opMap)((w) => w.slice(1))));
@@ -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 {
@@ -35,7 +43,7 @@ export interface SuggestOptions {
      */
     timeout?: number;
 }
-export declare type FindOptions = SearchOptions;
+export type FindOptions = SearchOptions;
 export interface FindResult {
     /** the text found, otherwise `false` */
     found: string | false;
@@ -44,7 +52,8 @@ export interface FindResult {
     /** `true` if it is a no-suggest word. */
     noSuggest: boolean;
 }
-export declare type HasOptions = SearchOptions;
+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 declare type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
-export declare type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
+export 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>;

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/index.d.ts

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

package/dist/SpellingDictionary/Typos/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAllSuggestions = exports.createTyposDef = exports.processEntriesToTyposDef = exports.parseTyposLine = exports.parseTyposFile = void 0;
+var typosParser_1 = require("./typosParser");
+Object.defineProperty(exports, "parseTyposFile", { enumerable: true, get: function () { return typosParser_1.parseTyposFile; } });
+Object.defineProperty(exports, "parseTyposLine", { enumerable: true, get: function () { return typosParser_1.parseTyposLine; } });
+Object.defineProperty(exports, "processEntriesToTyposDef", { enumerable: true, get: function () { return typosParser_1.processEntriesToTyposDef; } });
+var util_1 = require("./util");
+Object.defineProperty(exports, "createTyposDef", { enumerable: true, get: function () { return util_1.createTyposDef; } });
+Object.defineProperty(exports, "extractAllSuggestions", { enumerable: true, get: function () { return util_1.extractAllSuggestions; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,18 @@
+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 TypoWithNoSuggestions = string;
+type TypoWithSuggestionsArray = [forbidWord: string, ...suggestions: string[]];
+type TypoWithSuggestionsObj = TyposDef;
+type TypoWithSuggestions = TypoWithSuggestionsArray | TypoWithSuggestionsObj;
+export type TypoEntry = TypoWithNoSuggestions | TypoWithSuggestions;
+export {};
+//# sourceMappingURL=typos.d.ts.map

package/dist/SpellingDictionary/Typos/typos.js

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

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

@@ -0,0 +1,17 @@
+import { TypoEntry, TyposDef } from './typos';
+export declare function createTyposDefFromEntries(entries: Iterable<TypoEntry>): TyposDef;
+export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string, unknown> | unknown): TyposDef | undefined;
+/**
+ * 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.ts.map

package/dist/SpellingDictionary/Typos/typosParser.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTyposFile = exports.parseTyposLine = exports.processEntriesToTyposDef = exports.sanitizeIntoTypoDef = exports.createTyposDefFromEntries = void 0;
+const assert_1 = __importDefault(require("assert"));
+const util_1 = require("./util");
+function assertString(v) {
+    (0, assert_1.default)(typeof v === 'string', 'A string was expected.');
+    return true;
+}
+const suggestionsSeparator = /[,]/;
+const typoSuggestionsSeparator = /:|->/;
+const typoEntrySeparator = /[\n;]/;
+const inlineComment = /#.*/gm;
+function createTyposDefFromEntries(entries) {
+    const def = Object.create(null);
+    for (const entry of entries) {
+        (0, util_1.appendToDef)(def, entry);
+    }
+    return def;
+}
+exports.createTyposDefFromEntries = createTyposDefFromEntries;
+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));
+}
+function sanitizeIntoTypoDef(dirtyDef) {
+    if (!dirtyDef || typeof dirtyDef !== 'object')
+        return undefined;
+    const def = (0, util_1.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;
+        }
+        (0, assert_1.default)(value === false, 'Unexpected suggestion type.');
+        def[key] = false;
+    }
+    return def;
+}
+exports.sanitizeIntoTypoDef = sanitizeIntoTypoDef;
+/**
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+function processEntriesToTyposDef(entries) {
+    const def = isIterable(entries) ? reduceToTyposDef(entries) : entries;
+    const result = sanitizeIntoTypoDef(def);
+    (0, assert_1.default)(result);
+    return result;
+}
+exports.processEntriesToTyposDef = processEntriesToTyposDef;
+function reduceToTyposDef(entries) {
+    const def = (0, util_1.createTyposDef)();
+    for (const entry of entries) {
+        (0, util_1.appendToDef)(def, parseTyposLine(entry));
+    }
+    return def;
+}
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+function parseTyposLine(line) {
+    if (!line)
+        return undefined;
+    if (typeof line === 'string') {
+        const def = (0, util_1.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);
+}
+exports.parseTyposLine = parseTyposLine;
+function splitIntoLines(content) {
+    return trimAndFilter(normalize(content).split(typoEntrySeparator));
+}
+function splitEntry(line) {
+    return line.split(typoSuggestionsSeparator, 2);
+}
+function parseTyposFile(content) {
+    const lines = splitIntoLines(content.replace(inlineComment, ''));
+    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

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

package/dist/SpellingDictionary/Typos/util.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractIgnoreValues = exports.extractAllSuggestions = exports.createTyposDef = exports.appendToDef = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+/**
+ * Append an entry to a TyposDef.
+ * @param def - modified in place
+ * @param entry- entry to add.
+ * @returns def
+ */
+function appendToDef(def, entry) {
+    if (!entry)
+        return def;
+    if (typeof entry === 'string') {
+        def[entry] = false;
+        return def;
+    }
+    if (Array.isArray(entry)) {
+        const [key, ...sugs] = entry.map((s) => s.trim());
+        if (!key)
+            return def;
+        const s = sugs.map((s) => s.trim()).filter((s) => !!s);
+        def[key] = !s.length ? false : s.length === 1 ? s[0] : s;
+        return def;
+    }
+    Object.assign(def, entry);
+    return def;
+}
+exports.appendToDef = appendToDef;
+function createTyposDef(entries) {
+    const def = Object.create(null);
+    if (!entries)
+        return def;
+    for (const [key, value] of entries) {
+        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)(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 pfxLen = ignorePrefix.length;
+    return new Set(Object.keys(typosDef)
+        .filter((k) => k.startsWith(ignorePrefix))
+        .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

@@ -0,0 +1,21 @@
+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 - name of dictionary
+ * @param source - source
+ * @returns
+ */
+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

@@ -0,0 +1,152 @@
+"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");
+class TyposDictionaryImpl {
+    constructor(name, source, typosDef, ignoreList) {
+        this.name = name;
+        this.source = source;
+        this.typosDef = typosDef;
+        this.options = {};
+        this.type = 'typos';
+        this.isDictionaryCaseSensitive = true;
+        this.size = Object.keys(typosDef).length;
+        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.
+     * 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 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, ignoreCaseAndAccents) {
+        const lcWord = word.toLowerCase();
+        if (this.ignoreWords.has(word)) {
+            return { found: word, ignore: true };
+        }
+        if (this.suggestions.has(word)) {
+            return false;
+        }
+        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 { found: word, ignore: false };
+        if (lcWord in this.typosDef)
+            return { found: lcWord, ignore: false };
+        return false;
+    }
+    isForbidden(word, ignoreCaseAndAccents = defaults.isForbiddenIgnoreCaseAndAccents) {
+        const found = this._findForms(word, ignoreCaseAndAccents);
+        return found !== false && !found.ignore;
+    }
+    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()) || [];
+    }
+    _suggest(word) {
+        if (this.ignoreWords.has(word))
+            return [];
+        if (!(word in this.typosDef))
+            return undefined;
+        const sug = this.typosDef[word];
+        if (!sug)
+            return [];
+        if (typeof sug === 'string') {
+            return [
+                {
+                    word: sug,
+                    cost: 1,
+                    isPreferred: true,
+                },
+            ];
+        }
+        return sug.map((word, index) => ({ word, cost: index + 1 }));
+    }
+    genSuggestions(collector) {
+        const sugs = this.suggest(collector.word);
+        sugs.forEach((result) => collector.add(result));
+    }
+    mapWord(word) {
+        return word;
+    }
+    getErrors() {
+        return [];
+    }
+}
+/**
+ * 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
+ */
+function createTyposDictionary(entries, name, source) {
+    const def = (0, Typos_1.processEntriesToTyposDef)(entries);
+    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/repMap.d.ts

@@ -1,5 +1,5 @@
 import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
-export declare type ReplaceMapper = (src: string) => string;
+export type ReplaceMapper = (src: string) => string;
 export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper;
 declare function charsetToRepMap(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
 declare function createMapperRegExp(repMap: ReplaceMap): RegExp;

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/dist/util/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Like Required, but keeps the Optional.
  */
-export declare type RemoveUndefined<T> = {
+export type RemoveUndefined<T> = {
     [P in keyof T]: Exclude<T[P], undefined>;
 };
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.14.2",
+  "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",
@@ -38,16 +38,16 @@
     "node": ">=14"
   },
   "devDependencies": {
-    "@types/jest": "^29.2.2",
+    "@types/jest": "^29.2.3",
     "jest": "^29.3.1",
     "ts-jest": "^29.0.3"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.14.2",
-    "@cspell/cspell-types": "6.14.2",
-    "cspell-trie-lib": "6.14.2",
+    "@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": "ea9692380357e9e890c20f15b1200cc1c6c3a2df"
+  "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