cspell-lib 5.19.2 → 5.19.3

package/dist/Models/TextDocument.d.ts

@@ -4,6 +4,10 @@ export interface Position {
     line: number;
     character: number;
 }
+/**
+ * Range offset tuple.
+ */
+export declare type SimpleRange = [start: number, end: number];
 export interface TextDocumentLine {
     readonly text: string;
     readonly offset: number;
@@ -48,5 +52,10 @@ export interface CreateTextDocumentParams {
     locale?: string | undefined;
     version?: number | undefined;
 }
+export interface TextDocumentContentChangeEvent {
+    range?: SimpleRange;
+    text: string;
+}
 export declare function createTextDocument({ uri, content, languageId, locale, version, }: CreateTextDocumentParams): TextDocument;
+export declare function updateTextDocument(doc: TextDocument, edits: TextDocumentContentChangeEvent[], version?: number): TextDocument;
 //# sourceMappingURL=TextDocument.d.ts.map

package/dist/Models/TextDocument.js

@@ -22,21 +22,29 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTextDocument = void 0;
+exports.updateTextDocument = exports.createTextDocument = void 0;
 const LanguageIds_1 = require("../LanguageIds");
 const Uri = __importStar(require("./Uri"));
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const assert_1 = __importDefault(require("assert"));
 class TextDocumentImpl {
     constructor(uri, text, languageId, locale, version) {
         this.uri = uri;
-        this.text = text;
         this.languageId = languageId;
         this.locale = locale;
-        this.version = version;
         const primaryLanguageId = typeof languageId === 'string' ? languageId : languageId[0] || 'plaintext';
         this.vsTextDoc = vscode_languageserver_textdocument_1.TextDocument.create(uri.toString(), primaryLanguageId, version, text);
     }
+    get version() {
+        return this.vsTextDoc.version;
+    }
+    get text() {
+        return this.vsTextDoc.getText();
+    }
     positionAt(offset) {
         return this.vsTextDoc.positionAt(offset);
     }
@@ -61,6 +69,26 @@ class TextDocumentImpl {
             position,
         };
     }
+    /**
+     * Apply edits to the text.
+     * Note: the edits are applied one after the other.
+     * @param edits - changes to the text
+     * @param version - optional version to use.
+     * @returns this
+     */
+    update(edits, version) {
+        version = version !== null && version !== void 0 ? version : this.version + 1;
+        for (const edit of edits) {
+            const vsEdit = edit.range
+                ? {
+                    range: { start: this.positionAt(edit.range[0]), end: this.positionAt(edit.range[1]) },
+                    text: edit.text,
+                }
+                : edit;
+            vscode_languageserver_textdocument_1.TextDocument.update(this.vsTextDoc, [vsEdit], version);
+        }
+        return this;
+    }
 }
 function createTextDocument({ uri, content, languageId, locale, version, }) {
     version = version !== null && version !== void 0 ? version : 1;
@@ -70,4 +98,9 @@ function createTextDocument({ uri, content, languageId, locale, version, }) {
     return new TextDocumentImpl(uri, content, languageId, locale, version);
 }
 exports.createTextDocument = createTextDocument;
+function updateTextDocument(doc, edits, version) {
+    (0, assert_1.default)(doc instanceof TextDocumentImpl, 'Unknown TextDocument type');
+    return doc.update(edits, version);
+}
+exports.updateTextDocument = updateTextDocument;
 //# sourceMappingURL=TextDocument.js.map

package/dist/Settings/CSpellSettingsServer.d.ts

@@ -12,7 +12,7 @@ declare function mergeObjects(left: undefined, right: undefined): undefined;
 declare function mergeObjects<T>(left: T, right: undefined): T;
 declare function mergeObjects<T>(left: T, right: T): T;
 declare function mergeObjects<T>(left: undefined, right: T): T;
-export declare function mergeSettings(left: CSpellSettingsWSTO | CSpellSettingsI, ...settings: (CSpellSettingsWSTO | CSpellSettingsI)[]): CSpellSettingsI;
+export declare function mergeSettings(left: CSpellSettingsWSTO | CSpellSettingsI, ...settings: (CSpellSettingsWSTO | CSpellSettingsI | undefined)[]): CSpellSettingsI;
 export declare function mergeInDocSettings(left: CSpellSettingsWSTO, right: CSpellSettingsWSTO): CSpellSettingsWST;
 export declare function calcOverrideSettings(settings: CSpellSettingsWSTO, filename: string): CSpellSettingsI;
 /**

package/dist/Settings/CSpellSettingsServer.js

@@ -34,13 +34,19 @@ exports.configSettingsFileVersion0_1 = '0.1';
 exports.configSettingsFileVersion0_2 = '0.2';
 exports.currentSettingsFileVersion = exports.configSettingsFileVersion0_2;
 exports.ENV_CSPELL_GLOB_ROOT = 'CSPELL_GLOB_ROOT';
+function _unique(a) {
+    return [...new Set(a)];
+}
 function mergeListUnique(left, right) {
     if (left === undefined)
         return right;
     if (right === undefined)
         return left;
-    const uniqueItems = new Set([...left, ...right]);
-    return [...uniqueItems.keys()];
+    if (!right.length)
+        return left;
+    if (!left.length)
+        return right;
+    return _unique([...left, ...right]);
 }
 function mergeList(left, right) {
     if (left === undefined)
@@ -73,12 +79,6 @@ function mergeObjects(left, right) {
         return left;
     return { ...left, ...right };
 }
-function tagLanguageSettings(tag, settings = []) {
-    return settings.map((s) => ({
-        id: tag + '.' + (s.id || s.locale || s.languageId),
-        ...s,
-    }));
-}
 function replaceIfNotEmpty(left = [], right = []) {
     const filtered = right.filter((a) => !!a);
     if (filtered.length) {
@@ -87,7 +87,7 @@ function replaceIfNotEmpty(left = [], right = []) {
     return left;
 }
 function mergeSettings(left, ...settings) {
-    const rawSettings = settings.reduce(merge, toInternalSettings(left));
+    const rawSettings = settings.filter((a) => !!a).reduce(merge, toInternalSettings(left));
     return util.clean(rawSettings);
 }
 exports.mergeSettings = mergeSettings;
@@ -136,7 +136,7 @@ function merge(left, right) {
         dictionaryDefinitions: mergeListUnique(_left.dictionaryDefinitions, _right.dictionaryDefinitions),
         dictionaries: mergeListUnique(_left.dictionaries, _right.dictionaries),
         noSuggestDictionaries: mergeListUnique(_left.noSuggestDictionaries, _right.noSuggestDictionaries),
-        languageSettings: mergeList(tagLanguageSettings(leftId, _left.languageSettings), tagLanguageSettings(rightId, _right.languageSettings)),
+        languageSettings: mergeList(_left.languageSettings, _right.languageSettings),
         enabled: _right.enabled !== undefined ? _right.enabled : _left.enabled,
         files: mergeListUnique(_left.files, _right.files),
         ignorePaths: versionBasedMergeList(_left.ignorePaths, _right.ignorePaths, version),

package/dist/Settings/DictionarySettings.d.ts

@@ -1,5 +1,6 @@
-import type { DictionaryDefinition, DictionaryReference } from '@cspell/cspell-types';
+import type { DictionaryDefinition } from '@cspell/cspell-types';
 import { CSpellSettingsInternal, DictionaryDefinitionInternal, DictionaryDefinitionInternalWithSource } from '../Models/CSpellSettingsInternalDef';
+import { DictionaryReferenceCollection } from './DictionaryReferenceCollection';
 export declare type DefMapArrayItem = [string, DictionaryDefinitionInternal];
 /**
  * Combines the list of desired dictionaries with the list of dictionary
@@ -9,15 +10,16 @@ export declare type DefMapArrayItem = [string, DictionaryDefinitionInternal];
  * - Adding `!` to a dictId will remove the dictionary.
  * - Adding `!!` will add it back.
  *
- * @param dictIds - dictionaries desired
+ * @param dictRefCol - dictionaries desired
  * @param defs - dictionary definitions
  * @returns map from dictIds to definitions
  */
-export declare function filterDictDefsToLoad(dictRefIds: DictionaryReference[], defs: DictionaryDefinitionInternal[]): DictionaryDefinitionInternal[];
+export declare function filterDictDefsToLoad(dictRefCol: DictionaryReferenceCollection, defs: DictionaryDefinitionInternal[]): DictionaryDefinitionInternal[];
 export declare function mapDictDefsToInternal(defs: undefined, pathToSettingsFile: string): undefined;
 export declare function mapDictDefsToInternal(defs: DictionaryDefinition[], pathToSettingsFile: string): DictionaryDefinitionInternalWithSource[];
 export declare function mapDictDefsToInternal(defs: DictionaryDefinition[] | undefined, pathToSettingsFile: string): DictionaryDefinitionInternalWithSource[] | undefined;
 export declare function mapDictDefToInternal(def: DictionaryDefinition, pathToSettingsFile: string): DictionaryDefinitionInternalWithSource;
 export declare function isDictionaryDefinitionWithSource(d: DictionaryDefinition | DictionaryDefinitionInternalWithSource): d is DictionaryDefinitionInternalWithSource;
 export declare function calcDictionaryDefsToLoad(settings: CSpellSettingsInternal): DictionaryDefinitionInternal[];
+export declare function isDictionaryDefinitionInternal(def: DictionaryDefinition | DictionaryDefinitionInternal): def is DictionaryDefinitionInternal;
 //# sourceMappingURL=DictionarySettings.d.ts.map

package/dist/Settings/DictionarySettings.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcDictionaryDefsToLoad = exports.isDictionaryDefinitionWithSource = exports.mapDictDefToInternal = exports.mapDictDefsToInternal = exports.filterDictDefsToLoad = void 0;
+exports.isDictionaryDefinitionInternal = exports.calcDictionaryDefsToLoad = exports.isDictionaryDefinitionWithSource = exports.mapDictDefToInternal = exports.mapDictDefsToInternal = exports.filterDictDefsToLoad = void 0;
 const path = __importStar(require("path"));
 const resolveFile_1 = require("../util/resolveFile");
 const DictionaryReferenceCollection_1 = require("./DictionaryReferenceCollection");
@@ -37,30 +37,26 @@ const util_1 = require("../util/util");
  * - Adding `!` to a dictId will remove the dictionary.
  * - Adding `!!` will add it back.
  *
- * @param dictIds - dictionaries desired
+ * @param dictRefCol - dictionaries desired
  * @param defs - dictionary definitions
  * @returns map from dictIds to definitions
  */
-function filterDictDefsToLoad(dictRefIds, defs) {
-    function isDefP(def) {
-        return !!def.path;
-    }
-    const col = (0, DictionaryReferenceCollection_1.createDictionaryReferenceCollection)(dictRefIds);
-    const dictIdSet = new Set(col.enabled());
-    const allActiveDefs = defs
-        .filter(({ name }) => dictIdSet.has(name))
-        .map((def) => ({ ...def, path: getFullPathName(def) }))
-        // Remove any empty paths.
-        .filter(isDefP);
+function filterDictDefsToLoad(dictRefCol, defs) {
+    const allActiveDefs = defs.filter(({ name }) => dictRefCol.isEnabled(name)).map(fixPath);
     return [...new Map(allActiveDefs.map((d) => [d.name, d])).values()];
 }
 exports.filterDictDefsToLoad = filterDictDefsToLoad;
-function getFullPathName(def) {
-    const { path: filePath = '', file = '' } = def;
-    if (!filePath && !file) {
-        return '';
+function fixPath(def) {
+    if (def instanceof _DictionaryDefinitionInternalWithSource) {
+        return def;
     }
-    return path.join(filePath, file);
+    const { path: filePath = '', file = '' } = def;
+    const newPath = !filePath && !file ? '' : path.join(filePath, file);
+    return {
+        ...def,
+        file: undefined,
+        path: newPath,
+    };
 }
 function mapDictDefsToInternal(defs, pathToSettingsFile) {
     return defs === null || defs === void 0 ? void 0 : defs.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
@@ -93,9 +89,13 @@ function calcDictionaryDefsToLoad(settings) {
             return def;
         return { ...def, noSuggest: enabled };
     });
-    return filterDictDefsToLoad(colDicts.enabled(), modDefs);
+    return filterDictDefsToLoad(colDicts, modDefs);
 }
 exports.calcDictionaryDefsToLoad = calcDictionaryDefsToLoad;
+function isDictionaryDefinitionInternal(def) {
+    return def instanceof _DictionaryDefinitionInternalWithSource;
+}
+exports.isDictionaryDefinitionInternal = isDictionaryDefinitionInternal;
 class _DictionaryDefinitionInternalWithSource {
     constructor(def, __source) {
         this.__source = __source;

package/dist/Settings/LanguageSettings.d.ts

@@ -1,10 +1,10 @@
-import type { LanguageSetting, CSpellUserSettings, LocaleId, LanguageId, BaseSetting } from '@cspell/cspell-types';
+import type { BaseSetting, CSpellUserSettings, LanguageId, LanguageSetting, LocaleId } from '@cspell/cspell-types';
 export declare type LanguageSettings = LanguageSetting[];
 export declare function getDefaultLanguageSettings(): LanguageSettings;
 export declare function normalizeLanguageId(langId: LanguageId | LanguageId[]): Set<LanguageId>;
 export declare function normalizeLocale(locale: LocaleId | LocaleId[]): Set<LocaleId>;
 export declare function isLocaleInSet(locale: LocaleId | LocaleId[], setOfLocals: Set<LocaleId>): boolean;
-export declare function calcSettingsForLanguage(languageSettings: LanguageSettings, languageId: LanguageId, locale: LocaleId | LocaleId[]): BaseSetting;
+export declare function calcSettingsForLanguage(languageSettings: LanguageSettings, languageId: LanguageId, locale: LocaleId): BaseSetting;
 export declare function calcUserSettingsForLanguage(settings: CSpellUserSettings, languageId: string): CSpellUserSettings;
 export declare function calcSettingsForLanguageId(baseSettings: CSpellUserSettings, languageId: LanguageId[] | LanguageId): CSpellUserSettings;
 //# sourceMappingURL=LanguageSettings.d.ts.map

package/dist/Settings/LanguageSettings.js

@@ -24,6 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calcSettingsForLanguageId = exports.calcUserSettingsForLanguage = exports.calcSettingsForLanguage = exports.isLocaleInSet = exports.normalizeLocale = exports.normalizeLanguageId = exports.getDefaultLanguageSettings = void 0;
+const Memorizer_1 = require("../util/Memorizer");
+const util_1 = require("../util/util");
 const SpellSettings = __importStar(require("./CSpellSettingsServer"));
 const defaultLocale = 'en';
 const defaultLanguageSettings = [];
@@ -32,58 +34,69 @@ function getDefaultLanguageSettings() {
 }
 exports.getDefaultLanguageSettings = getDefaultLanguageSettings;
 function localesToList(locales) {
-    locales = typeof locales !== 'string' ? locales.join(',') : locales;
     return stringToList(locales.replace(/\s+/g, ','));
 }
 function stringToList(sList) {
-    if (typeof sList !== 'string') {
-        sList = sList.join(',');
-    }
-    sList = sList
+    return sList
         .replace(/[|;]/g, ',')
         .split(',')
         .map((s) => s.trim())
         .filter((s) => !!s);
-    return sList;
 }
-function normalizeLanguageId(langId) {
+const _normalizeLanguageId = (0, Memorizer_1.memorizerAll)(__normalizeLanguageId);
+function __normalizeLanguageId(langId) {
     const langIds = stringToList(langId);
     return new Set(langIds.map((a) => a.toLowerCase()));
 }
+function normalizeLanguageId(langId) {
+    return _normalizeLanguageId(typeof langId === 'string' ? langId : langId.join(','));
+}
 exports.normalizeLanguageId = normalizeLanguageId;
-function normalizeLanguageIdToString(langId) {
-    return [...normalizeLanguageId(langId)].join(',');
+const _normalizeLocale = (0, Memorizer_1.memorizerAll)(__normalizeLocale);
+function __normalizeLocale(locale) {
+    const locales = localesToList(locale);
+    return new Set(locales.map((locale) => locale.toLowerCase().replace(/[^a-z]/g, '')));
 }
 function normalizeLocale(locale) {
-    locale = localesToList(locale);
-    return new Set(locale.map((locale) => locale.toLowerCase().replace(/[^a-z]/g, '')));
+    locale = typeof locale === 'string' ? locale : locale.join(',');
+    return _normalizeLocale(locale);
 }
 exports.normalizeLocale = normalizeLocale;
 function isLocaleInSet(locale, setOfLocals) {
     const locales = normalizeLocale(locale);
-    return [...locales.values()].filter((locale) => setOfLocals.has(locale)).length > 0;
+    return (0, util_1.doSetsIntersect)(locales, setOfLocals);
 }
 exports.isLocaleInSet = isLocaleInSet;
 function calcSettingsForLanguage(languageSettings, languageId, locale) {
     languageId = languageId.toLowerCase();
     const allowedLocals = normalizeLocale(locale);
-    return defaultLanguageSettings
-        .concat(languageSettings)
+    const ls = languageSettings
         .filter((s) => doesLanguageSettingMatchLanguageId(s, languageId))
         .filter((s) => !s.locale || s.locale === '*' || isLocaleInSet(s.locale, allowedLocals))
         .map((langSetting) => {
-        const id = normalizeLanguageIdToString(langSetting.locale || langSetting.languageId || 'language');
-        const { languageId: _languageId, locale: _local, ...s } = { id, ...langSetting };
+        const { languageId: _languageId, locale: _locale, ...s } = langSetting;
         return s;
     })
-        .reduce((langSetting, setting) => ({
-        ...SpellSettings.mergeSettings(langSetting, setting),
-        languageId,
-        locale,
-    }), {});
+        .reduce((langSetting, setting) => SpellSettings.mergeSettings(langSetting, setting), {});
+    ls.languageId = languageId;
+    ls.locale = locale;
+    return ls;
 }
 exports.calcSettingsForLanguage = calcSettingsForLanguage;
+const cacheDoesLanguageSettingMatchLanguageId = new WeakMap();
 function doesLanguageSettingMatchLanguageId(s, languageId) {
+    var _a;
+    const r = (_a = cacheDoesLanguageSettingMatchLanguageId.get(s)) !== null && _a !== void 0 ? _a : new Map();
+    const f = r.get(languageId);
+    if (f !== undefined) {
+        return f;
+    }
+    const v = _doesLanguageSettingMatchLanguageId(s, languageId);
+    r.set(languageId, v);
+    cacheDoesLanguageSettingMatchLanguageId.set(s, r);
+    return v;
+}
+function _doesLanguageSettingMatchLanguageId(s, languageId) {
     const languageSettingsLanguageIds = s.languageId;
     if (!languageSettingsLanguageIds || languageSettingsLanguageIds === '*')
         return true;
@@ -96,13 +109,10 @@ function doesLanguageSettingMatchLanguageId(s, languageId) {
     return numExcludes === ids.size;
 }
 function calcUserSettingsForLanguage(settings, languageId) {
-    const { languageSettings = [], language: locale = defaultLocale } = settings;
-    const defaults = {
-        allowCompoundWords: settings.allowCompoundWords,
-        enabled: settings.enabled,
-    };
+    const { languageSettings = [], language: locale = defaultLocale, allowCompoundWords, enabled } = settings;
     const langSettings = {
-        ...defaults,
+        allowCompoundWords,
+        enabled,
         ...calcSettingsForLanguage(languageSettings, languageId, locale),
     };
     return SpellSettings.mergeSettings(settings, langSettings);

package/dist/SpellingDictionary/Dictionaries.js

@@ -7,11 +7,11 @@ const createSpellingDictionary_1 = require("./createSpellingDictionary");
 const DictionaryLoader_1 = require("./DictionaryLoader");
 const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
 function loadDictionaryDefs(defsToLoad) {
-    return defsToLoad.map((def) => (0, DictionaryLoader_1.loadDictionary)(def.path, def));
+    return defsToLoad.map(DictionaryLoader_1.loadDictionary);
 }
 exports.loadDictionaryDefs = loadDictionaryDefs;
 function loadDictionaryDefsSync(defsToLoad) {
-    return defsToLoad.map((def) => (0, DictionaryLoader_1.loadDictionarySync)(def.path, def));
+    return defsToLoad.map(DictionaryLoader_1.loadDictionarySync);
 }
 exports.loadDictionaryDefsSync = loadDictionaryDefsSync;
 function refreshDictionaryCache(maxAge) {

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -32,8 +32,8 @@ export interface SyncLoaders {
     W: LoaderSync;
     default: LoaderSync;
 }
-export declare function loadDictionary(uri: string, options: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
-export declare function loadDictionarySync(uri: string, options: DictionaryDefinitionInternal): SpellingDictionary;
+export declare function loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
+export declare function loadDictionarySync(def: 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.

package/dist/SpellingDictionary/DictionaryLoader.js

@@ -59,49 +59,50 @@ function __log(msg) {
     debugMode && debugLog.push(msg);
 }
 const dictionaryCache = new Map();
-function loadDictionary(uri, options) {
-    const key = calcKey(uri, options);
+const dictionaryCacheByDef = new Map();
+function getCacheEntry(def) {
+    const defEntry = dictionaryCacheByDef.get(def);
+    if (defEntry) {
+        return defEntry;
+    }
+    const key = calcKey(def);
     const entry = dictionaryCache.get(key);
+    if (entry) {
+        // replace old entry so it can be released.
+        entry.options = def;
+    }
+    return { key, entry };
+}
+function setCacheEntry(key, entry, def) {
+    dictionaryCache.set(key, entry);
+    dictionaryCacheByDef.set(def, { key, entry });
+}
+function loadDictionary(def) {
+    const { key, entry } = getCacheEntry(def);
     if (entry) {
         return entry.pending.then(([dictionary]) => dictionary);
     }
-    const loadedEntry = loadEntry(uri, options);
-    dictionaryCache.set(key, loadedEntry);
+    const loadedEntry = loadEntry(def.path, def);
+    setCacheEntry(key, loadedEntry, def);
     return loadedEntry.pending.then(([dictionary]) => dictionary);
 }
 exports.loadDictionary = loadDictionary;
-function loadDictionarySync(uri, options) {
-    const key = calcKey(uri, options);
-    const entry = dictionaryCache.get(key);
+function loadDictionarySync(def) {
+    const { key, entry } = getCacheEntry(def);
     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);
+    const loadedEntry = loadEntrySync(def.path, def);
+    setCacheEntry(key, loadedEntry, def);
     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()) || ''; });
-    const parts = [uri, loaderType].concat(optValues);
+function calcKey(def) {
+    const path = def.path;
+    const loaderType = determineType(path, def);
+    const optValues = importantOptionKeys.map((k) => { var _a; return ((_a = def[k]) === null || _a === void 0 ? void 0 : _a.toString()) || ''; });
+    const parts = [path, loaderType].concat(optValues);
     return parts.join('|');
 }
 /**
@@ -136,7 +137,10 @@ async function refreshEntry(entry, maxAge, now) {
         // }
         if (sigMatches && hasChanged) {
             entry.loadingState = LoadingState.Loading;
-            dictionaryCache.set(calcKey(entry.uri, entry.options), loadEntry(entry.uri, entry.options));
+            const key = calcKey(entry.options);
+            const newEntry = loadEntry(entry.uri, entry.options);
+            dictionaryCache.set(key, newEntry);
+            dictionaryCacheByDef.set(entry.options, { key, entry: newEntry });
         }
     }
 }

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export * from '@cspell/cspell-types';
 export * from 'cspell-io';
 export { ExcludeFilesGlobMap, ExclusionFunction } from './exclusionHelper';
 export { getLanguagesForExt } from './LanguageIds';
-export { createTextDocument } from './Models/TextDocument';
+export { createTextDocument, updateTextDocument } from './Models/TextDocument';
 export type { CreateTextDocumentParams, TextDocument, TextDocumentLine } from './Models/TextDocument';
 export * from './Settings';
 export { defaultFileName as defaultSettingsFilename } from './Settings';

package/dist/index.js

@@ -26,7 +26,7 @@ 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.getDictionary = exports.clearCachedFiles = exports.ExclusionHelper = exports.Link = exports.Text = exports.validateText = exports.IncludeExcludeFlag = exports.checkText = exports.resolveFile = exports.setLogger = exports.getLogger = exports.traceWordsAsync = exports.traceWords = exports.DocumentValidator = exports.suggestionsForWords = exports.suggestionsForWord = exports.SuggestionError = exports.SpellingDictionaryLoadError = exports.SpellingDictionaryCollection = exports.refreshDictionaryCache = exports.isSpellingDictionaryLoadError = exports.createSpellingDictionary = exports.CompoundWordsMethod = exports.spellCheckFile = exports.spellCheckDocument = exports.isBinaryFile = exports.fileToDocument = exports.determineFinalDocumentSettings = exports.constructSettingsForText = exports.combineTextAndLanguageSettings = exports.defaultSettingsFilename = exports.createTextDocument = exports.getLanguagesForExt = void 0;
+exports.getDictionary = exports.clearCachedFiles = exports.ExclusionHelper = exports.Link = exports.Text = exports.validateText = exports.IncludeExcludeFlag = exports.checkText = exports.resolveFile = exports.setLogger = exports.getLogger = exports.traceWordsAsync = exports.traceWords = exports.DocumentValidator = exports.suggestionsForWords = exports.suggestionsForWord = exports.SuggestionError = exports.SpellingDictionaryLoadError = exports.SpellingDictionaryCollection = exports.refreshDictionaryCache = exports.isSpellingDictionaryLoadError = exports.createSpellingDictionary = exports.CompoundWordsMethod = exports.spellCheckFile = exports.spellCheckDocument = exports.isBinaryFile = exports.fileToDocument = exports.determineFinalDocumentSettings = exports.constructSettingsForText = exports.combineTextAndLanguageSettings = exports.defaultSettingsFilename = exports.updateTextDocument = exports.createTextDocument = exports.getLanguagesForExt = void 0;
 const ExclusionHelper = __importStar(require("./exclusionHelper"));
 exports.ExclusionHelper = ExclusionHelper;
 const Settings_1 = require("./Settings");
@@ -42,6 +42,7 @@ var LanguageIds_1 = require("./LanguageIds");
 Object.defineProperty(exports, "getLanguagesForExt", { enumerable: true, get: function () { return LanguageIds_1.getLanguagesForExt; } });
 var TextDocument_1 = require("./Models/TextDocument");
 Object.defineProperty(exports, "createTextDocument", { enumerable: true, get: function () { return TextDocument_1.createTextDocument; } });
+Object.defineProperty(exports, "updateTextDocument", { enumerable: true, get: function () { return TextDocument_1.updateTextDocument; } });
 __exportStar(require("./Settings"), exports);
 var Settings_2 = require("./Settings");
 Object.defineProperty(exports, "defaultSettingsFilename", { enumerable: true, get: function () { return Settings_2.defaultFileName; } });

package/dist/textValidation/docValidator.d.ts

@@ -26,6 +26,7 @@ export declare class DocumentValidator {
     private _prepared;
     private _preparations;
     private _preparationTime;
+    private _suggestions;
     /**
      * @param doc - Document to validate
      * @param config - configuration to use (not finalized).
@@ -35,15 +36,19 @@ export declare class DocumentValidator {
     prepareSync(): void;
     prepare(): Promise<void>;
     private _prepareAsync;
+    private _updatePrep;
     /**
      * The amount of time in ms to prepare for validation.
      */
     get prepTime(): number;
     checkText(range: SimpleRange, _text: string, _scope: string[]): ValidationIssue[];
     get document(): TextDocument;
+    updateDocumentText(text: string): void;
     private addPossibleError;
     private catchError;
     private errorCatcherWrapper;
+    private suggest;
+    private genSuggestions;
 }
 export declare type Offset = number;
 export declare type SimpleRange = readonly [Offset, Offset];

package/dist/textValidation/docValidator.js

@@ -6,10 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentValidator = void 0;
 const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const assert_1 = __importDefault(require("assert"));
+const TextDocument_1 = require("../Models/TextDocument");
 const Settings_1 = require("../Settings");
 const configLoader_1 = require("../Settings/configLoader");
 const SpellingDictionary_1 = require("../SpellingDictionary");
 const errors_1 = require("../util/errors");
+const Memorizer_1 = require("../util/Memorizer");
+const simpleCache_1 = require("../util/simpleCache");
 const timer_1 = require("../util/timer");
 const util_1 = require("../util/util");
 const determineTextDocumentSettings_1 = require("./determineTextDocumentSettings");
@@ -26,6 +29,7 @@ class DocumentValidator {
         this._ready = false;
         this.errors = [];
         this._preparationTime = -1;
+        this._suggestions = new simpleCache_1.AutoCache((text) => this.genSuggestions(text), 1000);
         this._document = doc;
         // console.error(`DocumentValidator: ${doc.uri}`);
     }
@@ -50,7 +54,7 @@ class DocumentValidator {
                 ? this.errorCatcherWrapper(() => searchForDocumentConfigSync(this._document, settings, settings))
                 : undefined;
         this.addPossibleError((_a = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _a === void 0 ? void 0 : _a.error);
-        const config = localConfig ? (0, Settings_1.mergeSettings)(settings, localConfig) : settings;
+        const config = (0, Settings_1.mergeSettings)(settings, localConfig);
         const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, config);
         const dict = (0, SpellingDictionary_1.getDictionaryInternalSync)(docSettings);
         const shouldCheck = (_b = docSettings.enabled) !== null && _b !== void 0 ? _b : true;
@@ -60,6 +64,7 @@ class DocumentValidator {
         const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
         const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
         this._preparations = {
+            config,
             dictionary: dict,
             docSettings,
             shouldCheck,
@@ -70,6 +75,7 @@ class DocumentValidator {
         };
         this._ready = true;
         this._preparationTime = timer.elapsed();
+        // console.error(`prepareSync ${this._preparationTime.toFixed(2)}ms`);
     }
     async prepare() {
         if (this._ready)
@@ -90,9 +96,9 @@ class DocumentValidator {
             : useSearchForConfig
                 ? this.catchError(searchForDocumentConfig(this._document, settings, settings))
                 : undefined;
-        const localConfig = await pLocalConfig;
+        const localConfig = (await pLocalConfig) || {};
         this.addPossibleError((_a = localConfig === null || localConfig === void 0 ? void 0 : localConfig.__importRef) === null || _a === void 0 ? void 0 : _a.error);
-        const config = localConfig ? (0, Settings_1.mergeSettings)(settings, localConfig) : settings;
+        const config = (0, Settings_1.mergeSettings)(settings, localConfig);
         const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, config);
         const dict = await (0, SpellingDictionary_1.getDictionaryInternal)(docSettings);
         const shouldCheck = (_b = docSettings.enabled) !== null && _b !== void 0 ? _b : true;
@@ -102,6 +108,7 @@ class DocumentValidator {
         const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
         const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
         this._preparations = {
+            config,
             dictionary: dict,
             docSettings,
             shouldCheck,
@@ -113,6 +120,31 @@ class DocumentValidator {
         this._ready = true;
         this._preparationTime = timer.elapsed();
     }
+    _updatePrep() {
+        var _a;
+        (0, assert_1.default)(this._preparations);
+        const timer = (0, timer_1.createTimer)();
+        const { config } = this._preparations;
+        const docSettings = (0, determineTextDocumentSettings_1.determineTextDocumentSettings)(this._document, config);
+        const dict = (0, SpellingDictionary_1.getDictionaryInternalSync)(docSettings);
+        const shouldCheck = (_a = docSettings.enabled) !== null && _a !== void 0 ? _a : true;
+        const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
+        const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
+        const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
+        const segmenter = (0, textValidator_1.mapLineSegmentAgainstRangesFactory)(includeRanges);
+        const lineValidator = (0, textValidator_1.lineValidatorFactory)(dict, validateOptions);
+        this._preparations = {
+            config,
+            dictionary: dict,
+            docSettings,
+            shouldCheck,
+            validateOptions,
+            includeRanges,
+            segmenter,
+            lineValidator,
+        };
+        this._preparationTime = timer.elapsed();
+    }
     /**
      * The amount of time in ms to prepare for validation.
      */
@@ -120,7 +152,6 @@ class DocumentValidator {
         return this._preparationTime;
     }
     checkText(range, _text, _scope) {
-        var _a;
         (0, assert_1.default)(this._ready);
         (0, assert_1.default)(this._preparations);
         const { segmenter, lineValidator } = this._preparations;
@@ -143,25 +174,21 @@ class DocumentValidator {
         if (!this.options.generateSuggestions) {
             return issues;
         }
-        const settings = this._preparations.docSettings;
-        const dict = this._preparations.dictionary;
-        const sugOptions = (0, util_1.clean)({
-            compoundMethod: 0,
-            numSuggestions: this.options.numSuggestions,
-            includeTies: false,
-            ignoreCase: !((_a = settings.caseSensitive) !== null && _a !== void 0 ? _a : false),
-            timeout: settings.suggestionsTimeout,
-            numChanges: settings.suggestionNumChanges,
-        });
         const withSugs = issues.map((t) => {
-            const suggestions = dict.suggest(t.text, sugOptions).map((r) => r.word);
-            return { ...t, suggestions };
+            // lazy suggestion calculation.
+            const text = t.text;
+            const suggestions = (0, Memorizer_1.callOnce)(() => this.suggest(text));
+            return Object.defineProperty({ ...t }, 'suggestions', { enumerable: true, get: suggestions });
         });
         return withSugs;
     }
     get document() {
         return this._document;
     }
+    updateDocumentText(text) {
+        (0, TextDocument_1.updateTextDocument)(this._document, [{ text }]);
+        this._updatePrep();
+    }
     addPossibleError(error) {
         if (!error)
             return;
@@ -182,6 +209,24 @@ class DocumentValidator {
         }
         return undefined;
     }
+    suggest(text) {
+        return this._suggestions.get(text);
+    }
+    genSuggestions(text) {
+        var _a;
+        (0, assert_1.default)(this._preparations);
+        const settings = this._preparations.docSettings;
+        const dict = this._preparations.dictionary;
+        const sugOptions = (0, util_1.clean)({
+            compoundMethod: 0,
+            numSuggestions: this.options.numSuggestions,
+            includeTies: false,
+            ignoreCase: !((_a = settings.caseSensitive) !== null && _a !== void 0 ? _a : false),
+            timeout: settings.suggestionsTimeout,
+            numChanges: settings.suggestionNumChanges,
+        });
+        return dict.suggest(text, sugOptions).map((r) => r.word);
+    }
 }
 exports.DocumentValidator = DocumentValidator;
 async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {

package/dist/textValidation/validator.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkText = exports.IncludeExcludeFlag = exports.settingsToValidateOptions = exports.validateText = exports.diagSource = void 0;
 const Settings = __importStar(require("../Settings"));
 const SpellingDictionary_1 = require("../SpellingDictionary");
+const Memorizer_1 = require("../util/Memorizer");
 const util_1 = require("../util/util");
 const textValidator_1 = require("./textValidator");
 exports.diagSource = 'cSpell Checker';
@@ -46,8 +47,10 @@ async function validateText(text, settings, options = {}) {
         numChanges: settings.suggestionNumChanges,
     });
     const withSugs = issues.map((t) => {
-        const suggestions = dict.suggest(t.text, sugOptions).map((r) => r.word);
-        return { ...t, suggestions };
+        const text = t.text;
+        // lazy suggestion calculation.
+        const suggestions = (0, Memorizer_1.callOnce)(() => dict.suggest(text, sugOptions).map((r) => r.word));
+        return Object.defineProperty({ ...t }, 'suggestions', { enumerable: true, get: suggestions });
     });
     return withSugs;
 }

package/dist/trace.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.traceWordsAsync = exports.traceWords = void 0;
 const gensequence_1 = require("gensequence");
 const Settings_1 = require("./Settings");
+const CSpellSettingsServer_1 = require("./Settings/CSpellSettingsServer");
 const LanguageSettings_1 = require("./Settings/LanguageSettings");
 const SpellingDictionary_1 = require("./SpellingDictionary");
 const util = __importStar(require("./util/util"));
@@ -50,7 +51,7 @@ async function* traceWordsAsync(words, settings, options) {
         const dictionaries = (settings.dictionaries || [])
             .concat((settings.dictionaryDefinitions || []).map((d) => d.name))
             .filter(util.uniqueFn);
-        const dictSettings = { ...settings, dictionaries };
+        const dictSettings = (0, CSpellSettingsServer_1.toInternalSettings)({ ...settings, dictionaries });
         const dictBase = await (0, SpellingDictionary_1.getDictionaryInternal)(settings);
         const dicts = await (0, SpellingDictionary_1.getDictionaryInternal)(dictSettings);
         const activeDictionaries = dictBase.dictionaries.map((d) => d.name);

package/dist/util/Memorizer.d.ts

@@ -41,10 +41,18 @@ export declare function memorizerKeyBy<F extends (...args: any[]) => any, Args e
  * @param fn - function to memorize
  * @returns a new function.
  */
+export declare function memorizeLastCall<T>(fn: (...p: []) => T): (...p: []) => T;
 export declare function memorizeLastCall<T, K0>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
 export declare function memorizeLastCall<T, K0, K1>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
 export declare function memorizeLastCall<T, K0, K1, K2>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
 export declare function memorizeLastCall<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
 export declare function memorizeLastCall<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
+/**
+ * calls a function exactly once and always returns the same value.
+ * @param fn - function to call
+ * @returns a new function
+ */
+export declare function callOnce<T>(fn: () => T): () => T;
+export declare function memorizerAll<K extends any[], T>(fn: (...p: K) => T): (...p: K) => T;
 export {};
 //# sourceMappingURL=Memorizer.d.ts.map

package/dist/util/Memorizer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.memorizeLastCall = exports.memorizerKeyBy = exports.memorizer = void 0;
+exports.memorizerAll = exports.callOnce = exports.memorizeLastCall = exports.memorizerKeyBy = exports.memorizer = void 0;
 const util_1 = require("./util");
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const defaultSize = 50000;
@@ -73,4 +73,62 @@ function memorizeLastCall(fn) {
     };
 }
 exports.memorizeLastCall = memorizeLastCall;
+/**
+ * calls a function exactly once and always returns the same value.
+ * @param fn - function to call
+ * @returns a new function
+ */
+function callOnce(fn) {
+    let last;
+    return () => {
+        if (last) {
+            return last.value;
+        }
+        last = {
+            value: fn(),
+        };
+        return last.value;
+    };
+}
+exports.callOnce = callOnce;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function memorizerAll(fn) {
+    const r = {};
+    function find(p) {
+        var _a;
+        let n = r;
+        for (const k of p) {
+            if (!n)
+                break;
+            n = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(k);
+        }
+        return n;
+    }
+    function set(p, v) {
+        var _a;
+        let n = r;
+        for (const k of p) {
+            const c = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(k);
+            if (c) {
+                n = c;
+                continue;
+            }
+            const r = {};
+            n.c = n.c || new Map();
+            n.c.set(k, r);
+            n = r;
+        }
+        n.v = v;
+    }
+    return (...p) => {
+        const f = find(p);
+        if (f && 'v' in f) {
+            return f.v;
+        }
+        const v = fn(...p);
+        set(p, v);
+        return v;
+    };
+}
+exports.memorizerAll = memorizerAll;
 //# sourceMappingURL=Memorizer.js.map

package/dist/util/debugPerf.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Measure and log result.
+ * @param fn - function to measure.
+ * @param message - message to log
+ * @param callback - called when the function has finished.
+ * @returns a function
+ */
+export declare function perfFn<P extends any[], R>(fn: (...args: P) => R, message: string, callback?: (m: string, elapsedMs: number) => void): (...args: P) => R;
+//# sourceMappingURL=debugPerf.d.ts.map

package/dist/util/debugPerf.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perfFn = void 0;
+const timer_1 = require("./timer");
+/**
+ * Measure and log result.
+ * @param fn - function to measure.
+ * @param message - message to log
+ * @param callback - called when the function has finished.
+ * @returns a function
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function perfFn(fn, message, callback = (message, time) => console.error(`${message}: ${time.toFixed(2)}ms`)) {
+    return (...args) => {
+        const timer = (0, timer_1.createTimer)();
+        const r = fn(...args);
+        callback(message, timer.elapsed());
+        return r;
+    };
+}
+exports.perfFn = perfFn;
+//# sourceMappingURL=debugPerf.js.map

package/dist/util/simpleCache.d.ts

@@ -7,7 +7,8 @@ export declare class SimpleWeakCache<K extends object, T> {
     constructor(size: number);
     has(key: K): boolean;
     get(key: K): T | undefined;
-    set(key: K, value: T): this | undefined;
+    set(key: K, value: T): void;
+    private _set;
     private caches;
     private rotate;
 }
@@ -32,7 +33,8 @@ export declare class SimpleCache<K, T> {
     constructor(size: number);
     has(key: K): boolean;
     get(key: K): T | undefined;
-    set(key: K, value: T): this | undefined;
+    set(key: K, value: T): void;
+    private _set;
     private caches;
     private rotate;
 }

package/dist/util/simpleCache.js

@@ -18,27 +18,29 @@ class SimpleWeakCache {
     }
     get(key) {
         for (const c of this.caches()) {
-            if (c.has(key)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const v = c.get(key);
+            const entry = c.get(key);
+            if (entry) {
                 if (c !== this.L0) {
-                    this.set(key, v);
+                    this._set(key, entry);
                 }
-                return v;
+                return entry.v;
             }
         }
         return undefined;
     }
     set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
         if (this.L0.has(key)) {
-            this.L0.set(key, value);
+            this.L0.set(key, entry);
             return this;
         }
         if (this.sizeL0 >= this.size) {
             this.rotate();
         }
         this.sizeL0 += 1;
-        this.L0.set(key, value);
+        this.L0.set(key, entry);
     }
     caches() {
         return [this.L0, this.L1, this.L2];
@@ -90,32 +92,33 @@ class SimpleCache {
     }
     get(key) {
         for (const c of this.caches()) {
-            if (c.has(key)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const v = c.get(key);
+            const entry = c.get(key);
+            if (entry) {
                 if (c !== this.L0) {
-                    this.set(key, v);
+                    this._set(key, entry);
                 }
-                return v;
+                return entry.v;
             }
         }
         return undefined;
     }
     set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
         if (this.L0.has(key)) {
-            this.L0.set(key, value);
+            this.L0.set(key, entry);
             return this;
         }
         if (this.L0.size >= this.size) {
             this.rotate();
         }
-        this.L0.set(key, value);
+        this.L0.set(key, entry);
     }
     caches() {
         return [this.L0, this.L1, this.L2];
     }
     rotate() {
-        this.L2.clear();
         this.L2 = this.L1;
         this.L1 = this.L0;
         this.L0 = new Map();

package/dist/util/timer.d.ts

@@ -6,10 +6,21 @@ export interface Timer {
      * timer was created / started.
      */
     elapsed(): number;
+    /**
+     * Calculate the amount of time in ms since the
+     * end of the last lap.
+     */
+    lap(): number;
 }
 export declare function createTimer(hrTimeFn?: HRTimeFn): Timer;
 export declare type HRTimeFn = (time?: HRTime) => HRTime;
 export declare type HRTime = [number, number];
 export declare function toMilliseconds(t: HRTime): number;
 export declare function polyHrTime(time?: HRTime): HRTime;
+export interface LapRecorder {
+    times: [name: string, lapTime: number, totalTime: number][];
+    lap(name: string): void;
+    report(): string[];
+}
+export declare function createLapRecorder(): LapRecorder;
 //# sourceMappingURL=timer.d.ts.map

package/dist/util/timer.js

@@ -1,15 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.polyHrTime = exports.toMilliseconds = exports.createTimer = void 0;
+exports.createLapRecorder = exports.polyHrTime = exports.toMilliseconds = exports.createTimer = void 0;
 const _hrTime = (process === null || process === void 0 ? void 0 : process.hrtime) || polyHrTime;
 function createTimer(hrTimeFn = _hrTime) {
     let start = hrTimeFn();
+    let lastLap = 0;
+    function elapsed() {
+        return toMilliseconds(hrTimeFn(start));
+    }
     return {
         start() {
             start = hrTimeFn();
+            lastLap = 0;
         },
-        elapsed() {
-            return toMilliseconds(hrTimeFn(start));
+        elapsed,
+        lap() {
+            const now = elapsed();
+            const diff = now - lastLap;
+            lastLap = now;
+            return diff;
         },
     };
 }
@@ -26,4 +35,24 @@ function polyHrTime(time) {
     return [s, n];
 }
 exports.polyHrTime = polyHrTime;
+function createLapRecorder() {
+    const timer = createTimer();
+    const times = [];
+    let lapTime = 0;
+    function lap(name) {
+        const now = timer.elapsed();
+        const diff = now - lapTime;
+        times.push([name, diff, now]);
+        lapTime = diff;
+    }
+    function report() {
+        return times.map(([name, time]) => `${name}: ${time.toFixed(2)}`);
+    }
+    return {
+        times,
+        lap,
+        report,
+    };
+}
+exports.createLapRecorder = createLapRecorder;
 //# sourceMappingURL=timer.js.map

package/dist/util/util.d.ts

@@ -24,4 +24,11 @@ export declare function asyncIterableToArray<T>(iter: Iterable<T> | AsyncIterabl
  * @returns true if the values of `a` are exactly equal to the values of `b`
  */
 export declare function isArrayEqual<K>(a: K[], b: K[]): boolean;
+/**
+ * Determine if two sets intersect
+ * @param a - first Set
+ * @param b - second Set
+ * @returns true iff any element of `a` is in `b`
+ */
+export declare function doSetsIntersect<T>(a: Set<T>, b: Set<T>): boolean;
 //# sourceMappingURL=util.d.ts.map

package/dist/util/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArrayEqual = exports.asyncIterableToArray = exports.flatten = exports.flattenIterable = exports.isDefined = exports.scanMap = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
+exports.doSetsIntersect = exports.isArrayEqual = exports.asyncIterableToArray = exports.flatten = exports.flattenIterable = exports.isDefined = exports.scanMap = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
 // alias for uniqueFilterFnGenerator
 exports.uniqueFn = uniqueFilterFnGenerator;
 function uniqueFilterFnGenerator(extractFn) {
@@ -84,4 +84,21 @@ function isArrayEqual(a, b) {
     return isMatch;
 }
 exports.isArrayEqual = isArrayEqual;
+/**
+ * Determine if two sets intersect
+ * @param a - first Set
+ * @param b - second Set
+ * @returns true iff any element of `a` is in `b`
+ */
+function doSetsIntersect(a, b) {
+    function compare(a, b) {
+        for (const item of a) {
+            if (b.has(item))
+                return true;
+        }
+        return false;
+    }
+    return a.size <= b.size ? compare(a, b) : compare(b, a);
+}
+exports.doSetsIntersect = doSetsIntersect;
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "5.19.2",
+  "version": "5.19.3",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,16 +48,16 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^5.19.2",
-    "@cspell/cspell-pipe": "^5.19.2",
-    "@cspell/cspell-types": "^5.19.2",
+    "@cspell/cspell-bundled-dicts": "^5.19.3",
+    "@cspell/cspell-pipe": "^5.19.3",
+    "@cspell/cspell-types": "^5.19.3",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.2",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-glob": "^5.19.2",
-    "cspell-io": "^5.19.2",
-    "cspell-trie-lib": "^5.19.2",
+    "cspell-glob": "^5.19.3",
+    "cspell-io": "^5.19.3",
+    "cspell-trie-lib": "^5.19.3",
     "fast-equals": "^3.0.0",
     "find-up": "^5.0.0",
     "fs-extra": "^10.0.1",
@@ -83,14 +83,14 @@
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
-    "@types/node": "^17.0.21",
+    "@types/node": "^17.0.22",
     "cspell-dict-nl-nl": "^1.1.2",
     "jest": "^27.5.1",
     "lorem-ipsum": "^2.0.4",
     "rimraf": "^3.0.2",
-    "rollup": "^2.70.0",
+    "rollup": "^2.70.1",
     "rollup-plugin-dts": "^4.2.0",
     "ts-jest": "^27.1.3"
   },
-  "gitHead": "6540cb9f716993c554dc50dd54dd76d553f8f5e4"
+  "gitHead": "df43735d8f85fddbbd0befca7d98956f50474ce7"
 }