cspell-dictionary 6.10.0 → 6.11.0

package/dist/SpellingDictionary/CachingDictionary.d.ts

@@ -0,0 +1,30 @@
+import { CacheStats } from '../util/AutoCache';
+import { SearchOptions, SpellingDictionary } from './SpellingDictionary';
+import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
+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.ts.map

package/dist/SpellingDictionary/CachingDictionary.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCachingDictionary = void 0;
+const AutoCache_1 = require("../util/AutoCache");
+const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+let dictionaryCounter = 0;
+class CachedDict {
+    constructor(dict, options) {
+        this.dict = dict;
+        this.options = options;
+        this.id = ++dictionaryCounter;
+        this.has = (0, AutoCache_1.autoCache)((word) => this.dict.has(word, this.options));
+        this.isNoSuggestWord = (0, AutoCache_1.autoCache)((word) => this.dict.isNoSuggestWord(word, this.options));
+        this.isForbidden = (0, AutoCache_1.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: (0, AutoCache_1.extractStats)(this.has),
+            isNoSuggestWord: (0, AutoCache_1.extractStats)(this.isNoSuggestWord),
+            isForbidden: (0, AutoCache_1.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
+ */
+function createCachingDictionary(dict, options) {
+    options = (0, SpellingDictionaryMethods_1.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;
+}
+exports.createCachingDictionary = createCachingDictionary;
+//# sourceMappingURL=CachingDictionary.js.map

package/dist/SpellingDictionary/ForbiddenWordsDictionary.d.ts

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

package/dist/SpellingDictionary/ForbiddenWordsDictionary.js

@@ -0,0 +1,107 @@
+"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

package/dist/SpellingDictionary/IgnoreWordsDictionary.d.ts

@@ -0,0 +1,11 @@
+import { SpellingDictionary } from './SpellingDictionary';
+/**
+ * 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.ts.map

package/dist/SpellingDictionary/IgnoreWordsDictionary.js

@@ -0,0 +1,120 @@
+"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.createIgnoreWordsDictionary = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const Defaults = __importStar(require("./defaults"));
+const createSpellingDictionary_1 = require("./createSpellingDictionary");
+const NormalizeForm = 'NFC';
+class IgnoreWordsDictionary {
+    constructor(name, source, words) {
+        this.name = name;
+        this.source = source;
+        this.containsNoSuggestWords = true;
+        this.options = {};
+        this.type = 'forbidden';
+        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))));
+    }
+    /**
+     * 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) {
+        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 [];
+    }
+}
+/**
+ * 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
+ */
+function createIgnoreWordsDictionary(wordList, name, source) {
+    const testSpecialCharacters = /[*+]/;
+    const words = [...(0, cspell_trie_lib_1.parseDictionaryLines)(wordList, { stripCaseAndAccents: true })].map((w) => w.normalize(NormalizeForm));
+    const hasSpecial = words.findIndex((word) => testSpecialCharacters.test(word)) >= 0;
+    if (hasSpecial) {
+        return (0, createSpellingDictionary_1.createSpellingDictionary)(words, name, source, {
+            caseSensitive: true,
+            noSuggest: true,
+            weightMap: undefined,
+            supportNonStrictSearches: true,
+        });
+    }
+    return new IgnoreWordsDictionary(name, source, words);
+}
+exports.createIgnoreWordsDictionary = createIgnoreWordsDictionary;
+//# sourceMappingURL=IgnoreWordsDictionary.js.map

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -47,13 +47,18 @@ export interface FindResult {
 export declare type HasOptions = SearchOptions;
 export interface SpellingDictionaryOptions {
     repMap?: ReplaceMap;
-    useCompounds?: boolean;
     /**
      * The dictionary is case aware.
      */
     caseSensitive?: boolean;
+    /**
+     * This is a NO Suggest dictionary used for words to be ignored.
+     */
     noSuggest?: boolean;
-    weightMap?: WeightMap | undefined;
+    /**
+     * Extra dictionary information used in improving suggestions
+     * based upon locale.
+     */
     dictionaryInformation?: DictionaryInformation;
     /**
      * Strip Case and Accents to allow for case insensitive searches and
@@ -65,6 +70,15 @@ export interface SpellingDictionaryOptions {
      * @default true
      */
     supportNonStrictSearches?: boolean;
+    /**
+     * Turns on legacy word compounds.
+     * @deprecated
+     */
+    useCompounds?: boolean;
+    /**
+     * Optional WeightMap used to improve suggestions.
+     */
+    weightMap?: WeightMap | undefined;
 }
 export interface DictionaryInfo {
     /** The name of the dictionary */

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -1,31 +1,13 @@
-import { CompoundWordsMethod, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions } from './SpellingDictionary';
-declare function identityString(w: string): string;
-export declare class SpellingDictionaryCollection implements SpellingDictionary {
+import { SearchOptions, SpellingDictionary } from './SpellingDictionary';
+export interface SpellingDictionaryCollection extends SpellingDictionary {
+    readonly type: 'SpellingDictionaryCollection';
     readonly dictionaries: SpellingDictionary[];
-    readonly name: string;
-    readonly options: SpellingDictionaryOptions;
-    readonly mapWord: typeof identityString;
-    readonly type = "SpellingDictionaryCollection";
-    readonly source: string;
-    readonly isDictionaryCaseSensitive: boolean;
-    readonly containsNoSuggestWords: boolean;
-    constructor(dictionaries: SpellingDictionary[], name: string);
-    has(word: string, hasOptions?: HasOptions): boolean;
-    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
-    isNoSuggestWord(word: string, options?: HasOptions): boolean;
-    isForbidden(word: string): boolean;
-    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
-    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
-    _suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
-    get size(): number;
-    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     getErrors(): Error[];
-    private _isForbiddenInDict;
-    private _isNoSuggestWord;
 }
 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;
+export declare function isSpellingDictionaryCollection(dict: SpellingDictionary): dict is SpellingDictionaryCollection;
 export declare const __testing__: {
     isWordInAnyDictionary: typeof isWordInAnyDictionary;
     isWordForbiddenInAnyDictionary: typeof isWordForbiddenInAnyDictionary;

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
+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");
@@ -10,7 +10,7 @@ const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 function identityString(w) {
     return w;
 }
-class SpellingDictionaryCollection {
+class SpellingDictionaryCollectionImpl {
     constructor(dictionaries, name) {
         this.dictionaries = dictionaries;
         this.name = name;
@@ -80,9 +80,8 @@ class SpellingDictionaryCollection {
         return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
     }
 }
-exports.SpellingDictionaryCollection = SpellingDictionaryCollection;
 function createCollection(dictionaries, name) {
-    return new SpellingDictionaryCollection(dictionaries, name);
+    return new SpellingDictionaryCollectionImpl(dictionaries, name);
 }
 exports.createCollection = createCollection;
 function isWordInAnyDictionary(dicts, word, options) {
@@ -104,6 +103,10 @@ function isNoSuggestWordInAnyDictionary(dicts, word, options) {
 function isWordForbiddenInAnyDictionary(dicts, word) {
     return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isForbidden(word));
 }
+function isSpellingDictionaryCollection(dict) {
+    return dict instanceof SpellingDictionaryCollectionImpl;
+}
+exports.isSpellingDictionaryCollection = isSpellingDictionaryCollection;
 exports.__testing__ = {
     isWordInAnyDictionary,
     isWordForbiddenInAnyDictionary,

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -14,7 +14,6 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     readonly type = "SpellingDictionaryFromTrie";
     readonly isDictionaryCaseSensitive: boolean;
     readonly containsNoSuggestWords: boolean;
-    readonly ignoreCharactersRegExp: RegExp | undefined;
     private weightMap;
     constructor(trie: Trie, name: string, options: SpellingDictionaryOptions, source?: string, size?: number);
     get size(): number;
@@ -26,11 +25,25 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     private _findAnyForm;
     isNoSuggestWord(word: string, options?: HasOptions): boolean;
     isForbidden(word: string): boolean;
+    private _isForbidden;
     suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
     suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
     private _suggest;
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     getErrors(): Error[];
 }
-export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+export declare function createSpellingDictionaryFromTrieFile(data: Iterable<string> | string, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+declare function outerWordForms(word: string, mapWord: (word: string) => string): Set<string>;
+export declare const __testing__: {
+    outerWordForms: typeof outerWordForms;
+};
+export {};
 //# sourceMappingURL=SpellingDictionaryFromTrie.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -1,11 +1,38 @@
 "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.createSpellingDictionaryTrie = exports.SpellingDictionaryFromTrie = void 0;
+exports.__testing__ = exports.createSpellingDictionaryFromTrieFile = exports.SpellingDictionaryFromTrie = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const repMap_1 = require("../util/repMap");
 const clean_1 = require("../util/clean");
-const charset_1 = require("./charset");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+const AutoCache_1 = require("../util/AutoCache");
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const Defaults = __importStar(require("./defaults"));
+const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
+const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
 class SpellingDictionaryFromTrie {
     constructor(trie, name, options, source = 'from trie', size) {
         this.trie = trie;
@@ -16,13 +43,15 @@ class SpellingDictionaryFromTrie {
         this.knownWords = new Set();
         this.unknownWords = new Set();
         this.type = 'SpellingDictionaryFromTrie';
-        this._find = (word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase);
-        this.mapWord = (0, repMap_1.createMapper)(options.repMap || []);
+        this._find = findCache((word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase));
+        this._isForbidden = (0, AutoCache_1.autoCache)((word) => {
+            return this.trie.isForbiddenWord(word);
+        });
+        this.mapWord = (0, repMap_1.createMapper)(options.repMap, options.dictionaryInformation?.ignore);
         this.isDictionaryCaseSensitive = options.caseSensitive ?? !trie.isLegacy;
         this.containsNoSuggestWords = options.noSuggest || false;
         this._size = size || 0;
         this.weightMap = options.weightMap || (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(options.dictionaryInformation);
-        this.ignoreCharactersRegExp = (0, charset_1.charsetToRegExp)(this.options.dictionaryInformation?.ignore);
     }
     get size() {
         if (!this._size) {
@@ -56,16 +85,11 @@ class SpellingDictionaryFromTrie {
         return { found, forbidden, noSuggest };
     }
     resolveOptions(hasOptions) {
-        const { useCompounds = this.options.useCompounds, ignoreCase = true } = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        const { useCompounds = this.options.useCompounds, ignoreCase = Defaults.ignoreCase } = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
         return { useCompounds, ignoreCase };
     }
     findAnyForm(word, useCompounds, ignoreCase) {
-        const outerForms = new Set([word]);
-        if (this.ignoreCharactersRegExp) {
-            outerForms.add(word.replace(this.ignoreCharactersRegExp, ''));
-            outerForms.add(word.normalize('NFD').replace(this.ignoreCharactersRegExp, ''));
-            outerForms.add(word.normalize('NFC').replace(this.ignoreCharactersRegExp, ''));
-        }
+        const outerForms = outerWordForms(word, this.mapWord);
         for (const form of outerForms) {
             const r = this._findAnyForm(form, useCompounds, ignoreCase);
             if (r)
@@ -73,9 +97,8 @@ class SpellingDictionaryFromTrie {
         }
         return undefined;
     }
-    _findAnyForm(word, useCompounds, ignoreCase) {
-        const mWord = this.mapWord(word.normalize('NFC'));
-        const opts = { caseSensitive: !ignoreCase };
+    _findAnyForm(mWord, useCompounds, ignoreCase) {
+        const opts = ignoreCase ? findWordOptionsNotCaseSensitive : findWordOptionsCaseSensitive;
         const findResult = this.trie.findWord(mWord, opts);
         if (findResult.found !== false) {
             return findResult;
@@ -88,9 +111,9 @@ class SpellingDictionaryFromTrie {
             }
         }
         if (useCompounds) {
-            opts.useLegacyWordCompounds = useCompounds;
+            const optsUseCompounds = { ...opts, useLegacyWordCompounds: useCompounds };
             for (const w of forms) {
-                const findResult = this.trie.findWord(w, opts);
+                const findResult = this.trie.findWord(w, optsUseCompounds);
                 if (findResult.found !== false) {
                     return findResult;
                 }
@@ -102,7 +125,7 @@ class SpellingDictionaryFromTrie {
         return this.containsNoSuggestWords ? this.has(word, options) : false;
     }
     isForbidden(word) {
-        return this.trie.isForbiddenWord(word);
+        return this._isForbidden(word);
     }
     suggest(...args) {
         const [word] = args;
@@ -139,10 +162,39 @@ class SpellingDictionaryFromTrie {
 }
 exports.SpellingDictionaryFromTrie = SpellingDictionaryFromTrie;
 SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
-function createSpellingDictionaryTrie(data, name, source, options) {
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+function createSpellingDictionaryFromTrieFile(data, name, source, options) {
+    data = typeof data === 'string' ? data.split('\n') : data;
     const trieNode = (0, cspell_trie_lib_1.importTrie)(data);
     const trie = new cspell_trie_lib_1.Trie(trieNode);
     return new SpellingDictionaryFromTrie(trie, name, options, source);
 }
-exports.createSpellingDictionaryTrie = createSpellingDictionaryTrie;
+exports.createSpellingDictionaryFromTrieFile = createSpellingDictionaryFromTrieFile;
+function findCache(fn, size = 2000) {
+    const cache = (0, AutoCache_1.createCache01)(size);
+    function find(word, useCompounds, ignoreCase) {
+        const r = cache.get(word);
+        if (r !== undefined) {
+            if (r.useCompounds === useCompounds && r.ignoreCase === ignoreCase) {
+                return r.findResult;
+            }
+        }
+        const findResult = fn(word, useCompounds, ignoreCase);
+        cache.set(word, { useCompounds, ignoreCase, findResult });
+        return findResult;
+    }
+    return find;
+}
+function outerWordForms(word, mapWord) {
+    const forms = (0, sync_1.pipe)([word], (0, sync_1.opConcatMap)((word) => [word, word.normalize('NFC'), word.normalize('NFD')]), (0, sync_1.opConcatMap)((word) => [word, mapWord(word)]));
+    return new Set(forms);
+}
+exports.__testing__ = { outerWordForms };
 //# sourceMappingURL=SpellingDictionaryFromTrie.js.map

package/dist/SpellingDictionary/SpellingDictionaryMethods.d.ts

@@ -9,13 +9,13 @@ declare function wordSearchFormsArray(word: string, isDictionaryCaseSensitive: b
 export declare function wordSearchForms(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): Set<string>;
 export declare function wordSuggestFormsArray(word: string): string[];
 export declare function wordSuggestForms(word: string): Set<string>;
-interface DictionaryWordForm {
-    w: string;
-    p: string;
-}
-declare function wordDictionaryForms(word: string, prefixNoCase: string): IterableIterator<DictionaryWordForm>;
-export declare function wordDictionaryFormsCollector(prefixNoCase: string): (word: string) => Iterable<string>;
 export declare function hasOptionToSearchOption(opt: HasOptions | undefined): SearchOptions;
+/**
+ * Find the canonical form for SearchOptions. Useful Maps and WeakMaps.
+ * @param opt - options to normalize
+ * @returns SearchOptions - the canonical form
+ */
+export declare function canonicalSearchOptions(opt: SearchOptions): SearchOptions;
 export declare function suggestArgsToSuggestOptions(args: SuggestArgs): SuggestOptions;
 export declare function createWeightMapFromDictionaryInformation(di: undefined): undefined;
 export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation): WeightMap;
@@ -23,7 +23,5 @@ export declare function createWeightMapFromDictionaryInformation(di: DictionaryI
 export declare const __testMethods__: {
     wordSearchForms: typeof wordSearchForms;
     wordSearchFormsArray: typeof wordSearchFormsArray;
-    wordDictionaryForms: typeof wordDictionaryForms;
-    wordDictionaryFormsCollector: typeof wordDictionaryFormsCollector;
 };
 //# sourceMappingURL=SpellingDictionaryMethods.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryMethods.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testMethods__ = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.hasOptionToSearchOption = exports.wordDictionaryFormsCollector = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
+exports.__testMethods__ = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.canonicalSearchOptions = exports.hasOptionToSearchOption = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const clean_1 = require("../util/clean");
-const gensequence_1 = require("gensequence");
 const text_1 = require("../util/text");
 var cspell_trie_lib_2 = require("cspell-trie-lib");
 Object.defineProperty(exports, "impersonateCollector", { enumerable: true, get: function () { return cspell_trie_lib_2.impersonateCollector; } });
@@ -23,7 +22,7 @@ function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
         else {
             forms.add(wordLc);
             // Legacy remove any unbound accents
-            forms.add(wordLc.replace(/\p{M}/gu, ''));
+            forms.add((0, text_1.removeUnboundAccents)(wordLc));
         }
     }
     else {
@@ -38,7 +37,7 @@ function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
         else {
             forms.add(wordLc);
             // Legacy remove any unbound accents
-            forms.add(wordLc.replace(/\p{M}/gu, ''));
+            forms.add((0, text_1.removeUnboundAccents)(wordLc));
         }
     }
     return forms;
@@ -56,36 +55,37 @@ function wordSuggestForms(word) {
     return forms;
 }
 exports.wordSuggestForms = wordSuggestForms;
-function* wordDictionaryForms(word, prefixNoCase) {
-    word = word.normalize('NFC');
-    const wordLc = word.toLowerCase();
-    const wordNa = (0, text_1.removeAccents)(word);
-    const wordLcNa = (0, text_1.removeAccents)(wordLc);
-    function wf(w, p = '') {
-        return { w, p };
-    }
-    const prefix = prefixNoCase;
-    yield wf(word);
-    yield wf(wordNa, prefix);
-    yield wf(wordLc, prefix);
-    yield wf(wordLcNa, prefix);
-}
-function wordDictionaryFormsCollector(prefixNoCase) {
-    const knownWords = new Set();
-    return (word) => {
-        return (0, gensequence_1.genSequence)(wordDictionaryForms(word, prefixNoCase))
-            .filter((w) => !knownWords.has(w.w))
-            .map((w) => w.p + w.w)
-            .filter((w) => !knownWords.has(w))
-            .map((w) => (knownWords.add(w), w));
-    };
-}
-exports.wordDictionaryFormsCollector = wordDictionaryFormsCollector;
 const DEFAULT_HAS_OPTIONS = Object.freeze({});
 function hasOptionToSearchOption(opt) {
-    return !opt ? DEFAULT_HAS_OPTIONS : opt;
+    return canonicalSearchOptions(!opt ? DEFAULT_HAS_OPTIONS : opt);
 }
 exports.hasOptionToSearchOption = hasOptionToSearchOption;
+const canonicalSearchOptionsMap = new Map();
+const knownCanonicalOptions = new WeakMap();
+/**
+ * Find the canonical form for SearchOptions. Useful Maps and WeakMaps.
+ * @param opt - options to normalize
+ * @returns SearchOptions - the canonical form
+ */
+function canonicalSearchOptions(opt) {
+    const known = knownCanonicalOptions.get(opt);
+    if (known)
+        return known;
+    const { ignoreCase, useCompounds } = opt;
+    const foundLevel1Map = canonicalSearchOptionsMap.get(ignoreCase);
+    const useLevel1Map = foundLevel1Map || new Map();
+    if (!foundLevel1Map) {
+        canonicalSearchOptionsMap.set(ignoreCase, useLevel1Map);
+    }
+    const foundCanOpts = useLevel1Map.get(useCompounds);
+    const canOpts = foundCanOpts || Object.freeze({ ignoreCase, useCompounds });
+    if (!foundCanOpts) {
+        useLevel1Map.set(useCompounds, canOpts);
+    }
+    knownCanonicalOptions.set(opt, canOpts);
+    return canOpts;
+}
+exports.canonicalSearchOptions = canonicalSearchOptions;
 function suggestArgsToSuggestOptions(args) {
     const [_word, options, compoundMethod, numChanges, ignoreCase] = args;
     const suggestOptions = typeof options === 'object'
@@ -108,7 +108,5 @@ exports.createWeightMapFromDictionaryInformation = createWeightMapFromDictionary
 exports.__testMethods__ = {
     wordSearchForms,
     wordSearchFormsArray,
-    wordDictionaryForms,
-    wordDictionaryFormsCollector,
 };
 //# sourceMappingURL=SpellingDictionaryMethods.js.map

package/dist/SpellingDictionary/createSpellingDictionary.d.ts

@@ -1,7 +1,15 @@
 import { IterableLike } from '../util/IterableLike';
-import { SpellingDictionary, SpellingDictionaryOptions, DictionaryInfo } from './SpellingDictionary';
-export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
-export declare function createForbiddenWordsDictionary(wordList: readonly string[], name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
+import type { DictionaryInfo, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary';
+export declare const defaultOptions: SpellingDictionaryOptions;
+/**
+ * Create a SpellingDictionary
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - dictionary options
+ * @returns a Spelling Dictionary
+ */
+export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
 export interface SpellingDictionaryLoadError extends Error {
     /** The Error Name */
     readonly name: string;
@@ -12,6 +20,5 @@ export interface SpellingDictionaryLoadError extends Error {
     /** Dictionary Information */
     readonly info: DictionaryInfo;
 }
-export declare function createFailedToLoadDictionary(error: SpellingDictionaryLoadError): SpellingDictionary;
-export declare function createSpellingDictionaryLoadError(errorName: string, message: string, info: DictionaryInfo, cause?: Error): SpellingDictionaryLoadError;
+export declare function createFailedToLoadDictionary(name: string, source: string, error: Error, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
 //# sourceMappingURL=createSpellingDictionary.d.ts.map

package/dist/SpellingDictionary/createSpellingDictionary.js

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionaryLoadError = exports.createFailedToLoadDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = void 0;
+exports.createFailedToLoadDictionary = exports.createSpellingDictionary = exports.defaultOptions = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const fast_equals_1 = require("fast-equals");
-const gensequence_1 = require("gensequence");
 const simpleCache_1 = require("../util/simpleCache");
 const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
-const defaultOptions = Object.freeze({
+exports.defaultOptions = Object.freeze({
     weightMap: undefined,
 });
 const cachedDictionaries = new simpleCache_1.AutoWeakCache(_createSpellingDictionary, 64);
 const maxSetSize = 3;
 const cachedParamsByWordList = new simpleCache_1.SimpleCache(64);
+/**
+ * Create a SpellingDictionary
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - dictionary options
+ * @returns a Spelling Dictionary
+ */
 function createSpellingDictionary(wordList, name, source, options) {
     const params = [wordList, name, source, options];
     if (!Array.isArray(wordList)) {
@@ -37,24 +44,14 @@ 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 || defaultOptions) };
+    const opts = { ...(options || exports.defaultOptions) };
     if (opts.weightMap === undefined && opts.dictionaryInformation) {
         opts.weightMap = (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(opts.dictionaryInformation);
     }
     return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, opts, source);
 }
-function createForbiddenWordsDictionary(wordList, name, source, options) {
-    // console.log(`createSpellingDictionary ${name} ${source}`);
-    const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList.concat(wordList.map((a) => a.toLowerCase())), {
-        stripCaseAndAccents: !options?.noSuggest,
-    });
-    const forbidWords = gensequence_1.operators.map((w) => '!' + w)(words);
-    const trie = (0, cspell_trie_lib_1.buildTrieFast)(forbidWords);
-    return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, options || defaultOptions, source);
-}
-exports.createForbiddenWordsDictionary = createForbiddenWordsDictionary;
-function createFailedToLoadDictionary(error) {
-    const { name, source, options } = error.info;
+function createFailedToLoadDictionary(name, source, error, options) {
+    options = options || {};
     return {
         name,
         source,
@@ -76,16 +73,4 @@ function createFailedToLoadDictionary(error) {
     };
 }
 exports.createFailedToLoadDictionary = createFailedToLoadDictionary;
-function createSpellingDictionaryLoadError(errorName, message, info, cause) {
-    const err = {
-        name: errorName,
-        message,
-        info,
-        cause,
-    };
-    const stack = cause?.stack;
-    stack && (err.stack = stack);
-    return err;
-}
-exports.createSpellingDictionaryLoadError = createSpellingDictionaryLoadError;
 //# sourceMappingURL=createSpellingDictionary.js.map

package/dist/SpellingDictionary/defaults.d.ts

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

package/dist/SpellingDictionary/defaults.js

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

package/dist/SpellingDictionary/index.d.ts

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

package/dist/SpellingDictionary/index.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCollection = exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = void 0;
+exports.createSpellingDictionaryFromTrieFile = exports.createCollection = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = 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, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createForbiddenWordsDictionary; } });
 Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createSpellingDictionary; } });
+var ForbiddenWordsDictionary_1 = require("./ForbiddenWordsDictionary");
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return ForbiddenWordsDictionary_1.createForbiddenWordsDictionary; } });
+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; } });
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = exports.createCollection = void 0;
+exports.createSpellingDictionaryFromTrieFile = exports.createSpellingDictionary = exports.createIgnoreWordsDictionary = exports.createForbiddenWordsDictionary = 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, "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; } });
+Object.defineProperty(exports, "createSpellingDictionaryFromTrieFile", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionaryFromTrieFile; } });
 //# sourceMappingURL=index.js.map

package/dist/util/AutoCache.d.ts

@@ -0,0 +1,25 @@
+interface AutoCache<R> extends CacheStats {
+    (word: string): R;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    swaps: number;
+}
+declare class Cache01<R> implements CacheStats {
+    readonly maxSize: number;
+    private count;
+    private cache0;
+    private cache1;
+    hits: number;
+    misses: number;
+    swaps: number;
+    constructor(maxSize: number);
+    get(key: string): R | undefined;
+    set(key: string, value: R): this;
+}
+export declare function createCache01<R>(size: number): Cache01<R>;
+export declare function autoCache<R>(fn: (p: string) => R, size?: number): AutoCache<R>;
+export declare function extractStats(ac: AutoCache<unknown> | CacheStats): CacheStats;
+export {};
+//# sourceMappingURL=AutoCache.d.ts.map

package/dist/util/AutoCache.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStats = exports.autoCache = exports.createCache01 = void 0;
+const CACHE_SIZE = 100;
+class Cache01 {
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+        this.count = 0;
+        this.cache0 = Object.create(null);
+        this.cache1 = Object.create(null);
+        this.hits = 0;
+        this.misses = 0;
+        this.swaps = 0;
+    }
+    get(key) {
+        const cache0 = this.cache0;
+        const cache1 = this.cache1;
+        if (key in cache0) {
+            ++this.hits;
+            return cache0[key];
+        }
+        if (key in cache1) {
+            ++this.hits;
+            ++this.count;
+            const r = cache1[key];
+            cache0[key] = r;
+            return r;
+        }
+        ++this.misses;
+        return undefined;
+    }
+    set(key, value) {
+        if (this.count >= this.maxSize) {
+            this.cache1 = this.cache0;
+            this.cache0 = Object.create(null);
+            this.swaps++;
+            this.count = 0;
+        }
+        ++this.count;
+        this.cache0[key] = value;
+        return this;
+    }
+}
+function createCache01(size) {
+    return new Cache01(size);
+}
+exports.createCache01 = createCache01;
+function autoCache(fn, size = CACHE_SIZE) {
+    const cache = createCache01(size);
+    const ac = get;
+    ac.hits = 0;
+    ac.misses = 0;
+    ac.swaps = 0;
+    function get(k) {
+        const f = cache.get(k);
+        if (f !== undefined) {
+            ++ac.hits;
+            return f;
+        }
+        const r = fn(k);
+        cache.set(k, r);
+        ac.swaps = cache.swaps;
+        ++ac.misses;
+        return r;
+    }
+    return ac;
+}
+exports.autoCache = autoCache;
+function extractStats(ac) {
+    const { hits, misses, swaps } = ac;
+    return { hits, misses, swaps };
+}
+exports.extractStats = extractStats;
+//# sourceMappingURL=AutoCache.js.map

package/dist/util/repMap.d.ts

@@ -1,4 +1,11 @@
-import type { ReplaceMap } from '@cspell/cspell-types';
+import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
 export declare type ReplaceMapper = (src: string) => string;
-export declare function createMapper(repMap: ReplaceMap): ReplaceMapper;
+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;
+export declare const __testing__: {
+    charsetToRepMap: typeof charsetToRepMap;
+    createMapperRegExp: typeof createMapperRegExp;
+};
+export {};
 //# sourceMappingURL=repMap.d.ts.map

package/dist/util/repMap.js

@@ -1,12 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMapper = void 0;
+exports.__testing__ = exports.createMapper = void 0;
 const regexHelper_1 = require("./regexHelper");
-function createMapper(repMap) {
+function createMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (a) => a;
+    repMap = repMap || [];
+    const charsetMap = charsetToRepMap(ignoreCharset);
+    if (charsetMap) {
+        repMap = repMap.concat(charsetMap);
+    }
     const filteredMap = repMap.filter(([match, _]) => !!match);
     if (!filteredMap.length) {
         return (a) => a;
     }
+    const regEx = createMapperRegExp(repMap);
+    const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
+    function resolve(m, ...matches) {
+        const index = matches.findIndex((a) => !!a);
+        return 0 <= index && index < values.length ? values[index] : m;
+    }
+    return function (s) {
+        return s.replace(regEx, resolve);
+    };
+}
+exports.createMapper = createMapper;
+function charsetToRepMap(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .map((chars) => `[${chars.replace(/[\][\\]/g, '\\$&')}]`)
+        .map((map) => [map, replaceWith]);
+}
+function createMapperRegExp(repMap) {
+    const filteredMap = repMap.filter(([match, _]) => !!match);
+    if (!filteredMap.length) {
+        return /$^/;
+    }
     const regExStr = filteredMap
         .map(([from, _]) => from)
         // make sure it compiles into a regex
@@ -25,14 +56,10 @@ function createMapper(repMap) {
         .map((s) => `(${s})`)
         .join('|');
     const regEx = new RegExp(regExStr, 'g');
-    const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
-    function resolve(m, ...matches) {
-        const index = matches.findIndex((a) => !!a);
-        return 0 <= index && index < values.length ? values[index] : m;
-    }
-    return function (s) {
-        return s.replace(regEx, resolve);
-    };
+    return regEx;
 }
-exports.createMapper = createMapper;
+exports.__testing__ = {
+    charsetToRepMap,
+    createMapperRegExp,
+};
 //# sourceMappingURL=repMap.js.map

package/dist/util/text.d.ts

@@ -6,4 +6,5 @@ export declare function ucFirst(word: string): string;
 export declare function lcFirst(word: string): string;
 export declare function matchCase(example: string, word: string): string;
 export declare function removeAccents(text: string): string;
+export declare function removeUnboundAccents(text: string): string;
 //# sourceMappingURL=text.d.ts.map

package/dist/util/text.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeAccents = exports.matchCase = exports.lcFirst = exports.ucFirst = exports.isFirstCharacterLower = exports.isFirstCharacterUpper = exports.isLowerCase = exports.isUpperCase = void 0;
+exports.removeUnboundAccents = exports.removeAccents = exports.matchCase = exports.lcFirst = exports.ucFirst = exports.isFirstCharacterLower = exports.isFirstCharacterUpper = exports.isLowerCase = exports.isUpperCase = void 0;
 const regExFirstUpper = /^\p{Lu}\p{M}?\p{Ll}+$/u;
 const regExAllUpper = /^(?:\p{Lu}\p{M}?)+$/u;
 const regExAllLower = /^(?:\p{Ll}\p{M}?)+$/u;
@@ -52,4 +52,8 @@ function removeAccents(text) {
     return text.normalize('NFD').replace(regExAccents, '');
 }
 exports.removeAccents = removeAccents;
+function removeUnboundAccents(text) {
+    return text.replace(regExAccents, '');
+}
+exports.removeUnboundAccents = removeUnboundAccents;
 //# sourceMappingURL=text.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.10.0",
+  "version": "6.11.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -37,12 +37,17 @@
   "engines": {
     "node": ">=14"
   },
+  "devDependencies": {
+    "@types/jest": "^29.1.0",
+    "jest": "^29.1.1",
+    "ts-jest": "^29.0.3"
+  },
   "dependencies": {
-    "@cspell/cspell-pipe": "^6.10.0",
-    "@cspell/cspell-types": "^6.10.0",
-    "cspell-trie-lib": "^6.10.0",
+    "@cspell/cspell-pipe": "^6.11.0",
+    "@cspell/cspell-types": "^6.11.0",
+    "cspell-trie-lib": "^6.11.0",
     "fast-equals": "^4.0.3",
     "gensequence": "^4.0.2"
   },
-  "gitHead": "244f2ff310aa64bdb41cf93e85ba9e9f35c2b937"
+  "gitHead": "664676692898c3b6aa150fb2c6656b56f49a54b8"
 }

package/dist/SpellingDictionary/charset.d.ts

@@ -1,3 +0,0 @@
-import { CharacterSet } from '@cspell/cspell-types';
-export declare function charsetToRegExp(charset: CharacterSet | undefined): RegExp | undefined;
-//# sourceMappingURL=charset.d.ts.map

package/dist/SpellingDictionary/charset.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.charsetToRegExp = void 0;
-function charsetToRegExp(charset) {
-    if (!charset)
-        return undefined;
-    try {
-        const reg = `[${charset.replace(/[\][\\]/g, '\\$&')}]`;
-        return new RegExp(reg, 'g');
-    }
-    catch (e) {
-        return undefined;
-    }
-}
-exports.charsetToRegExp = charsetToRegExp;
-//# sourceMappingURL=charset.js.map