cspell-lib 5.19.0 → 5.19.3

package/dist/Models/CSpellSettingsInternalDef.d.ts

@@ -6,6 +6,11 @@ export interface CSpellSettingsInternal extends Omit<CSpellSettingsWithSourceTra
     [SymbolCSpellSettingsInternal]: true;
     dictionaryDefinitions?: DictionaryDefinitionInternal[];
 }
+export interface CSpellSettingsInternalFinalized extends CSpellSettingsInternal {
+    finalized: true;
+    ignoreRegExpList: RegExp[];
+    includeRegExpList: RegExp[];
+}
 declare type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
 export interface DictionaryDefinitionInternal extends Readonly<DictionaryDefinitionPreferred>, Readonly<Partial<DictionaryDefinitionCustomUniqueFields>>, Readonly<DictionaryDefinitionAugmented> {
     /**

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

@@ -1,5 +1,5 @@
 import type { CSpellSettingsWithSourceTrace, Glob, ImportFileRef } from '@cspell/cspell-types';
-import { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef';
+import { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef';
 import { OptionalOrUndefined } from '../util/types';
 declare type CSpellSettingsWST = CSpellSettingsWithSourceTrace;
 declare type CSpellSettingsWSTO = OptionalOrUndefined<CSpellSettingsWithSourceTrace>;
@@ -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;
 /**
@@ -20,7 +20,7 @@ export declare function calcOverrideSettings(settings: CSpellSettingsWSTO, filen
  * @param settings - settings to finalize
  * @returns settings where all globs and file paths have been resolved.
  */
-export declare function finalizeSettings(settings: CSpellSettingsWSTO | CSpellSettingsI): CSpellSettingsI;
+export declare function finalizeSettings(settings: CSpellSettingsWSTO | CSpellSettingsI): CSpellSettingsInternalFinalized;
 export declare function toInternalSettings(settings: undefined): undefined;
 export declare function toInternalSettings(settings: CSpellSettingsI | CSpellSettingsWSTO): CSpellSettingsI;
 export declare function toInternalSettings(settings?: CSpellSettingsI | CSpellSettingsWSTO): CSpellSettingsI | undefined;

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),
@@ -221,6 +221,7 @@ function _finalizeSettings(settings) {
     // apply patterns to any RegExpLists.
     const finalized = {
         ...settings,
+        finalized: true,
         ignoreRegExpList: (0, patterns_1.resolvePatterns)(settings.ignoreRegExpList, settings.patterns),
         includeRegExpList: (0, patterns_1.resolvePatterns)(settings.includeRegExpList, settings.patterns),
     };

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/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.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

@@ -25,6 +25,8 @@ export declare class DocumentValidator {
     readonly errors: Error[];
     private _prepared;
     private _preparations;
+    private _preparationTime;
+    private _suggestions;
     /**
      * @param doc - Document to validate
      * @param config - configuration to use (not finalized).
@@ -34,11 +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];