cspell-dictionary 6.28.0 → 6.29.0

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/createSpellingDictionary.d.ts

@@ -1,5 +1,5 @@
-import type { IterableLike } from '../util/IterableLike';
-import type { DictionaryInfo, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary';
+import type { IterableLike } from '../util/IterableLike.js';
+import type { DictionaryInfo, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary.js';
 /**
  * Create a SpellingDictionary
  * @param wordList - list of words

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/createSpellingDictionary.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFailedToLoadDictionary = exports.createSpellingDictionary = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const fast_equals_1 = require("fast-equals");
-const simpleCache_1 = require("../util/simpleCache");
-const SpellingDictionary_1 = require("./SpellingDictionary");
-const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
-const cachedDictionaries = new simpleCache_1.AutoWeakCache(_createSpellingDictionary, 64);
+const simpleCache_js_1 = require("../util/simpleCache.js");
+const SpellingDictionary_js_1 = require("./SpellingDictionary.js");
+const SpellingDictionaryFromTrie_js_1 = require("./SpellingDictionaryFromTrie.js");
+const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
+const cachedDictionaries = new simpleCache_js_1.AutoWeakCache(_createSpellingDictionary, 64);
 const maxSetSize = 3;
-const cachedParamsByWordList = new simpleCache_1.SimpleCache(64);
+const cachedParamsByWordList = new simpleCache_js_1.SimpleCache(64);
 /**
  * Create a SpellingDictionary
  * @param wordList - list of words
@@ -42,11 +42,11 @@ function _createSpellingDictionary(params) {
     const parseOptions = { stripCaseAndAccents: options?.supportNonStrictSearches ?? true };
     const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList, parseOptions);
     const trie = (0, cspell_trie_lib_1.buildTrieFast)(words);
-    const opts = { ...(options || SpellingDictionary_1.defaultOptions) };
+    const opts = { ...(options || SpellingDictionary_js_1.defaultOptions) };
     if (opts.weightMap === undefined && opts.dictionaryInformation) {
-        opts.weightMap = (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(opts.dictionaryInformation);
+        opts.weightMap = (0, SpellingDictionaryMethods_js_1.createWeightMapFromDictionaryInformation)(opts.dictionaryInformation);
     }
-    return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, opts, source);
+    return new SpellingDictionaryFromTrie_js_1.SpellingDictionaryFromTrie(trie, name, opts, source);
 }
 function createFailedToLoadDictionary(name, source, error, options) {
     options = options || {};

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/index.d.ts

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

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/index.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTyposDictionary = exports.createSuggestDictionary = exports.createSpellingDictionaryFromTrieFile = exports.createCollection = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = exports.createFlagWordsDictionary = exports.createSpellingDictionary = exports.createFailedToLoadDictionary = exports.createInlineSpellingDictionary = exports.createCachingDictionary = void 0;
-var CachingDictionary_1 = require("./CachingDictionary");
-Object.defineProperty(exports, "createCachingDictionary", { enumerable: true, get: function () { return CachingDictionary_1.createCachingDictionary; } });
-var createInlineSpellingDictionary_1 = require("./createInlineSpellingDictionary");
-Object.defineProperty(exports, "createInlineSpellingDictionary", { enumerable: true, get: function () { return createInlineSpellingDictionary_1.createInlineSpellingDictionary; } });
-var createSpellingDictionary_1 = require("./createSpellingDictionary");
-Object.defineProperty(exports, "createFailedToLoadDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createFailedToLoadDictionary; } });
-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 SuggestDictionary_1 = require("./SuggestDictionary");
-Object.defineProperty(exports, "createSuggestDictionary", { enumerable: true, get: function () { return SuggestDictionary_1.createSuggestDictionary; } });
-var TyposDictionary_1 = require("./TyposDictionary");
-Object.defineProperty(exports, "createTyposDictionary", { enumerable: true, get: function () { return TyposDictionary_1.createTyposDictionary; } });
+var CachingDictionary_js_1 = require("./CachingDictionary.js");
+Object.defineProperty(exports, "createCachingDictionary", { enumerable: true, get: function () { return CachingDictionary_js_1.createCachingDictionary; } });
+var createInlineSpellingDictionary_js_1 = require("./createInlineSpellingDictionary.js");
+Object.defineProperty(exports, "createInlineSpellingDictionary", { enumerable: true, get: function () { return createInlineSpellingDictionary_js_1.createInlineSpellingDictionary; } });
+var createSpellingDictionary_js_1 = require("./createSpellingDictionary.js");
+Object.defineProperty(exports, "createFailedToLoadDictionary", { enumerable: true, get: function () { return createSpellingDictionary_js_1.createFailedToLoadDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return createSpellingDictionary_js_1.createSpellingDictionary; } });
+var FlagWordsDictionary_js_1 = require("./FlagWordsDictionary.js");
+Object.defineProperty(exports, "createFlagWordsDictionary", { enumerable: true, get: function () { return FlagWordsDictionary_js_1.createFlagWordsDictionary; } });
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return FlagWordsDictionary_js_1.createFlagWordsDictionary; } });
+var IgnoreWordsDictionary_js_1 = require("./IgnoreWordsDictionary.js");
+Object.defineProperty(exports, "createIgnoreWordsDictionary", { enumerable: true, get: function () { return IgnoreWordsDictionary_js_1.createIgnoreWordsDictionary; } });
+var SpellingDictionaryCollection_js_1 = require("./SpellingDictionaryCollection.js");
+Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionaryCollection_js_1.createCollection; } });
+var SpellingDictionaryFromTrie_js_1 = require("./SpellingDictionaryFromTrie.js");
+Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return SpellingDictionaryFromTrie_js_1.createSpellingDictionaryFromTrieFile; } });
+var SuggestDictionary_js_1 = require("./SuggestDictionary.js");
+Object.defineProperty(exports, "createSuggestDictionary", { enumerable: true, get: function () { return SuggestDictionary_js_1.createSuggestDictionary; } });
+var TyposDictionary_js_1 = require("./TyposDictionary.js");
+Object.defineProperty(exports, "createTyposDictionary", { enumerable: true, get: function () { return TyposDictionary_js_1.createTyposDictionary; } });
 //# sourceMappingURL=index.js.map

package/dist/{index.d.ts → cjs/index.d.ts}

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

package/dist/{index.js → cjs/index.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSuggestDictionary = exports.createSpellingDictionaryFromTrieFile = exports.createSpellingDictionary = exports.createInlineSpellingDictionary = 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, "createInlineSpellingDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createInlineSpellingDictionary; } });
-Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionary; } });
-Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionaryFromTrieFile; } });
-Object.defineProperty(exports, "createSuggestDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createSuggestDictionary; } });
+var index_js_1 = require("./SpellingDictionary/index.js");
+Object.defineProperty(exports, "createCachingDictionary", { enumerable: true, get: function () { return index_js_1.createCachingDictionary; } });
+Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return index_js_1.createCollection; } });
+Object.defineProperty(exports, "createFailedToLoadDictionary", { enumerable: true, get: function () { return index_js_1.createFailedToLoadDictionary; } });
+Object.defineProperty(exports, "createFlagWordsDictionary", { enumerable: true, get: function () { return index_js_1.createFlagWordsDictionary; } });
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return index_js_1.createForbiddenWordsDictionary; } });
+Object.defineProperty(exports, "createIgnoreWordsDictionary", { enumerable: true, get: function () { return index_js_1.createIgnoreWordsDictionary; } });
+Object.defineProperty(exports, "createInlineSpellingDictionary", { enumerable: true, get: function () { return index_js_1.createInlineSpellingDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return index_js_1.createSpellingDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return index_js_1.createSpellingDictionaryFromTrieFile; } });
+Object.defineProperty(exports, "createSuggestDictionary", { enumerable: true, get: function () { return index_js_1.createSuggestDictionary; } });
 //# sourceMappingURL=index.js.map

package/dist/{util → cjs/util}/clean.d.ts

@@ -1,4 +1,4 @@
-import type { RemoveUndefined } from './types';
+import type { RemoveUndefined } from './types.js';
 /**
  * Delete all `undefined` fields from an object.
  * @param src - object to be cleaned

package/dist/{util → cjs/util}/repMap.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.createRepMapper = exports.createMapper = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const regexHelper_1 = require("./regexHelper");
-const util_1 = require("./util");
+const regexHelper_js_1 = require("./regexHelper.js");
+const util_js_1 = require("./util.js");
 function createMapper(repMap, ignoreCharset) {
     if (!repMap && !ignoreCharset)
         return (a) => a;
@@ -62,7 +62,7 @@ function createMapperRegExp(repMap) {
             s = r;
         }
         catch (err) {
-            return (0, regexHelper_1.escapeRegEx)(s);
+            return (0, regexHelper_js_1.escapeRegEx)(s);
         }
         return s;
     })
@@ -130,7 +130,7 @@ function calcAllEdits(root, word) {
     return edits;
 }
 function createTrie(repMap, ignoreCharset) {
-    const combined = [repMap, charsetToRepMap(ignoreCharset)].filter(util_1.isDefined).flatMap((a) => a);
+    const combined = [repMap, charsetToRepMap(ignoreCharset)].filter(util_js_1.isDefined).flatMap((a) => a);
     const expanded = expandReplaceMap(combined);
     const trieRoot = Object.create(null);
     expanded.forEach(([match, replaceWith]) => addToTrie(trieRoot, match, replaceWith));

package/dist/{util → cjs/util}/textMappers.js

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

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

@@ -0,0 +1,30 @@
+import type { CacheStats } from '../util/AutoCache.mjs';
+import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.mjs';
+import type { SpellingDictionaryCollection } from './SpellingDictionaryCollection.mjs';
+interface CallStats {
+    name: string;
+    id: number;
+    has: CacheStats;
+    isNoSuggestWord: CacheStats;
+    isForbidden: CacheStats;
+}
+/**
+ * Caching Dictionary remembers method calls to increase performance.
+ */
+export interface CachingDictionary {
+    name: string;
+    id: number;
+    has(word: string): boolean;
+    isNoSuggestWord(word: string): boolean;
+    isForbidden(word: string): boolean;
+    stats(): CallStats;
+}
+/**
+ * create a caching dictionary
+ * @param dict - Dictionary to cache the search results.
+ * @param options - Search options to use.
+ * @returns CachingDictionary
+ */
+export declare function createCachingDictionary(dict: SpellingDictionary | SpellingDictionaryCollection, options: SearchOptions): CachingDictionary;
+export {};
+//# sourceMappingURL=CachingDictionary.d.mts.map

package/dist/esm/SpellingDictionary/CachingDictionary.mjs

@@ -0,0 +1,45 @@
+import { autoCache, extractStats } from '../util/AutoCache.mjs';
+import { canonicalSearchOptions } from './SpellingDictionaryMethods.mjs';
+let dictionaryCounter = 0;
+class CachedDict {
+    constructor(dict, options) {
+        this.dict = dict;
+        this.options = options;
+        this.id = ++dictionaryCounter;
+        this.has = autoCache((word) => this.dict.has(word, this.options));
+        this.isNoSuggestWord = autoCache((word) => this.dict.isNoSuggestWord(word, this.options));
+        this.isForbidden = autoCache((word) => this.dict.isForbidden(word));
+        this.name = dict.name;
+        // console.log(`CachedDict for ${this.name}`);
+    }
+    stats() {
+        return {
+            name: this.name,
+            id: this.id,
+            has: extractStats(this.has),
+            isNoSuggestWord: extractStats(this.isNoSuggestWord),
+            isForbidden: extractStats(this.isForbidden),
+        };
+    }
+}
+const knownDicts = new Map();
+/**
+ * create a caching dictionary
+ * @param dict - Dictionary to cache the search results.
+ * @param options - Search options to use.
+ * @returns CachingDictionary
+ */
+export function createCachingDictionary(dict, options) {
+    options = canonicalSearchOptions(options);
+    let knownOptions = knownDicts.get(options);
+    if (!knownOptions) {
+        knownOptions = new WeakMap();
+        knownDicts.set(options, knownOptions);
+    }
+    const known = knownOptions.get(dict);
+    if (known)
+        return known;
+    const cached = new CachedDict(dict, options);
+    knownOptions.set(dict, cached);
+    return cached;
+}

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

@@ -0,0 +1,11 @@
+import type { SpellingDictionary } from './SpellingDictionary.mjs';
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param wordList - list of words
+ * @param name
+ * @param source
+ * @param options
+ * @returns SpellingDictionary
+ */
+export declare function createFlagWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
+//# sourceMappingURL=FlagWordsDictionary.d.mts.map

package/dist/esm/SpellingDictionary/FlagWordsDictionary.mjs

@@ -0,0 +1,134 @@
+import { opMap, pipe } from '@cspell/cspell-pipe/sync';
+import { buildTrieFast, parseDictionaryLines } from 'cspell-trie-lib';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
+import * as Defaults from './defaults.mjs';
+import { defaultOptions } from './SpellingDictionary.mjs';
+import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.mjs';
+import { suggestArgsToSuggestOptions } from './SpellingDictionaryMethods.mjs';
+import { createTyposDictionary } from './TyposDictionary.mjs';
+class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
+    constructor(trie, name, source) {
+        super(trie, name, 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 = 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 [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param wordList - list of words
+ * @param name
+ * @param source
+ * @param options
+ * @returns SpellingDictionary
+ */
+export function createFlagWordsDictionary(wordList, name, source) {
+    return createCache.get(wordList, () => {
+        const testSpecialCharacters = /[~*+]/;
+        const { t: specialWords, f: typoWords } = bisect(parseDictionaryLines(wordList, { stripCaseAndAccents: false }), (line) => testSpecialCharacters.test(line));
+        const trieDict = specialWords.size ? buildTrieDict(specialWords, name, source) : undefined;
+        const typosDict = createTyposDictionary(typoWords, name, source);
+        if (!trieDict)
+            return typosDict;
+        return new FlagWordsDictionary(name, source, typosDict, trieDict);
+    });
+}
+const regExpCleanIgnore = /^(!!)+/;
+function buildTrieDict(words, name, source) {
+    const trie = buildTrieFast(pipe(words, opMap((w) => '!' + w), 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 };
+}

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

@@ -0,0 +1,11 @@
+import type { SpellingDictionary } from './SpellingDictionary.mjs';
+/**
+ * Create a dictionary where all words are to be ignored.
+ * Ignored words override forbidden words.
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - dictionary source
+ * @returns
+ */
+export declare function createIgnoreWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
+//# sourceMappingURL=IgnoreWordsDictionary.d.mts.map

package/dist/esm/SpellingDictionary/IgnoreWordsDictionary.mjs

@@ -0,0 +1,96 @@
+import { opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
+import { parseDictionaryLines } from 'cspell-trie-lib';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
+import { createSpellingDictionary } from './createSpellingDictionary.mjs';
+import * as Defaults from './defaults.mjs';
+const NormalizeForm = 'NFC';
+class IgnoreWordsDictionary {
+    constructor(name, source, words) {
+        this.name = name;
+        this.source = source;
+        this.containsNoSuggestWords = true;
+        this.options = {};
+        this.type = 'ignore';
+        this.isDictionaryCaseSensitive = true;
+        this.dict = new Set(words);
+        this.dictNonStrict = new Set(pipe(this.dict, opFilter((w) => w.startsWith('~')), opMap((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) {
+        const nWord = word.normalize(NormalizeForm);
+        if (this.dict.has(nWord))
+            return true;
+        const lcWord = nWord.toLowerCase();
+        if (this.dict.has(lcWord))
+            return true;
+        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
+        return ignoreCase && (this.dictNonStrict.has(nWord) || this.dictNonStrict.has(lcWord));
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, options) {
+        const nWord = word.normalize(NormalizeForm);
+        if (this.dict.has(nWord))
+            return { found: nWord, forbidden: false, noSuggest: true };
+        const lcWord = nWord.toLowerCase();
+        if (this.dict.has(lcWord))
+            return { found: lcWord, forbidden: false, noSuggest: true };
+        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
+        if (!ignoreCase)
+            return undefined;
+        if (this.dictNonStrict.has(nWord))
+            return { found: nWord, forbidden: false, noSuggest: true };
+        return (this.dictNonStrict.has(lcWord) && { found: lcWord, forbidden: false, noSuggest: true }) || undefined;
+    }
+    isForbidden(_word, _ignoreCase) {
+        return false;
+    }
+    isNoSuggestWord(word, options) {
+        return this.has(word, options);
+    }
+    suggest() {
+        return [];
+    }
+    genSuggestions() {
+        return;
+    }
+    mapWord(word) {
+        return word;
+    }
+    get size() {
+        return this.dict.size;
+    }
+    getErrors() {
+        return [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * Create a dictionary where all words are to be ignored.
+ * Ignored words override forbidden words.
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - dictionary source
+ * @returns
+ */
+export function createIgnoreWordsDictionary(wordList, name, source) {
+    return createCache.get(wordList, () => {
+        const testSpecialCharacters = /[*+]/;
+        const words = [...parseDictionaryLines(wordList, { stripCaseAndAccents: true })].map((w) => w.normalize(NormalizeForm));
+        const hasSpecial = words.findIndex((word) => testSpecialCharacters.test(word)) >= 0;
+        if (hasSpecial) {
+            return createSpellingDictionary(words, name, source, {
+                caseSensitive: true,
+                noSuggest: true,
+                weightMap: undefined,
+                supportNonStrictSearches: true,
+            });
+        }
+        return new IgnoreWordsDictionary(name, source, words);
+    });
+}