cspell-dictionary 6.27.0 → 6.29.0

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

@@ -25,11 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTyposDictionary = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
-const AutoResolve_1 = require("../util/AutoResolve");
-const textMappers_1 = require("../util/textMappers");
-const defaults = __importStar(require("./defaults"));
-const Typos_1 = require("./Typos");
-const util_1 = require("./Typos/util");
+const AutoResolve_js_1 = require("../util/AutoResolve.js");
+const textMappers_js_1 = require("../util/textMappers.js");
+const defaults = __importStar(require("./defaults.js"));
+const index_js_1 = require("./Typos/index.js");
+const util_js_1 = require("./Typos/util.js");
 class TyposDictionaryImpl {
     constructor(name, source, typosDef, ignoreList) {
         this.name = name;
@@ -39,10 +39,10 @@ class TyposDictionaryImpl {
         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.explicitIgnoreWords = (0, util_js_1.extractIgnoreValues)(typosDef, '!');
+        this.suggestions = (0, util_js_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.suggestionsLower = new Set((0, sync_1.pipe)(this.suggestions, textMappers_js_1.mapperRemoveCaseAndAccents));
         this.containsNoSuggestWords = this.ignoreWords.size > 0;
     }
     /**
@@ -139,7 +139,7 @@ class TyposDictionaryImpl {
         return [];
     }
 }
-const createCache = (0, AutoResolve_1.createAutoResolveWeakCache)();
+const createCache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
 /**
  * Create a dictionary where all words are to be forbidden.
  * @param entries - list of Typos Entries
@@ -149,7 +149,7 @@ const createCache = (0, AutoResolve_1.createAutoResolveWeakCache)();
  */
 function createTyposDictionary(entries, name, source) {
     return createCache.get(entries, () => {
-        const def = (0, Typos_1.processEntriesToTyposDef)(entries);
+        const def = (0, index_js_1.processEntriesToTyposDef)(entries);
         return new TyposDictionaryImpl(name, source, def);
     });
 }

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

@@ -1,3 +1,3 @@
-import type { DictionaryDefinitionInline, SpellingDictionary } from './SpellingDictionary';
+import type { DictionaryDefinitionInline, SpellingDictionary } from './SpellingDictionary.js';
 export declare function createInlineSpellingDictionary(inlineDict: DictionaryDefinitionInline, source: string): SpellingDictionary;
 //# sourceMappingURL=createInlineSpellingDictionary.d.ts.map

package/dist/cjs/SpellingDictionary/createInlineSpellingDictionary.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInlineSpellingDictionary = void 0;
+const AutoResolve_js_1 = require("../util/AutoResolve.js");
+const util_js_1 = require("../util/util.js");
+const createSpellingDictionary_js_1 = require("./createSpellingDictionary.js");
+const FlagWordsDictionary_js_1 = require("./FlagWordsDictionary.js");
+const IgnoreWordsDictionary_js_1 = require("./IgnoreWordsDictionary.js");
+const SpellingDictionaryCollection_js_1 = require("./SpellingDictionaryCollection.js");
+const SuggestDictionary_js_1 = require("./SuggestDictionary.js");
+const cache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
+function createInlineSpellingDictionary(inlineDict, source) {
+    return cache.get(inlineDict, () => {
+        const { words, flagWords, ignoreWords, suggestWords, name } = inlineDict;
+        const dictSources = [
+            words && (0, createSpellingDictionary_js_1.createSpellingDictionary)(words, name + '-words', source, inlineDict),
+            flagWords && (0, FlagWordsDictionary_js_1.createFlagWordsDictionary)(flagWords, name + '-flag-words', source),
+            ignoreWords && (0, IgnoreWordsDictionary_js_1.createIgnoreWordsDictionary)(ignoreWords, name + '-ignore-words', source),
+            suggestWords && (0, SuggestDictionary_js_1.createSuggestDictionary)(suggestWords, name + '-suggest', source),
+        ].filter(util_js_1.isDefined);
+        return (0, SpellingDictionaryCollection_js_1.createCollection)(dictSources, name, source);
+    });
+}
+exports.createInlineSpellingDictionary = createInlineSpellingDictionary;
+//# sourceMappingURL=createInlineSpellingDictionary.js.map

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/cjs/util/repMap.d.ts

@@ -0,0 +1,27 @@
+import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
+export type ReplaceMapper = (src: string) => string;
+export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper;
+declare function charsetToRepMapRegEx(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
+declare function createMapperRegExp(repMap: ReplaceMap): RegExp;
+interface RepTrieNode {
+    rep?: string[];
+    children?: Record<string, RepTrieNode>;
+}
+interface Edit {
+    b: number;
+    e: number;
+    r: string;
+}
+export declare function createRepMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): (word: string) => string[];
+declare function applyEdits(word: string, edits: Edit[]): string[];
+declare function calcAllEdits(root: RepTrieNode, word: string): Edit[];
+declare function createTrie(repMap: ReplaceMap | undefined, ignoreCharset?: string): RepTrieNode;
+export declare const __testing__: {
+    charsetToRepMap: typeof charsetToRepMapRegEx;
+    createMapperRegExp: typeof createMapperRegExp;
+    createTrie: typeof createTrie;
+    calcAllEdits: typeof calcAllEdits;
+    applyEdits: typeof applyEdits;
+};
+export {};
+//# sourceMappingURL=repMap.d.ts.map

package/dist/cjs/util/repMap.js

@@ -0,0 +1,158 @@
+"use strict";
+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_js_1 = require("./regexHelper.js");
+const util_js_1 = require("./util.js");
+function createMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (a) => a;
+    repMap = repMap || [];
+    const charsetMap = charsetToRepMapRegEx(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 charsetToRepMapRegEx(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .map((chars) => `[${chars.replace(/[\][\\]/g, '\\$&')}]`)
+        .map((map) => [map, replaceWith]);
+}
+function charsetToRepMap(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .flatMap((chars) => [...(0, cspell_trie_lib_1.expandCharacterSet)(chars)])
+        .map((char) => [char, replaceWith]);
+}
+function expandReplaceMap(repMap) {
+    return repMap.flatMap(([from, replaceWith]) => from.split('|').map((w) => [w, 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
+        .map((s) => {
+        try {
+            // fix up any nested ()
+            const r = s.match(/\(/) ? s.replace(/\((?=.*\))/g, '(?:').replace(/\(\?:\?/g, '(?') : s;
+            new RegExp(r);
+            s = r;
+        }
+        catch (err) {
+            return (0, regexHelper_js_1.escapeRegEx)(s);
+        }
+        return s;
+    })
+        .map((s) => `(${s})`)
+        .join('|');
+    const regEx = new RegExp(regExStr, 'g');
+    return regEx;
+}
+function createRepMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (word) => [word];
+    const trie = createTrie(repMap, ignoreCharset);
+    // const root = createTrie(repMap, ignoreCharset);
+    return (word) => {
+        const edits = calcAllEdits(trie, word);
+        return applyEdits(word, edits);
+    };
+}
+exports.createRepMapper = createRepMapper;
+function applyEdits(word, edits) {
+    if (!edits.length)
+        return [word];
+    // Prepare
+    const letterEdits = [];
+    for (let i = 0; i < word.length; ++i) {
+        letterEdits[i] = { edits: [{ b: i, e: i + 1, r: word[i] }], suffixes: [] };
+    }
+    letterEdits[word.length] = { edits: [], suffixes: [''] };
+    // Add edits
+    for (const edit of edits) {
+        const le = letterEdits[edit.b];
+        le.edits.push(edit);
+    }
+    // Apply edits in reverse
+    for (let i = word.length - 1; i >= 0; --i) {
+        const le = letterEdits[i];
+        const sfx = le.suffixes;
+        for (const edit of le.edits) {
+            const pfx = edit.r;
+            const nSfx = letterEdits[edit.e].suffixes;
+            for (const s of nSfx) {
+                sfx.push(pfx + s);
+            }
+        }
+    }
+    const results = new Set(letterEdits[0].suffixes);
+    return [...results];
+}
+function calcAllEdits(root, word) {
+    const edits = [];
+    function walk(node, b, e) {
+        if (node.rep) {
+            node.rep.forEach((r) => edits.push({ b, e, r }));
+        }
+        if (e === word.length || !node.children)
+            return;
+        const n = node.children[word[e]];
+        if (!n)
+            return;
+        walk(n, b, e + 1);
+    }
+    for (let i = 0; i < word.length; ++i) {
+        walk(root, i, i);
+    }
+    return edits;
+}
+function createTrie(repMap, ignoreCharset) {
+    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));
+    return trieRoot;
+}
+function addToTrie(node, match, replaceWith) {
+    while (match) {
+        const children = node.children || (node.children = Object.create(null));
+        const k = match[0];
+        const childNode = children[k] || (children[k] = Object.create(null));
+        node = childNode;
+        match = match.slice(1);
+    }
+    const s = new Set(node.rep || []);
+    s.add(replaceWith);
+    node.rep = [...s];
+}
+exports.__testing__ = {
+    charsetToRepMap: charsetToRepMapRegEx,
+    createMapperRegExp,
+    createTrie,
+    calcAllEdits,
+    applyEdits,
+};
+//# sourceMappingURL=repMap.js.map

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