cspell-lib 6.11.1 → 6.12.0

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -1,5 +1,5 @@
+import { SpellingDictionary, SpellingDictionaryCollection } from 'cspell-dictionary';
 import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
-import { SpellingDictionary, SpellingDictionaryCollection } from './SpellingDictionary';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
 export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;

package/dist/SpellingDictionary/Dictionaries.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
+const cspell_dictionary_1 = require("cspell-dictionary");
 const DictionarySettings_1 = require("../Settings/DictionarySettings");
 const util_1 = require("../util/util");
 const DictionaryLoader_1 = require("./DictionaryLoader");
-const SpellingDictionary_1 = require("./SpellingDictionary");
 function loadDictionaryDefs(defsToLoad) {
     return defsToLoad.map(DictionaryLoader_1.loadDictionary);
 }
@@ -30,21 +30,18 @@ function getDictionaryInternalSync(settings) {
 exports.getDictionaryInternalSync = getDictionaryInternalSync;
 function _getDictionaryInternal(settings, spellDictionaries) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
-    const { createSpellingDictionary, createIgnoreWordsDictionary, createCollection, createForbiddenWordsDictionary } = (0, SpellingDictionary_1.getSpellDictInterface)();
-    const settingsWordsDictionary = createSpellingDictionary(words, '[words]', 'From Settings `words`', {
+    const settingsWordsDictionary = (0, cspell_dictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
     });
     const settingsUserWordsDictionary = userWords.length
-        ? createSpellingDictionary(userWords, '[userWords]', 'From Settings `userWords`', {
+        ? (0, cspell_dictionary_1.createSpellingDictionary)(userWords, '[userWords]', 'From Settings `userWords`', {
             caseSensitive: true,
             weightMap: undefined,
         })
         : undefined;
-    const ignoreWordsDictionary = createIgnoreWordsDictionary(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`');
-    const flagWordsDictionary = createForbiddenWordsDictionary(flagWords, '[flagWords]', 'From Settings `flagWords`', {
-        weightMap: undefined,
-    });
+    const ignoreWordsDictionary = (0, cspell_dictionary_1.createIgnoreWordsDictionary)(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`');
+    const flagWordsDictionary = (0, cspell_dictionary_1.createForbiddenWordsDictionary)(flagWords, '[flagWords]', 'From Settings `flagWords`');
     const dictionaries = [
         ...spellDictionaries,
         settingsWordsDictionary,
@@ -52,6 +49,6 @@ function _getDictionaryInternal(settings, spellDictionaries) {
         ignoreWordsDictionary,
         flagWordsDictionary,
     ].filter(util_1.isDefined);
-    return createCollection(dictionaries, 'dictionary collection');
+    return (0, cspell_dictionary_1.createCollection)(dictionaries, 'dictionary collection');
 }
 //# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/DictionaryController/DictionaryLoader.d.ts

@@ -1,6 +1,6 @@
+import { SpellingDictionary } from 'cspell-dictionary';
 import { CSpellIO } from 'cspell-io';
 import { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef';
-import { SpellingDictionary } from '../SpellingDictionaryLibOld/SpellingDictionary';
 export declare type LoadOptions = DictionaryDefinitionInternal;
 export declare class DictionaryLoader {
     private cspellIO;

package/dist/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DictionaryLoader = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
+const cspell_dictionary_1 = require("cspell-dictionary");
 const errors_1 = require("../../util/errors");
-const createSpellingDictionary_1 = require("../SpellingDictionaryLibOld/createSpellingDictionary");
 const SpellingDictionaryError_1 = require("../SpellingDictionaryError");
-const SpellingDictionaryFromTrie_1 = require("../SpellingDictionaryLibOld/SpellingDictionaryFromTrie");
 const MAX_AGE = 10000;
 const loaders = {
     S: loadSimpleWordList,
@@ -98,7 +97,7 @@ class DictionaryLoader {
     }
     loadEntry(uri, options, now = Date.now()) {
         options = this.normalizeOptions(uri, options);
-        const pDictionary = load(this.reader, uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
+        const pDictionary = load(this.reader, uri, options).catch((e) => (0, cspell_dictionary_1.createFailedToLoadDictionary)(options.name, uri, new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load'), options));
         const pStat = this.getStat(uri);
         const pending = Promise.all([pDictionary, pStat]);
         const sig = now + Math.random();
@@ -141,7 +140,7 @@ class DictionaryLoader {
         }
         catch (e) {
             const error = (0, errors_1.toError)(e);
-            const dictionary = (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, error, 'failed to load'));
+            const dictionary = (0, cspell_dictionary_1.createFailedToLoadDictionary)(options.name, uri, new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, error, 'failed to load'), options);
             const pending = Promise.resolve([dictionary, stat]);
             return {
                 uri,
@@ -236,7 +235,7 @@ function _legacyWordListSync(lines, filename, options) {
     (0, sync_1.opMap)((line) => line.replace(/#.*/g, '')), 
     // Split on everything else
     (0, sync_1.opConcatMap)((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), (0, sync_1.opFilter)((word) => !!word));
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(words, options.name, filename, options);
+    return (0, cspell_dictionary_1.createSpellingDictionary)(words, options.name, filename, options);
 }
 async function wordsPerLineWordList(readLines, filename, options) {
     const lines = await readLines(filename);
@@ -252,22 +251,22 @@ function _wordsPerLineWordList(lines, filename, options) {
     (0, sync_1.opMap)((line) => line.replace(/#.*/g, '')), 
     // Split on everything else
     (0, sync_1.opConcatMap)((line) => line.split(/\s+/gu)), (0, sync_1.opFilter)((word) => !!word));
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(words, options.name, filename, options);
+    return (0, cspell_dictionary_1.createSpellingDictionary)(words, options.name, filename, options);
 }
 async function loadSimpleWordList(reader, filename, options) {
     const lines = await reader(filename);
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, options.name, filename, options);
+    return (0, cspell_dictionary_1.createSpellingDictionary)(lines, options.name, filename, options);
 }
 function loadSimpleWordListSync(readLinesSync, filename, options) {
     const lines = readLinesSync(filename);
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, options.name, filename, options);
+    return (0, cspell_dictionary_1.createSpellingDictionary)(lines, options.name, filename, options);
 }
 async function loadTrie(readLines, filename, options) {
     const lines = await readLines(filename);
-    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, options.name, filename, options);
+    return (0, cspell_dictionary_1.createSpellingDictionaryFromTrieFile)(lines, options.name, filename, options);
 }
 function loadTrieSync(readLinesSync, filename, options) {
     const lines = readLinesSync(filename);
-    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, options.name, filename, options);
+    return (0, cspell_dictionary_1.createSpellingDictionaryFromTrieFile)(lines, options.name, filename, options);
 }
 //# sourceMappingURL=DictionaryLoader.js.map

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,7 +1,7 @@
 import { CSpellIO } from 'cspell-io';
 import { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
 import { DictionaryLoader } from './DictionaryController';
-import { SpellingDictionary } from './SpellingDictionaryLibOld/SpellingDictionary';
+import { SpellingDictionary } from 'cspell-dictionary';
 export type { LoadOptions } from './DictionaryController';
 export declare function getDictionaryLoader(cspellIO?: CSpellIO): DictionaryLoader;
 export declare function loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -1,15 +1,15 @@
 import * as cspellDictModule from 'cspell-dictionary';
-import { SpellingDictionaryLibOld } from './SpellingDictionaryLibOld';
 export { CompoundWordsMethod } from 'cspell-trie-lib';
 declare const SpellingDictionaryModule: {
     readonly createCollection: typeof cspellDictModule.createCollection;
     readonly createForbiddenWordsDictionary: typeof cspellDictModule.createForbiddenWordsDictionary;
     readonly createSpellingDictionary: typeof cspellDictModule.createSpellingDictionary;
     readonly createIgnoreWordsDictionary: typeof cspellDictModule.createIgnoreWordsDictionary;
+    readonly createSpellingDictionaryFromTrieFile: typeof cspellDictModule.createSpellingDictionaryFromTrieFile;
 };
-declare type SpellDictInterface = typeof SpellingDictionaryModule | typeof SpellingDictionaryLibOld;
+declare type SpellDictInterface = typeof SpellingDictionaryModule;
 export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from 'cspell-dictionary';
 export declare function getSpellDictInterface(): SpellDictInterface;
-export declare const createSpellingDictionary: typeof import("./SpellingDictionaryLibOld/createSpellingDictionary").createSpellingDictionary | typeof cspellDictModule.createSpellingDictionary;
-export declare const createCollection: typeof import("./SpellingDictionaryLibOld/SpellingDictionaryCollection").createCollection | typeof cspellDictModule.createCollection;
+export declare const createSpellingDictionary: typeof cspellDictModule.createSpellingDictionary;
+export declare const createCollection: typeof cspellDictModule.createCollection;
 //# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionary.js

@@ -25,8 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCollection = exports.createSpellingDictionary = exports.getSpellDictInterface = exports.CompoundWordsMethod = void 0;
 const cspellDictModule = __importStar(require("cspell-dictionary"));
-const FeatureFlags_1 = require("../FeatureFlags");
-const SpellingDictionaryLibOld_1 = require("./SpellingDictionaryLibOld");
 var cspell_trie_lib_1 = require("cspell-trie-lib");
 Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: function () { return cspell_trie_lib_1.CompoundWordsMethod; } });
 const SpellingDictionaryModule = {
@@ -34,12 +32,10 @@ const SpellingDictionaryModule = {
     createForbiddenWordsDictionary: cspellDictModule.createForbiddenWordsDictionary,
     createSpellingDictionary: cspellDictModule.createSpellingDictionary,
     createIgnoreWordsDictionary: cspellDictModule.createIgnoreWordsDictionary,
+    createSpellingDictionaryFromTrieFile: cspellDictModule.createSpellingDictionaryFromTrieFile,
 };
-const flagUseCSpellDictionary = 'use-cspell-dictionary';
-(0, FeatureFlags_1.getSystemFeatureFlags)().register(flagUseCSpellDictionary, 'Use the CSpell Dictionary module.');
 function getSpellDictInterface() {
-    const useModule = (0, FeatureFlags_1.getSystemFeatureFlags)().getFlagBool(flagUseCSpellDictionary) ?? true;
-    return useModule ? SpellingDictionaryModule : SpellingDictionaryLibOld_1.SpellingDictionaryLibOld;
+    return SpellingDictionaryModule;
 }
 exports.getSpellDictInterface = getSpellDictInterface;
 exports.createSpellingDictionary = getSpellDictInterface().createSpellingDictionary;

package/dist/textValidation/textValidator.d.ts

@@ -1,5 +1,5 @@
 import { Sequence } from 'gensequence';
-import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionary';
+import { SpellingDictionary } from 'cspell-dictionary';
 import * as TextRange from '../util/TextRange';
 import { IncludeExcludeOptions, LineSegment, ValidationOptions, ValidationResult } from './ValidationTypes';
 export declare const defaultMaxNumberOfProblems = 200;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.11.1",
+  "version": "6.12.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,18 +48,18 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^6.11.1",
-    "@cspell/cspell-pipe": "^6.11.1",
-    "@cspell/cspell-types": "^6.11.1",
+    "@cspell/cspell-bundled-dicts": "^6.12.0",
+    "@cspell/cspell-pipe": "^6.12.0",
+    "@cspell/cspell-types": "^6.12.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-dictionary": "^6.11.1",
-    "cspell-glob": "^6.11.1",
-    "cspell-grammar": "^6.11.1",
-    "cspell-io": "^6.11.1",
-    "cspell-trie-lib": "^6.11.1",
+    "cspell-dictionary": "^6.12.0",
+    "cspell-glob": "^6.12.0",
+    "cspell-grammar": "^6.12.0",
+    "cspell-io": "^6.12.0",
+    "cspell-trie-lib": "^6.12.0",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "fs-extra": "^10.1.0",
@@ -94,5 +94,5 @@
     "rollup-plugin-dts": "^4.2.2",
     "ts-jest": "^29.0.3"
   },
-  "gitHead": "1a4559d3a82de15c7442ec15dbb3b7db99fb355e"
+  "gitHead": "211105141a72268d45710661d2a9b15656ecf65e"
 }

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionary.d.ts

@@ -1,4 +0,0 @@
-export { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions, } from 'cspell-dictionary';
-export { CompoundWordsMethod } from 'cspell-trie-lib';
-export type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
-//# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionary.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompoundWordsMethod = void 0;
-var cspell_trie_lib_1 = require("cspell-trie-lib");
-Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: function () { return cspell_trie_lib_1.CompoundWordsMethod; } });
-//# sourceMappingURL=SpellingDictionary.js.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryCollection.d.ts

@@ -1,35 +0,0 @@
-import { CompoundWordsMethod, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions } from './SpellingDictionary';
-declare function identityString(w: string): string;
-declare class SpellingDictionaryCollection implements SpellingDictionary {
-    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 const SpellingDictionaryCollectionLegacy: typeof SpellingDictionaryCollection;
-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 const __testing__: {
-    isWordInAnyDictionary: typeof isWordInAnyDictionary;
-    isWordForbiddenInAnyDictionary: typeof isWordForbiddenInAnyDictionary;
-};
-export {};
-//# sourceMappingURL=SpellingDictionaryCollection.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryCollection.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollectionLegacy = void 0;
-const cspell_trie_lib_1 = require("cspell-trie-lib");
-const gensequence_1 = require("gensequence");
-const Settings_1 = require("../../Settings");
-const Memorizer_1 = require("../../util/Memorizer");
-const util_1 = require("../../util/util");
-const SpellingDictionary_1 = require("./SpellingDictionary");
-const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
-function identityString(w) {
-    return w;
-}
-class SpellingDictionaryCollection {
-    constructor(dictionaries, name) {
-        this.dictionaries = dictionaries;
-        this.name = name;
-        this.options = { weightMap: undefined };
-        this.mapWord = identityString;
-        this.type = 'SpellingDictionaryCollection';
-        this._isForbiddenInDict = (0, Memorizer_1.memorizer)((word) => isWordForbiddenInAnyDictionary(this.dictionaries, word), SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie.cachedWordsLimit);
-        this._isNoSuggestWord = (0, Memorizer_1.memorizerKeyBy)((word, options) => {
-            if (!this.containsNoSuggestWords)
-                return false;
-            return !!isNoSuggestWordInAnyDictionary(this.dictionaries, word, options || {});
-        }, (word, options) => {
-            const opts = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(options);
-            return [word, opts.useCompounds, opts.ignoreCase].join();
-        }, SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie.cachedWordsLimit);
-        this.dictionaries = this.dictionaries.sort((a, b) => b.size - a.size);
-        this.source = dictionaries.map((d) => d.name).join(', ');
-        this.isDictionaryCaseSensitive = this.dictionaries.reduce((a, b) => a || b.isDictionaryCaseSensitive, false);
-        this.containsNoSuggestWords = this.dictionaries.reduce((a, b) => a || b.containsNoSuggestWords, false);
-    }
-    has(word, hasOptions) {
-        const options = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
-        return !!isWordInAnyDictionary(this.dictionaries, word, options) && !this.isForbidden(word);
-    }
-    find(word, hasOptions) {
-        const options = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
-        const { found = false, forbidden = false, noSuggest = false, } = findInAnyDictionary(this.dictionaries, word, options) || {};
-        return { found, forbidden, noSuggest };
-    }
-    isNoSuggestWord(word, options) {
-        return this._isNoSuggestWord(word, options);
-    }
-    isForbidden(word) {
-        return !!this._isForbiddenInDict(word) && !this.isNoSuggestWord(word);
-    }
-    suggest(...args) {
-        const [word] = args;
-        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
-        return this._suggest(word, suggestOptions);
-    }
-    _suggest(word, suggestOptions) {
-        const { numSuggestions = (0, Settings_1.getDefaultSettings)(false).numSuggestions || SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout, } = suggestOptions;
-        const prefixNoCase = cspell_trie_lib_1.CASE_INSENSITIVE_PREFIX;
-        const filter = (word, _cost) => {
-            return ((ignoreCase || word[0] !== prefixNoCase) &&
-                !this.isForbidden(word) &&
-                !this.isNoSuggestWord(word, suggestOptions));
-        };
-        const collector = (0, SpellingDictionaryMethods_1.suggestionCollector)(word, (0, util_1.clean)({
-            numSuggestions,
-            filter,
-            changeLimit: numChanges,
-            includeTies,
-            ignoreCase,
-            timeout,
-        }));
-        this.genSuggestions(collector, suggestOptions);
-        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
-    }
-    get size() {
-        return this.dictionaries.reduce((a, b) => a + b.size, 0);
-    }
-    genSuggestions(collector, suggestOptions) {
-        const _suggestOptions = { ...suggestOptions };
-        const { compoundMethod = SpellingDictionary_1.CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;
-        _suggestOptions.compoundMethod = this.options.useCompounds ? SpellingDictionary_1.CompoundWordsMethod.JOIN_WORDS : compoundMethod;
-        this.dictionaries.forEach((dict) => dict.genSuggestions(collector, _suggestOptions));
-    }
-    getErrors() {
-        return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
-    }
-}
-exports.SpellingDictionaryCollectionLegacy = SpellingDictionaryCollection;
-function createCollection(dictionaries, name) {
-    return new SpellingDictionaryCollection(dictionaries, name);
-}
-exports.createCollection = createCollection;
-function isWordInAnyDictionary(dicts, word, options) {
-    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.has(word, options));
-}
-function findInAnyDictionary(dicts, word, options) {
-    const found = dicts.map((dict) => dict.find(word, options)).filter(util_1.isDefined);
-    if (!found.length)
-        return undefined;
-    return found.reduce((a, b) => ({
-        found: a.forbidden ? a.found : b.forbidden ? b.found : a.found || b.found,
-        forbidden: a.forbidden || b.forbidden,
-        noSuggest: a.noSuggest || b.noSuggest,
-    }));
-}
-function isNoSuggestWordInAnyDictionary(dicts, word, options) {
-    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isNoSuggestWord(word, options));
-}
-function isWordForbiddenInAnyDictionary(dicts, word) {
-    return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isForbidden(word));
-}
-exports.__testing__ = {
-    isWordInAnyDictionary,
-    isWordForbiddenInAnyDictionary,
-};
-//# sourceMappingURL=SpellingDictionaryCollection.js.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryFromTrie.d.ts

@@ -1,36 +0,0 @@
-import type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
-import { CompoundWordsMethod, Trie } from 'cspell-trie-lib';
-import { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions } from './SpellingDictionary';
-export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
-    readonly trie: Trie;
-    readonly name: string;
-    readonly options: SpellingDictionaryOptions;
-    readonly source: string;
-    static readonly cachedWordsLimit = 50000;
-    private _size;
-    readonly knownWords: Set<string>;
-    readonly unknownWords: Set<string>;
-    readonly mapWord: (word: string) => string;
-    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;
-    has(word: string, hasOptions?: HasOptions): boolean;
-    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
-    private resolveOptions;
-    private _find;
-    private findAnyForm;
-    private _findAnyForm;
-    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[];
-    private _suggest;
-    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
-    getErrors(): Error[];
-}
-export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
-//# sourceMappingURL=SpellingDictionaryFromTrie.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryFromTrie.js

@@ -1,150 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpellingDictionaryTrie = exports.SpellingDictionaryFromTrie = void 0;
-const cspell_trie_lib_1 = require("cspell-trie-lib");
-const Settings_1 = require("../../Settings");
-const Memorizer_1 = require("../../util/Memorizer");
-const repMap_1 = require("../../util/repMap");
-const util_1 = require("../../util/util");
-const charset_1 = require("./charset");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
-class SpellingDictionaryFromTrie {
-    constructor(trie, name, options, source = 'from trie', size) {
-        this.trie = trie;
-        this.name = name;
-        this.options = options;
-        this.source = source;
-        this._size = 0;
-        this.knownWords = new Set();
-        this.unknownWords = new Set();
-        this.type = 'SpellingDictionaryFromTrie';
-        this._find = (0, Memorizer_1.memorizer)((word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase), SpellingDictionaryFromTrie.cachedWordsLimit);
-        this.mapWord = (0, repMap_1.createMapper)(options.repMap || []);
-        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) {
-            // walk the trie and get the approximate size.
-            const i = this.trie.iterate();
-            let deeper = true;
-            let size = 0;
-            for (let r = i.next(); !r.done; r = i.next(deeper)) {
-                // count all nodes even though they are not words.
-                // because we are not going to all the leaves, this should give a good enough approximation.
-                size += 1;
-                deeper = r.value.text.length < 5;
-            }
-            this._size = size;
-        }
-        return this._size;
-    }
-    has(word, hasOptions) {
-        const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
-        const r = this._find(word, useCompounds, ignoreCase);
-        return !!r && !r.forbidden && !!r.found;
-    }
-    find(word, hasOptions) {
-        const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
-        const r = this._find(word, useCompounds, ignoreCase);
-        const { forbidden = this.isForbidden(word) } = r || {};
-        if (!r && !forbidden)
-            return undefined;
-        const { found = forbidden ? word : false } = r || {};
-        const noSuggest = found !== false && this.containsNoSuggestWords;
-        return { found, forbidden, noSuggest };
-    }
-    resolveOptions(hasOptions) {
-        const { useCompounds = this.options.useCompounds, ignoreCase = true } = (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, ''));
-        }
-        for (const form of outerForms) {
-            const r = this._findAnyForm(form, useCompounds, ignoreCase);
-            if (r)
-                return r;
-        }
-        return undefined;
-    }
-    _findAnyForm(word, useCompounds, ignoreCase) {
-        const mWord = this.mapWord(word.normalize('NFC'));
-        const opts = { caseSensitive: !ignoreCase };
-        const findResult = this.trie.findWord(mWord, opts);
-        if (findResult.found !== false) {
-            return findResult;
-        }
-        const forms = (0, SpellingDictionaryMethods_1.wordSearchForms)(mWord, this.isDictionaryCaseSensitive, ignoreCase);
-        for (const w of forms) {
-            const findResult = this.trie.findWord(w, opts);
-            if (findResult.found !== false) {
-                return findResult;
-            }
-        }
-        if (useCompounds) {
-            opts.useLegacyWordCompounds = useCompounds;
-            for (const w of forms) {
-                const findResult = this.trie.findWord(w, opts);
-                if (findResult.found !== false) {
-                    return findResult;
-                }
-            }
-        }
-        return undefined;
-    }
-    isNoSuggestWord(word, options) {
-        return this.containsNoSuggestWords ? this.has(word, options) : false;
-    }
-    isForbidden(word) {
-        return this.trie.isForbiddenWord(word);
-    }
-    suggest(...args) {
-        const [word] = args;
-        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
-        return this._suggest(word, suggestOptions);
-    }
-    _suggest(word, suggestOptions) {
-        const { numSuggestions = (0, Settings_1.getDefaultSettings)(false).numSuggestions || SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, includeTies, ignoreCase, timeout, } = suggestOptions;
-        function filter(_word) {
-            return true;
-        }
-        const collector = (0, cspell_trie_lib_1.suggestionCollector)(word, (0, util_1.clean)({
-            numSuggestions,
-            filter,
-            changeLimit: numChanges,
-            includeTies,
-            ignoreCase,
-            timeout,
-            weightMap: this.weightMap,
-        }));
-        this.genSuggestions(collector, suggestOptions);
-        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
-    }
-    genSuggestions(collector, suggestOptions) {
-        if (this.options.noSuggest)
-            return;
-        const _compoundMethod = suggestOptions.compoundMethod ??
-            (this.options.useCompounds ? cspell_trie_lib_1.CompoundWordsMethod.JOIN_WORDS : cspell_trie_lib_1.CompoundWordsMethod.NONE);
-        (0, SpellingDictionaryMethods_1.wordSuggestFormsArray)(collector.word).forEach((w) => this.trie.genSuggestions((0, SpellingDictionaryMethods_1.impersonateCollector)(collector, w), _compoundMethod));
-    }
-    getErrors() {
-        return [];
-    }
-}
-exports.SpellingDictionaryFromTrie = SpellingDictionaryFromTrie;
-SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
-function createSpellingDictionaryTrie(data, name, source, options) {
-    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;
-//# sourceMappingURL=SpellingDictionaryFromTrie.js.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryMethods.d.ts

@@ -1,29 +0,0 @@
-import { DictionaryInformation } from '@cspell/cspell-types';
-import { CompoundWordsMethod, SuggestionResult, WeightMap } from 'cspell-trie-lib';
-import { HasOptions, SearchOptions, SpellingDictionary, SuggestOptions } from './SpellingDictionary';
-export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
-export declare type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
-export declare type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
-export declare const defaultNumSuggestions = 10;
-declare function wordSearchFormsArray(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): string[];
-export declare function wordSearchForms(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): Set<string>;
-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;
-export declare function suggestArgsToSuggestOptions(args: SuggestArgs): SuggestOptions;
-export declare function createWeightMapFromDictionaryInformation(di: undefined): undefined;
-export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation): WeightMap;
-export declare function createWeightMapFromDictionaryInformation(di: DictionaryInformation | undefined): WeightMap | undefined;
-export declare const __testMethods__: {
-    wordSearchForms: typeof wordSearchForms;
-    wordSearchFormsArray: typeof wordSearchFormsArray;
-    wordDictionaryForms: typeof wordDictionaryForms;
-    wordDictionaryFormsCollector: typeof wordDictionaryFormsCollector;
-};
-//# sourceMappingURL=SpellingDictionaryMethods.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryMethods.js

@@ -1,114 +0,0 @@
-"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;
-const cspell_trie_lib_1 = require("cspell-trie-lib");
-const trie_util_1 = require("cspell-trie-lib/dist/lib/trie-util");
-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; } });
-Object.defineProperty(exports, "suggestionCollector", { enumerable: true, get: function () { return cspell_trie_lib_2.suggestionCollector; } });
-exports.defaultNumSuggestions = 10;
-function wordSearchFormsArray(word, isDictionaryCaseSensitive, ignoreCase) {
-    return [...wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase)];
-}
-function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
-    const forms = new Set();
-    word = word.normalize('NFC');
-    const wordLc = word.toLowerCase();
-    if (ignoreCase) {
-        if (isDictionaryCaseSensitive) {
-            forms.add(wordLc);
-        }
-        else {
-            forms.add(wordLc);
-            // Legacy remove any unbound accents
-            forms.add(wordLc.replace(/\p{M}/gu, ''));
-        }
-    }
-    else {
-        if (isDictionaryCaseSensitive) {
-            forms.add(word);
-            forms.add(wordLc);
-            // HOUSE -> House, house
-            if ((0, text_1.isUpperCase)(word)) {
-                forms.add((0, text_1.ucFirst)(wordLc));
-            }
-        }
-        else {
-            forms.add(wordLc);
-            // Legacy remove any unbound accents
-            forms.add(wordLc.replace(/\p{M}/gu, ''));
-        }
-    }
-    return forms;
-}
-exports.wordSearchForms = wordSearchForms;
-function wordSuggestFormsArray(word) {
-    return [...wordSuggestForms(word)];
-}
-exports.wordSuggestFormsArray = wordSuggestFormsArray;
-function wordSuggestForms(word) {
-    word = word.normalize('NFC');
-    const forms = new Set([word]);
-    const wordLc = word.toLowerCase();
-    forms.add(wordLc);
-    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;
-}
-exports.hasOptionToSearchOption = hasOptionToSearchOption;
-function suggestArgsToSuggestOptions(args) {
-    const [_word, options, compoundMethod, numChanges, ignoreCase] = args;
-    const suggestOptions = typeof options === 'object'
-        ? options
-        : (0, trie_util_1.clean)({
-            numSuggestions: options,
-            compoundMethod,
-            numChanges,
-            ignoreCase,
-            includeTies: undefined,
-            timeout: undefined,
-        });
-    return suggestOptions;
-}
-exports.suggestArgsToSuggestOptions = suggestArgsToSuggestOptions;
-function createWeightMapFromDictionaryInformation(di) {
-    return di ? (0, cspell_trie_lib_1.mapDictionaryInformationToWeightMap)(di) : undefined;
-}
-exports.createWeightMapFromDictionaryInformation = createWeightMapFromDictionaryInformation;
-exports.__testMethods__ = {
-    wordSearchForms,
-    wordSearchFormsArray,
-    wordDictionaryForms,
-    wordDictionaryFormsCollector,
-};
-//# sourceMappingURL=SpellingDictionaryMethods.js.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/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/SpellingDictionaryLibOld/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

package/dist/SpellingDictionary/SpellingDictionaryLibOld/createSpellingDictionary.d.ts

@@ -1,8 +0,0 @@
-import { IterableLike } from '../../util/IterableLike';
-import { SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary';
-import { SpellingDictionaryLoadError } from '../SpellingDictionaryError';
-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;
-export declare function createFailedToLoadDictionary(error: SpellingDictionaryLoadError): SpellingDictionary;
-export declare function createIgnoreWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
-//# sourceMappingURL=createSpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/createSpellingDictionary.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIgnoreWordsDictionary = exports.createFailedToLoadDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = 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({
-    weightMap: undefined,
-});
-const cachedDictionaries = new simpleCache_1.AutoWeakCache(_createSpellingDictionary, 64);
-const maxSetSize = 3;
-const cachedParamsByWordList = new simpleCache_1.SimpleCache(64);
-function createSpellingDictionary(wordList, name, source, options) {
-    const params = [wordList, name, source, options];
-    if (!Array.isArray(wordList)) {
-        return _createSpellingDictionary(params);
-    }
-    const cached = cachedParamsByWordList.get(name) || new Set();
-    for (const cachedParams of cached) {
-        if ((0, fast_equals_1.deepEqual)(params, cachedParams)) {
-            return cachedDictionaries.get(cachedParams);
-        }
-    }
-    if (cached.size > maxSetSize)
-        cached.clear();
-    cached.add(params);
-    cachedParamsByWordList.set(name, cached);
-    return cachedDictionaries.get(params);
-}
-exports.createSpellingDictionary = createSpellingDictionary;
-function _createSpellingDictionary(params) {
-    const [wordList, name, source, options] = params;
-    // console.log(`createSpellingDictionary ${name} ${source}`);
-    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) };
-    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(`createForbiddenWordsDictionary ${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 { options, uri: source } = error;
-    const errors = [error];
-    return {
-        name: options.name,
-        source,
-        type: 'error',
-        containsNoSuggestWords: false,
-        has: () => false,
-        find: () => undefined,
-        isNoSuggestWord: () => false,
-        isForbidden: () => false,
-        suggest: () => [],
-        mapWord: (a) => a,
-        genSuggestions: () => {
-            return;
-        },
-        size: 0,
-        options,
-        isDictionaryCaseSensitive: false,
-        getErrors: () => errors,
-    };
-}
-exports.createFailedToLoadDictionary = createFailedToLoadDictionary;
-function createIgnoreWordsDictionary(wordList, name, source) {
-    // console.log('createIgnoreWordsDictionary %o', wordList);
-    return createSpellingDictionary(wordList, name, source, {
-        caseSensitive: true,
-        noSuggest: true,
-        weightMap: undefined,
-        supportNonStrictSearches: true,
-    });
-}
-exports.createIgnoreWordsDictionary = createIgnoreWordsDictionary;
-//# sourceMappingURL=createSpellingDictionary.js.map

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

@@ -1,11 +0,0 @@
-export * from './SpellingDictionary';
-import { createCollection } from './SpellingDictionaryCollection';
-import { createFailedToLoadDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary } from './createSpellingDictionary';
-export declare const SpellingDictionaryLibOld: {
-    readonly createCollection: typeof createCollection;
-    readonly createFailedToLoadDictionary: typeof createFailedToLoadDictionary;
-    readonly createForbiddenWordsDictionary: typeof createForbiddenWordsDictionary;
-    readonly createIgnoreWordsDictionary: typeof createIgnoreWordsDictionary;
-    readonly createSpellingDictionary: typeof createSpellingDictionary;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/index.js

@@ -1,28 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpellingDictionaryLibOld = void 0;
-__exportStar(require("./SpellingDictionary"), exports);
-const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-exports.SpellingDictionaryLibOld = {
-    createCollection: SpellingDictionaryCollection_1.createCollection,
-    createFailedToLoadDictionary: createSpellingDictionary_1.createFailedToLoadDictionary,
-    createForbiddenWordsDictionary: createSpellingDictionary_1.createForbiddenWordsDictionary,
-    createIgnoreWordsDictionary: createSpellingDictionary_1.createIgnoreWordsDictionary,
-    createSpellingDictionary: createSpellingDictionary_1.createSpellingDictionary,
-};
-//# sourceMappingURL=index.js.map