cspell-lib 5.18.5 → 5.19.2

package/dist/Settings/configLoader.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -19,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.extractImportErrors = exports.clearCachedSettingsFiles = exports.getCachedFileSize = exports.getGlobalSettings = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfig = exports.searchForConfig = exports.readSettings = exports.defaultConfigFilenames = exports.defaultFileName = exports.sectionCSpell = void 0;
+exports.__testing__ = exports.extractImportErrors = exports.clearCachedSettingsFiles = exports.getCachedFileSize = exports.getGlobalSettings = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfigSync = exports.loadConfig = exports.searchForConfigSync = exports.searchForConfig = exports.readSettings = exports.defaultConfigFilenames = exports.defaultFileName = exports.sectionCSpell = void 0;
 const json = __importStar(require("comment-json"));
 const cosmiconfig_1 = require("cosmiconfig");
 const path = __importStar(require("path"));
@@ -215,16 +219,20 @@ function readSettings(filename, relativeToOrDefault, defaultValue) {
     return importSettings(ref, defaultValue, defaultValue || defaultPnPSettings);
 }
 exports.readSettings = readSettings;
-async function normalizeSearchForConfigResult(searchPath, searchResult, pnpSettings) {
-    var _a;
+async function normalizeSearchForConfigResultAsync(searchPath, searchResult, pnpSettings) {
     let result;
-    let error;
     try {
         result = (await searchResult) || undefined;
     }
     catch (cause) {
-        error = new ImportError_1.ImportError(`Failed to find config file at: "${searchPath}"`, cause);
+        result = new ImportError_1.ImportError(`Failed to find config file at: "${searchPath}"`, cause);
     }
+    return normalizeSearchForConfigResult(searchPath, result, pnpSettings);
+}
+function normalizeSearchForConfigResult(searchPath, searchResult, pnpSettings) {
+    var _a;
+    const error = searchResult instanceof ImportError_1.ImportError ? searchResult : undefined;
+    const result = searchResult instanceof ImportError_1.ImportError ? undefined : searchResult;
     const filepath = result === null || result === void 0 ? void 0 : result.filepath;
     if (filepath) {
         const cached = cachedFiles.get(filepath);
@@ -252,9 +260,20 @@ async function normalizeSearchForConfigResult(searchPath, searchResult, pnpSetti
     };
 }
 function searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
-    return normalizeSearchForConfigResult(searchFrom || process.cwd(), cspellConfigExplorer.search(searchFrom), pnpSettings).then((r) => (r.filepath ? r.config : undefined));
+    return normalizeSearchForConfigResultAsync(searchFrom || process.cwd(), cspellConfigExplorer.search(searchFrom), pnpSettings).then((r) => (r.filepath ? r.config : undefined));
 }
 exports.searchForConfig = searchForConfig;
+function searchForConfigSync(searchFrom, pnpSettings = defaultPnPSettings) {
+    let searchResult;
+    try {
+        searchResult = cspellConfigExplorerSync.search(searchFrom) || undefined;
+    }
+    catch (err) {
+        searchResult = new ImportError_1.ImportError(`Failed to find config file from: "${searchFrom}"`, err);
+    }
+    return normalizeSearchForConfigResult(searchFrom || process.cwd(), searchResult, pnpSettings).config;
+}
+exports.searchForConfigSync = searchForConfigSync;
 /**
  * Load a CSpell configuration files.
  * @param file - path or package reference to load.
@@ -266,9 +285,30 @@ function loadConfig(file, pnpSettings = defaultPnPSettings) {
     if (cached) {
         return Promise.resolve(cached);
     }
-    return normalizeSearchForConfigResult(file, cspellConfigExplorer.load(file), pnpSettings).then((r) => r.config);
+    return normalizeSearchForConfigResultAsync(file, cspellConfigExplorer.load(file), pnpSettings).then((r) => r.config);
 }
 exports.loadConfig = loadConfig;
+/**
+ * Load a CSpell configuration files.
+ * @param filename - path or package reference to load.
+ * @param pnpSettings - PnP settings
+ * @returns normalized CSpellSettings
+ */
+function loadConfigSync(filename, pnpSettings = defaultPnPSettings) {
+    const cached = cachedFiles.get(path.resolve(filename));
+    if (cached) {
+        return cached;
+    }
+    let searchResult;
+    try {
+        searchResult = cspellConfigExplorerSync.load(filename) || undefined;
+    }
+    catch (err) {
+        searchResult = new ImportError_1.ImportError(`Failed to find config file at: "${filename}"`, err);
+    }
+    return normalizeSearchForConfigResult(filename, searchResult, pnpSettings).config;
+}
+exports.loadConfigSync = loadConfigSync;
 function loadPnP(pnpSettings, searchFrom) {
     if (!pnpSettings.usePnP) {
         return Promise.resolve(undefined);
@@ -379,10 +419,11 @@ function toGlobDef(g, root, source) {
         return g.map((g) => toGlobDef(g, root, source));
     }
     if (typeof g === 'string') {
-        return toGlobDef({
-            glob: g,
-            root,
-        }, root, source);
+        const glob = { glob: g };
+        if (root !== undefined) {
+            glob.root = root;
+        }
+        return toGlobDef(glob, root, source);
     }
     if (source) {
         return { ...g, source };
@@ -446,7 +487,7 @@ function normalizeLanguageSettings(languageSettings) {
         return undefined;
     function fixLocale(s) {
         const { local: locale, ...rest } = s;
-        return { locale, ...rest };
+        return util.clean({ locale, ...rest });
     }
     return languageSettings.map(fixLocale);
 }

package/dist/Settings/link.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -22,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.removePathsFromGlobalImports = exports.addPathsToGlobalImports = exports.listGlobalImports = void 0;
 const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
+const util_1 = require("../util/util");
 const configLoader_1 = require("./configLoader");
 const GlobalSettings_1 = require("./GlobalSettings");
 function listGlobalImports() {
@@ -129,12 +134,12 @@ function resolveSettings(filename) {
     const ref = settings.__importRef;
     const resolvedToFilename = ref === null || ref === void 0 ? void 0 : ref.filename;
     const error = ((_a = ref === null || ref === void 0 ? void 0 : ref.error) === null || _a === void 0 ? void 0 : _a.message) || (!resolvedToFilename && 'File not Found') || undefined;
-    return {
+    return (0, util_1.clean)({
         filename,
         resolvedToFilename,
         error,
         settings,
-    };
+    });
 }
 function normalizeImports(imports) {
     return typeof imports === 'string' ? [imports] : imports || [];

package/dist/Settings/patterns.d.ts

@@ -1,3 +1,3 @@
 import type { RegExpPatternDefinition } from '@cspell/cspell-types';
-export declare function resolvePatterns(regExpList?: (string | RegExp)[], patternDefinitions?: RegExpPatternDefinition[]): (string | RegExp)[];
+export declare function resolvePatterns(regExpList?: (string | RegExp)[], patternDefinitions?: RegExpPatternDefinition[]): RegExp[];
 //# sourceMappingURL=patterns.d.ts.map

package/dist/Settings/patterns.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePatterns = void 0;
+const text_1 = require("../util/text");
 const util_1 = require("../util/util");
 function resolvePatterns(regExpList = [], patternDefinitions = []) {
     const patternMap = new Map(patternDefinitions.map((def) => [def.name.toLowerCase(), def.pattern]));
@@ -22,7 +23,10 @@ function resolvePatterns(regExpList = [], patternDefinitions = []) {
         }
     }
     const patternList = regExpList.map(resolvePattern).filter(util_1.isDefined);
-    return [...flatten(patternList)];
+    return [...flatten(patternList)].map(toRegExp).filter(util_1.isDefined);
 }
 exports.resolvePatterns = resolvePatterns;
+function toRegExp(pattern) {
+    return pattern instanceof RegExp ? new RegExp(pattern) : (0, text_1.stringToRegExp)(pattern, 'gim', 'g');
+}
 //# sourceMappingURL=patterns.js.map

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -2,6 +2,8 @@ import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/
 import { SpellingDictionary } from './SpellingDictionary';
 import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
+export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
 export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
+export declare function getDictionaryInternalSync(settings: CSpellSettingsInternal): SpellingDictionaryCollection;
 //# sourceMappingURL=Dictionaries.d.ts.map

package/dist/SpellingDictionary/Dictionaries.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefs = void 0;
+exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
 const DictionarySettings_1 = require("../Settings/DictionarySettings");
 const util_1 = require("../util/util");
 const createSpellingDictionary_1 = require("./createSpellingDictionary");
@@ -10,14 +10,27 @@ function loadDictionaryDefs(defsToLoad) {
     return defsToLoad.map((def) => (0, DictionaryLoader_1.loadDictionary)(def.path, def));
 }
 exports.loadDictionaryDefs = loadDictionaryDefs;
+function loadDictionaryDefsSync(defsToLoad) {
+    return defsToLoad.map((def) => (0, DictionaryLoader_1.loadDictionarySync)(def.path, def));
+}
+exports.loadDictionaryDefsSync = loadDictionaryDefsSync;
 function refreshDictionaryCache(maxAge) {
     return (0, DictionaryLoader_1.refreshCacheEntries)(maxAge);
 }
 exports.refreshDictionaryCache = refreshDictionaryCache;
 const emptyWords = Object.freeze([]);
-function getDictionaryInternal(settings) {
+async function getDictionaryInternal(settings) {
+    const spellDictionaries = await Promise.all(loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings)));
+    return _getDictionaryInternal(settings, spellDictionaries);
+}
+exports.getDictionaryInternal = getDictionaryInternal;
+function getDictionaryInternalSync(settings) {
+    const spellDictionaries = loadDictionaryDefsSync((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
+    return _getDictionaryInternal(settings, spellDictionaries);
+}
+exports.getDictionaryInternalSync = getDictionaryInternalSync;
+function _getDictionaryInternal(settings, spellDictionaries) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
-    const spellDictionaries = loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
     const settingsWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
@@ -43,7 +56,6 @@ function getDictionaryInternal(settings) {
         ignoreWordsDictionary,
         flagWordsDictionary,
     ].filter(util_1.isDefined);
-    return (0, SpellingDictionaryCollection_1.createCollectionP)(dictionaries, 'dictionary collection');
+    return (0, SpellingDictionaryCollection_1.createCollection)(dictionaries, 'dictionary collection');
 }
-exports.getDictionaryInternal = getDictionaryInternal;
 //# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,15 +1,23 @@
 import { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
 import { SpellingDictionary } from './SpellingDictionary';
 export declare type LoadOptions = DictionaryDefinitionInternal;
+declare enum LoadingState {
+    Loaded = 0,
+    Loading = 1
+}
 interface CacheEntry {
     uri: string;
     options: LoadOptions;
     ts: number;
-    state: Promise<Stats | Error>;
-    dictionary: Promise<SpellingDictionary>;
+    stat: Stats | Error | undefined;
+    dictionary: SpellingDictionary | undefined;
+    pending: Promise<readonly [SpellingDictionary, Stats | Error]>;
+    loadingState: LoadingState;
+    sig: number;
 }
 export declare type LoaderType = keyof Loaders;
 export declare type Loader = (filename: string, options: LoadOptions) => Promise<SpellingDictionary>;
+export declare type LoaderSync = (filename: string, options: LoadOptions) => SpellingDictionary;
 export interface Loaders {
     S: Loader;
     C: Loader;
@@ -17,7 +25,15 @@ export interface Loaders {
     W: Loader;
     default: Loader;
 }
+export interface SyncLoaders {
+    S: LoaderSync;
+    C: LoaderSync;
+    T: LoaderSync;
+    W: LoaderSync;
+    default: LoaderSync;
+}
 export declare function loadDictionary(uri: string, options: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
+export declare function loadDictionarySync(uri: string, options: DictionaryDefinitionInternal): SpellingDictionary;
 /**
  * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
  * @param maxAge - Only check the dictionary if it has been at least `maxAge` ms since the last check.
@@ -64,5 +80,8 @@ interface StatsBase<T> {
     birthtime: Date;
 }
 export declare type Stats = StatsBase<number>;
+export declare const __testing__: {
+    debugLog: string[];
+};
 export {};
 //# sourceMappingURL=DictionaryLoader.d.ts.map

package/dist/SpellingDictionary/DictionaryLoader.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -19,10 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testing = exports.refreshCacheEntries = exports.loadDictionary = void 0;
-const fs_extra_1 = require("fs-extra");
+exports.__testing__ = exports.testing = exports.refreshCacheEntries = exports.loadDictionarySync = exports.loadDictionary = void 0;
+const fs_1 = require("fs");
 const gensequence_1 = require("gensequence");
 const path = __importStar(require("path"));
+const util_1 = require("util");
+const errors_1 = require("../util/errors");
 const fileReader_1 = require("../util/fileReader");
 const createSpellingDictionary_1 = require("./createSpellingDictionary");
 const SpellingDictionaryError_1 = require("./SpellingDictionaryError");
@@ -35,19 +41,63 @@ const loaders = {
     T: loadTrie,
     default: loadSimpleWordList,
 };
+const loadersSync = {
+    S: loadSimpleWordListSync,
+    C: legacyWordListSync,
+    W: wordsPerLineWordListSync,
+    T: loadTrieSync,
+    default: loadSimpleWordListSync,
+};
+var LoadingState;
+(function (LoadingState) {
+    LoadingState[LoadingState["Loaded"] = 0] = "Loaded";
+    LoadingState[LoadingState["Loading"] = 1] = "Loading";
+})(LoadingState || (LoadingState = {}));
+const debugLog = [];
+const debugMode = false;
+function __log(msg) {
+    debugMode && debugLog.push(msg);
+}
 const dictionaryCache = new Map();
 function loadDictionary(uri, options) {
     const key = calcKey(uri, options);
     const entry = dictionaryCache.get(key);
     if (entry) {
-        return entry.dictionary;
+        return entry.pending.then(([dictionary]) => dictionary);
     }
     const loadedEntry = loadEntry(uri, options);
     dictionaryCache.set(key, loadedEntry);
-    return loadedEntry.dictionary;
+    return loadedEntry.pending.then(([dictionary]) => dictionary);
 }
 exports.loadDictionary = loadDictionary;
-const importantOptionKeys = ['name', 'noSuggest', 'useCompounds'];
+function loadDictionarySync(uri, options) {
+    const key = calcKey(uri, options);
+    const entry = dictionaryCache.get(key);
+    if ((entry === null || entry === void 0 ? void 0 : entry.dictionary) && entry.loadingState === LoadingState.Loaded) {
+        // if (entry.options.name === 'temp') {
+        //     __log(
+        //         `Cache Found ${entry.options.name}; ts: ${entry.sig.toFixed(2)}; file: ${path.relative(
+        //             process.cwd(),
+        //             entry.uri
+        //         )}`
+        //     );
+        // }
+        return entry.dictionary;
+    }
+    // if (options.name === 'temp') {
+    //     __log(
+    //         `Cache Miss ${options.name}; ts: ${entry?.sig.toFixed(2) || Date.now()}; file: ${path.relative(
+    //             process.cwd(),
+    //             uri
+    //         )}`
+    //     );
+    // }
+    const loadedEntry = loadEntrySync(uri, options);
+    dictionaryCache.set(key, loadedEntry);
+    return loadedEntry.dictionary;
+}
+exports.loadDictionarySync = loadDictionarySync;
+const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
 function calcKey(uri, options) {
     const loaderType = determineType(uri, options);
     const optValues = importantOptionKeys.map((k) => { var _a; return ((_a = options[k]) === null || _a === void 0 ? void 0 : _a.toString()) || ''; });
@@ -60,21 +110,39 @@ function calcKey(uri, options) {
  * @param now - optional timestamp representing now. (Mostly used in testing)
  */
 async function refreshCacheEntries(maxAge = MAX_AGE, now = Date.now()) {
-    await Promise.all([...dictionaryCache].map(([, entry]) => refreshEntry(entry, maxAge, now)));
+    await Promise.all([...dictionaryCache.values()].map((entry) => refreshEntry(entry, maxAge, now)));
 }
 exports.refreshCacheEntries = refreshCacheEntries;
 async function refreshEntry(entry, maxAge, now) {
     if (now - entry.ts >= maxAge) {
+        const sig = now + Math.random();
         // Write to the ts, so the next one will not do it.
+        entry.sig = sig;
         entry.ts = now;
-        const pStat = (0, fs_extra_1.stat)(entry.uri).catch((e) => e);
-        const [state, oldState] = await Promise.all([pStat, entry.state]);
-        if (entry.ts === now && !isEqual(state, oldState)) {
+        const pStat = getStat(entry.uri);
+        const [newStat] = await Promise.all([pStat, entry.pending]);
+        const hasChanged = !isEqual(newStat, entry.stat);
+        const sigMatches = entry.sig === sig;
+        // if (entry.options.name === 'temp') {
+        //     const processedAt = Date.now();
+        //     __log(
+        //         `Refresh ${entry.options.name}; sig: ${sig.toFixed(
+        //             2
+        //         )} at ${processedAt}; Sig Matches: ${sigMatches.toString()}; changed: ${hasChanged.toString()}; file: ${path.relative(
+        //             process.cwd(),
+        //             entry.uri
+        //         )}`
+        //     );
+        // }
+        if (sigMatches && hasChanged) {
+            entry.loadingState = LoadingState.Loading;
             dictionaryCache.set(calcKey(entry.uri, entry.options), loadEntry(entry.uri, entry.options));
         }
     }
 }
 function isEqual(a, b) {
+    if (!b)
+        return false;
     if (isError(a)) {
         return isError(b) && a.message === b.message && a.name === b.name;
     }
@@ -82,22 +150,69 @@ function isEqual(a, b) {
 }
 function isError(e) {
     const err = e;
-    return !!(err.name && err.message);
+    return !!err.message;
 }
 function loadEntry(uri, options, now = Date.now()) {
-    const dictionary = load(uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
-    return {
+    const pDictionary = load(uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
+    const pStat = getStat(uri);
+    const pending = Promise.all([pDictionary, pStat]);
+    const sig = now + Math.random();
+    const entry = {
         uri,
         options,
         ts: now,
-        state: (0, fs_extra_1.stat)(uri).catch((e) => e),
-        dictionary,
+        stat: undefined,
+        dictionary: undefined,
+        pending,
+        loadingState: LoadingState.Loading,
+        sig,
     };
+    // eslint-disable-next-line promise/catch-or-return
+    pending.then(([dictionary, stat]) => {
+        entry.stat = stat;
+        entry.dictionary = dictionary;
+        entry.loadingState = LoadingState.Loaded;
+        return;
+    });
+    return entry;
+}
+function loadEntrySync(uri, options, now = Date.now()) {
+    const stat = getStatSync(uri);
+    const sig = now + Math.random();
+    try {
+        const dictionary = loadSync(uri, options);
+        const pending = Promise.resolve([dictionary, stat]);
+        return {
+            uri,
+            options,
+            ts: now,
+            stat,
+            dictionary,
+            pending,
+            loadingState: LoadingState.Loaded,
+            sig,
+        };
+    }
+    catch (e) {
+        const error = e instanceof Error ? e : new Error((0, util_1.format)(e));
+        const dictionary = (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, error, 'failed to load'));
+        const pending = Promise.resolve([dictionary, stat]);
+        return {
+            uri,
+            options,
+            ts: now,
+            stat,
+            dictionary,
+            pending,
+            loadingState: LoadingState.Loaded,
+            sig,
+        };
+    }
 }
 function determineType(uri, opts) {
     const t = (opts.type && opts.type in loaders && opts.type) || 'S';
     const defLoaderType = t;
-    const defType = uri.endsWith('.trie.gz') ? 'T' : uri.endsWith('.txt.gz') ? defLoaderType : defLoaderType;
+    const defType = uri.endsWith('.trie.gz') ? 'T' : defLoaderType;
     const regTrieTest = /\.trie\b/i;
     return regTrieTest.test(uri) ? 'T' : defType;
 }
@@ -106,8 +221,20 @@ function load(uri, options) {
     const loader = loaders[type] || loaders.default;
     return loader(uri, options);
 }
+function loadSync(uri, options) {
+    const type = determineType(uri, options);
+    const loader = loadersSync[type] || loaders.default;
+    return loader(uri, options);
+}
 async function legacyWordList(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
+    return _legacyWordListSync(lines, filename, options);
+}
+function legacyWordListSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return _legacyWordListSync(lines, filename, options);
+}
+function _legacyWordListSync(lines, filename, options) {
     const words = (0, gensequence_1.genSequence)(lines)
         // Remove comments
         .map((line) => line.replace(/#.*/g, ''))
@@ -118,6 +245,13 @@ async function legacyWordList(filename, options) {
 }
 async function wordsPerLineWordList(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
+    return _wordsPerLineWordList(lines, filename, options);
+}
+function wordsPerLineWordListSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return _wordsPerLineWordList(lines, filename, options);
+}
+function _wordsPerLineWordList(lines, filename, options) {
     const words = (0, gensequence_1.genSequence)(lines)
         // Remove comments
         .map((line) => line.replace(/#.*/g, ''))
@@ -130,10 +264,18 @@ async function loadSimpleWordList(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
     return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, determineName(filename, options), filename, options);
 }
+function loadSimpleWordListSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, determineName(filename, options), filename, options);
+}
 async function loadTrie(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
     return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, determineName(filename, options), filename, options);
 }
+function loadTrieSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, determineName(filename, options), filename, options);
+}
 function determineName(filename, options) {
     return options.name || path.basename(filename);
 }
@@ -143,4 +285,25 @@ exports.testing = {
     loadEntry,
     load,
 };
+function toError(e) {
+    if ((0, errors_1.isErrnoException)(e))
+        return e;
+    if (e instanceof Error)
+        return e;
+    return new Error((0, util_1.format)(e));
+}
+function getStat(uri) {
+    return fs_1.promises.stat(uri).catch((e) => toError(e));
+}
+function getStatSync(uri) {
+    try {
+        return (0, fs_1.statSync)(uri);
+    }
+    catch (e) {
+        return toError(e);
+    }
+}
+exports.__testing__ = {
+    debugLog,
+};
 //# sourceMappingURL=DictionaryLoader.js.map

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -26,7 +26,6 @@ export declare class SpellingDictionaryCollection implements SpellingDictionary
 export declare function createCollection(dictionaries: SpellingDictionary[], name: string): SpellingDictionaryCollection;
 declare function isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptions): SpellingDictionary | undefined;
 declare function isWordForbiddenInAnyDictionary(dicts: SpellingDictionary[], word: string): SpellingDictionary | undefined;
-export declare function createCollectionP(dicts: (Promise<SpellingDictionary> | SpellingDictionary)[], name: string): Promise<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.createCollectionP = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
+exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const gensequence_1 = require("gensequence");
 const Settings_1 = require("../Settings");
@@ -54,23 +54,21 @@ class SpellingDictionaryCollection {
         return this._suggest(word, suggestOptions);
     }
     _suggest(word, suggestOptions) {
-        const _suggestOptions = { ...suggestOptions };
-        const { numSuggestions = (0, Settings_1.getDefaultSettings)().numSuggestions || SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, compoundMethod, ignoreCase, includeTies, timeout, } = suggestOptions;
-        _suggestOptions.compoundMethod = this.options.useCompounds ? SpellingDictionary_1.CompoundWordsMethod.JOIN_WORDS : compoundMethod;
+        const { numSuggestions = (0, Settings_1.getDefaultSettings)().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, {
+        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 }));
     }
@@ -111,10 +109,6 @@ function isNoSuggestWordInAnyDictionary(dicts, word, options) {
 function isWordForbiddenInAnyDictionary(dicts, word) {
     return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isForbidden(word));
 }
-function createCollectionP(dicts, name) {
-    return Promise.all(dicts).then((dicts) => new SpellingDictionaryCollection(dicts, name));
-}
-exports.createCollectionP = createCollectionP;
 exports.__testing__ = {
     isWordInAnyDictionary,
     isWordForbiddenInAnyDictionary,

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -30,5 +30,5 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     getErrors(): Error[];
 }
-export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): Promise<SpellingDictionary>;
+export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
 //# sourceMappingURL=SpellingDictionaryFromTrie.d.ts.map