cspell-lib 8.2.3 → 8.3.0

package/dist/esm/Settings/Controller/configLoader/configLoader.d.ts

@@ -49,6 +49,7 @@ export interface IConfigLoader {
      * @returns the resulting settings
      */
     searchForConfig(searchFrom: URL | string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
+    resolveConfigFileLocation(filenameOrURL: string | URL, relativeTo?: string | URL): Promise<URL | undefined>;
     getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     /**
      * The loader caches configuration files for performance. This method clears the cache.
@@ -71,12 +72,15 @@ export interface IConfigLoader {
      */
     dispose(): void;
     getStats(): Readonly<Record<string, Readonly<Record<string, number>>>>;
+    readonly isTrusted: boolean;
+    setIsTrusted(isTrusted: boolean): void;
 }
 export declare class ConfigLoader implements IConfigLoader {
     readonly fs: VFileSystem;
     readonly templateVariables: Record<string, string>;
     onReady: Promise<void>;
     readonly fileResolver: FileResolver;
+    private _isTrusted;
     /**
      * Use `createConfigLoader`
      * @param virtualFs - virtual file system to use.
@@ -107,7 +111,9 @@ export declare class ConfigLoader implements IConfigLoader {
     getGlobalSettings(): CSpellSettingsI;
     getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     clearCachedSettingsFiles(): void;
+    protected init(): Promise<void>;
     protected prefetchGlobalSettingsAsync(): Promise<void>;
+    protected resolveDefaultConfig(): Promise<URL>;
     protected importSettings(fileRef: ImportFileRef, pnpSettings: PnPSettingsOptional | undefined, backReferences: string[]): ImportedConfigEntry;
     private setupPnp;
     mergeConfigFileWithImports(cfgFile: CSpellConfigFile, pnpSettings: PnPSettingsOptional | undefined, referencedBy?: string[] | undefined): Promise<CSpellSettingsI>;
@@ -124,7 +130,10 @@ export declare class ConfigLoader implements IConfigLoader {
         cacheMergeListUnique: Readonly<import("../../../util/AutoResolve.js").CacheStats>;
         cacheMergeLists: Readonly<import("../../../util/AutoResolve.js").CacheStats>;
     };
+    resolveConfigFileLocation(filenameOrURL: string | URL, relativeTo: string | URL): Promise<URL | undefined>;
     private resolveFilename;
+    get isTrusted(): boolean;
+    setIsTrusted(isTrusted: boolean): void;
 }
 declare class ConfigLoaderInternal extends ConfigLoader {
     constructor(vfs: VFileSystem);

package/dist/esm/Settings/Controller/configLoader/configLoader.js

@@ -4,6 +4,7 @@ import { isUrlLike, toFileURL } from 'cspell-io';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { URI, Utils as UriUtils } from 'vscode-uri';
+import { srcDirectory } from '../../../../lib-cjs/index.cjs';
 import { onClearCache } from '../../../events/index.js';
 import { getVirtualFS } from '../../../fileSystem.js';
 import { createCSpellSettingsInternal as csi } from '../../../Models/CSpellSettingsInternalDef.js';
@@ -12,7 +13,7 @@ import { logError, logWarning } from '../../../util/logger.js';
 import { FileResolver } from '../../../util/resolveFile.js';
 import { envToTemplateVars } from '../../../util/templates.js';
 import { addTrailingSlash, cwdURL, resolveFileWithURL, toFilePathOrHref, windowsDriveLetterToUpper, } from '../../../util/url.js';
-import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
+import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, defaultConfigFileModuleRef, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
 import { getMergeStats, mergeSettings } from '../../CSpellSettingsServer.js';
 import { getGlobalConfig } from '../../GlobalSettings.js';
 import { ImportError } from '../ImportError.js';
@@ -28,11 +29,19 @@ const setOfSupportedConfigVersions = Object.freeze(new Set(supportedCSpellConfig
 export const sectionCSpell = 'cSpell';
 export const defaultFileName = 'cspell.json';
 let defaultConfigLoader = undefined;
+const defaultExtensions = ['.json', '.yaml', '.yml', '.jsonc'];
+const defaultJsExtensions = ['.js', '.cjs', '.mjs'];
+const trustedSearch = new Map([
+    ['*', defaultExtensions],
+    ['file:', [...defaultExtensions, ...defaultJsExtensions]],
+]);
+const unTrustedSearch = new Map([['*', defaultExtensions]]);
 export class ConfigLoader {
     fs;
     templateVariables;
     onReady;
     fileResolver;
+    _isTrusted = true;
     /**
      * Use `createConfigLoader`
      * @param virtualFs - virtual file system to use.
@@ -40,10 +49,10 @@ export class ConfigLoader {
     constructor(fs, templateVariables = envToTemplateVars(process.env)) {
         this.fs = fs;
         this.templateVariables = templateVariables;
-        this.configSearch = new ConfigSearch(searchPlaces, fs);
+        this.configSearch = new ConfigSearch(searchPlaces, trustedSearch, fs);
         this.cspellConfigFileReaderWriter = createReaderWriter(undefined, undefined, createIO(fs));
         this.fileResolver = new FileResolver(fs, this.templateVariables);
-        this.onReady = this.prefetchGlobalSettingsAsync();
+        this.onReady = this.init();
         this.subscribeToEvents();
     }
     subscribeToEvents() {
@@ -140,10 +149,19 @@ export class ConfigLoader {
         this.cachedMergedConfig = new WeakMap();
         this.prefetchGlobalSettingsAsync();
     }
-    prefetchGlobalSettingsAsync() {
-        this.onReady = this.getGlobalSettingsAsync().then(() => undefined, (e) => logError(e));
+    init() {
+        this.onReady = Promise.all([this.prefetchGlobalSettingsAsync(), this.resolveDefaultConfig()]).then(() => undefined);
         return this.onReady;
     }
+    async prefetchGlobalSettingsAsync() {
+        await this.getGlobalSettingsAsync().catch((e) => logError(e));
+    }
+    async resolveDefaultConfig() {
+        const r = await this.fileResolver.resolveFile(defaultConfigFileModuleRef, srcDirectory);
+        const url = toFileURL(r.filename);
+        this.cspellConfigFileReaderWriter.setTrustedUrls([new URL('../..', url)]);
+        return url;
+    }
     importSettings(fileRef, pnpSettings, backReferences) {
         const url = toFileURL(fileRef.filename);
         const cacheKey = url.href;
@@ -318,6 +336,10 @@ export class ConfigLoader {
     getStats() {
         return { ...getMergeStats() };
     }
+    async resolveConfigFileLocation(filenameOrURL, relativeTo) {
+        const r = await this.fileResolver.resolveFile(filenameOrURL, relativeTo);
+        return r.found ? toFileURL(r.filename) : undefined;
+    }
     async resolveFilename(filename, relativeTo) {
         if (filename instanceof URL)
             return { filename: toFilePathOrHref(filename) };
@@ -332,6 +354,15 @@ export class ConfigLoader {
             error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
         };
     }
+    get isTrusted() {
+        return this._isTrusted;
+    }
+    setIsTrusted(isTrusted) {
+        this._isTrusted = isTrusted;
+        this.clearCachedSettingsFiles();
+        this.configSearch = new ConfigSearch(searchPlaces, isTrusted ? trustedSearch : unTrustedSearch, this.fs);
+        this.cspellConfigFileReaderWriter.setUntrustedExtensions(isTrusted ? [] : defaultJsExtensions);
+    }
 }
 class ConfigLoaderInternal extends ConfigLoader {
     constructor(vfs) {

package/dist/esm/Settings/Controller/configLoader/configSearch.d.ts

@@ -1,15 +1,23 @@
 import type { VFileSystem } from '../../../fileSystem.js';
 export declare class ConfigSearch {
     readonly searchPlaces: readonly string[];
+    readonly allowedExtensionsByProtocol: Map<string, readonly string[]>;
     private fs;
     private searchCache;
     private searchDirCache;
-    constructor(searchPlaces: readonly string[], fs: VFileSystem);
+    private searchPlacesByProtocol;
+    /**
+     * @param searchPlaces - The list of file names to search for.
+     * @param allowedExtensionsByProtocol - Map of allowed extensions by protocol, '*' is used to match all protocols.
+     * @param fs - The file system to use.
+     */
+    constructor(searchPlaces: readonly string[], allowedExtensionsByProtocol: Map<string, readonly string[]>, fs: VFileSystem);
     searchForConfig(searchFromURL: URL): Promise<URL | undefined>;
     clearCache(): void;
     private findUpConfigPath;
     private hasConfig;
     private createHasFileDirSearch;
+    private readDir;
     private createHasFileStatCheck;
     private hasConfigDir;
 }

package/dist/esm/Settings/Controller/configLoader/configSearch.js

@@ -1,15 +1,25 @@
+import { extname } from 'node:path/posix';
 import { urlBasename } from 'cspell-io';
 import { createAutoResolveCache } from '../../../util/AutoResolve.js';
 import { findUpFromUrl } from '../../../util/findUpFromUrl.js';
 export class ConfigSearch {
     searchPlaces;
+    allowedExtensionsByProtocol;
     fs;
     searchCache = new Map();
     searchDirCache = new Map();
-    constructor(searchPlaces, fs) {
+    searchPlacesByProtocol;
+    /**
+     * @param searchPlaces - The list of file names to search for.
+     * @param allowedExtensionsByProtocol - Map of allowed extensions by protocol, '*' is used to match all protocols.
+     * @param fs - The file system to use.
+     */
+    constructor(searchPlaces, allowedExtensionsByProtocol, fs) {
         this.searchPlaces = searchPlaces;
+        this.allowedExtensionsByProtocol = allowedExtensionsByProtocol;
         this.fs = fs;
-        this.searchPlaces = searchPlaces;
+        this.searchPlacesByProtocol = setupSearchPlacesByProtocol(searchPlaces, allowedExtensionsByProtocol);
+        this.searchPlaces = this.searchPlacesByProtocol.get('*') || searchPlaces;
     }
     searchForConfig(searchFromURL) {
         const dirUrl = new URL('.', searchFromURL);
@@ -74,17 +84,26 @@ export class ConfigSearch {
                 const parentInfo = await parentInfoP;
                 const name = urlBasename(dir).slice(0, -1);
                 const found = parentInfo.get(name);
-                if (!found?.isDirectory())
+                if (!found?.isDirectory() && !found?.isSymbolicLink())
                     return false;
             }
             const dirUrlHref = dir.href;
-            const dirInfo = await dirInfoCache.get(dirUrlHref, async () => new Map((await this.fs.readDirectory(dir).catch(() => [])).map((ent) => [ent.name, ent])));
+            const dirInfo = await dirInfoCache.get(dirUrlHref, async () => await this.readDir(dir));
             const name = urlBasename(filename);
             const found = dirInfo.get(name);
-            return !!found?.isFile();
+            return found?.isFile() || found?.isSymbolicLink() || false;
         };
         return hasFile;
     }
+    async readDir(dir) {
+        try {
+            const dirInfo = await this.fs.readDirectory(dir);
+            return new Map(dirInfo.map((ent) => [ent.name, ent]));
+        }
+        catch (e) {
+            return new Map();
+        }
+    }
     createHasFileStatCheck() {
         const hasFile = async (filename) => {
             const stat = await this.fs.stat(filename).catch(() => undefined);
@@ -96,7 +115,8 @@ export class ConfigSearch {
         const hasFile = this.fs.getCapabilities(dir).readDirectory
             ? this.createHasFileDirSearch()
             : this.createHasFileStatCheck();
-        for (const searchPlace of this.searchPlaces) {
+        const searchPlaces = this.searchPlacesByProtocol.get(dir.protocol) || this.searchPlaces;
+        for (const searchPlace of searchPlaces) {
             const file = new URL(searchPlace, dir);
             const found = await hasFile(file);
             if (found) {
@@ -109,6 +129,12 @@ export class ConfigSearch {
         return undefined;
     }
 }
+function setupSearchPlacesByProtocol(searchPlaces, allowedExtensionsByProtocol) {
+    const map = new Map([...allowedExtensionsByProtocol.entries()]
+        .map(([k, v]) => [k, new Set(v)])
+        .map(([protocol, exts]) => [protocol, searchPlaces.filter((url) => exts.has(extname(url)))]));
+    return map;
+}
 async function checkPackageJson(fs, filename) {
     try {
         const file = await fs.readFile(filename);

package/dist/esm/Settings/DefaultSettings.js

@@ -3,11 +3,11 @@ import { srcDirectory } from '../../lib-cjs/index.cjs';
 import { createCSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { PatternRegExp } from '../Models/PatternRegExp.js';
 import { resolveFile } from '../util/resolveFile.js';
+import { defaultConfigFileModuleRef } from './constants.js';
 import { readSettings } from './Controller/configLoader/index.js';
 import { mergeSettings } from './CSpellSettingsServer.js';
 import * as LanguageSettings from './LanguageSettings.js';
 import * as RegPat from './RegExpPatterns.js';
-const defaultConfigFileModuleRef = '@cspell/cspell-bundled-dicts/cspell-default.json';
 // Do not use require.resolve because webpack will mess it up.
 const defaultConfigFile = () => resolveConfigModule(defaultConfigFileModuleRef);
 const regExpSpellCheckerDisable = [

package/dist/esm/Settings/DictionarySettings.js

@@ -1,7 +1,7 @@
 import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
 import * as path from 'path';
 import { isDictionaryDefinitionInlineInternal } from '../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveWeakCache } from '../util/AutoResolve.js';
+import { createAutoResolveWeakWeakCache } from '../util/AutoResolve.js';
 import { resolveRelativeTo } from '../util/resolveFile.js';
 import { toFilePathOrHref } from '../util/url.js';
 import { clean } from '../util/util.js';
@@ -40,7 +40,7 @@ function fixDicPath(defPath, defFile) {
 export function mapDictDefsToInternal(defs, pathToSettingsFile) {
     return defs?.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
 }
-const internalDefs = new AutoResolveWeakCache();
+const internalDefs = createAutoResolveWeakWeakCache();
 export function mapDictDefToInternal(def, pathToSettingsFile) {
     return internalDefs.get(def, (def) => _mapDictDefToInternal(def, pathToSettingsFile));
 }

package/dist/esm/Settings/constants.d.ts

@@ -2,4 +2,5 @@ export declare const configSettingsFileVersion0_1 = "0.1";
 export declare const configSettingsFileVersion0_2 = "0.2";
 export declare const currentSettingsFileVersion = "0.2";
 export declare const ENV_CSPELL_GLOB_ROOT = "CSPELL_GLOB_ROOT";
+export declare const defaultConfigFileModuleRef = "@cspell/cspell-bundled-dicts/cspell-default.json";
 //# sourceMappingURL=constants.d.ts.map

package/dist/esm/Settings/constants.js

@@ -2,4 +2,5 @@ export const configSettingsFileVersion0_1 = '0.1';
 export const configSettingsFileVersion0_2 = '0.2';
 export const currentSettingsFileVersion = configSettingsFileVersion0_2;
 export const ENV_CSPELL_GLOB_ROOT = 'CSPELL_GLOB_ROOT';
+export const defaultConfigFileModuleRef = '@cspell/cspell-bundled-dicts/cspell-default.json';
 //# sourceMappingURL=constants.js.map

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

@@ -8,7 +8,9 @@ export declare class DictionaryLoader {
     private inlineDictionaryCache;
     private dictionaryCacheByDef;
     private reader;
-    constructor(fs: VFileSystem);
+    /** The keepAliveCache is to hold onto the most recently loaded dictionaries. */
+    private keepAliveCache;
+    constructor(fs: VFileSystem, keepAliveSize?: number);
     loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
     /**
      * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.

package/dist/esm/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -3,8 +3,9 @@ import { StrongWeakMap } from '@cspell/strong-weak-map';
 import { createFailedToLoadDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from 'cspell-dictionary';
 import { compareStats, toFileURL, urlBasename } from 'cspell-io';
 import { isDictionaryDefinitionInlineInternal } from '../../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveWeakCache } from '../../util/AutoResolve.js';
+import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
+import { SimpleCache } from '../../util/simpleCache.js';
 import { SpellingDictionaryLoadError } from '../SpellingDictionaryError.js';
 const MAX_AGE = 10000;
 const loaders = {
@@ -23,11 +24,14 @@ export class DictionaryLoader {
     fs;
     dictionaryCache = new StrongWeakMap();
     inlineDictionaryCache = new AutoResolveWeakCache();
-    dictionaryCacheByDef = new StrongWeakMap();
+    dictionaryCacheByDef = new AutoResolveWeakWeakCache();
     reader;
-    constructor(fs) {
+    /** The keepAliveCache is to hold onto the most recently loaded dictionaries. */
+    keepAliveCache;
+    constructor(fs, keepAliveSize = 10) {
         this.fs = fs;
         this.reader = toReader(fs);
+        this.keepAliveCache = new SimpleCache(keepAliveSize);
     }
     loadDictionary(def) {
         if (isDictionaryDefinitionInlineInternal(def)) {
@@ -39,6 +43,7 @@ export class DictionaryLoader {
         }
         const loadedEntry = this.loadEntry(def.path, def);
         this.setCacheEntry(key, loadedEntry, def);
+        this.keepAliveCache.set(def, loadedEntry);
         return loadedEntry.pending.then(([dictionary]) => dictionary);
     }
     /**
@@ -52,6 +57,7 @@ export class DictionaryLoader {
     getCacheEntry(def) {
         const defEntry = this.dictionaryCacheByDef.get(def);
         if (defEntry) {
+            this.keepAliveCache.get(def);
             return defEntry;
         }
         const key = this.calcKey(def);
@@ -59,6 +65,7 @@ export class DictionaryLoader {
         if (entry) {
             // replace old entry so it can be released.
             entry.options = def;
+            this.keepAliveCache.set(def, entry);
         }
         return { key, entry };
     }

package/dist/esm/textValidation/docValidator.d.ts

@@ -72,6 +72,21 @@ export declare class DocumentValidator {
     checkDocumentDirectives(forceCheck?: boolean): ValidationIssue[];
     get document(): TextDocument;
     updateDocumentText(text: string): Promise<void>;
+    /**
+     * Get the calculated ranges of text that should be included in the spell checking.
+     * @returns MatchRanges of text to include.
+     */
+    getCheckedTextRanges(): MatchRange[];
+    traceWord(word: string): {
+        word: string;
+        found: boolean;
+        foundWord: string | undefined;
+        forbidden: boolean;
+        noSuggest: boolean;
+        dictName: string;
+        dictSource: string;
+        errors: Error[] | undefined;
+    }[];
     private defaultParser;
     private _checkParsedText;
     private addPossibleError;

package/dist/esm/textValidation/docValidator.js

@@ -11,6 +11,7 @@ import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
+import { toFilePathOrHref } from '../util/url.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
@@ -237,6 +238,36 @@ export class DocumentValidator {
         updateTextDocument(this._document, [{ text }]);
         await this._updatePrep();
     }
+    /**
+     * Get the calculated ranges of text that should be included in the spell checking.
+     * @returns MatchRanges of text to include.
+     */
+    getCheckedTextRanges() {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        return this._preparations.includeRanges;
+    }
+    traceWord(word) {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const dictCollection = this._preparations.dictionary;
+        const config = this._preparations.config;
+        const opts = {
+            ignoreCase: true,
+            allowCompoundWords: config.allowCompoundWords || false,
+        };
+        const trace = dictCollection.dictionaries
+            .map((dict) => ({ dict, findResult: dict.find(word, opts) }))
+            .map(({ dict, findResult }) => ({
+            word,
+            found: !!findResult?.found,
+            foundWord: findResult?.found || undefined,
+            forbidden: findResult?.forbidden || false,
+            noSuggest: findResult?.noSuggest || false,
+            dictName: dict.name,
+            dictSource: toFilePathOrHref(dict.source),
+            errors: normalizeErrors(dict.getErrors?.()),
+        }));
+        return trace;
+    }
     defaultParser() {
         return pipeSync(this.document.getLines(), opMap((line) => {
             const { text, offset } = line;
@@ -378,4 +409,7 @@ function recordPerfTime(timings, name) {
 function timePromise(timings, name, p) {
     return p.finally(recordPerfTime(timings, name));
 }
+function normalizeErrors(errors) {
+    return errors?.length ? errors : undefined;
+}
 //# sourceMappingURL=docValidator.js.map

package/dist/esm/trace.js

@@ -1,9 +1,9 @@
-import { fileURLToPath } from 'node:url';
 import { genSequence } from 'gensequence';
 import { toInternalSettings } from './Settings/CSpellSettingsServer.js';
 import { finalizeSettings, mergeSettings } from './Settings/index.js';
 import { calcSettingsForLanguageId } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
+import { toFilePathOrHref } from './util/url.js';
 import * as util from './util/util.js';
 export async function traceWords(words, settings, options) {
     const results = await util.asyncIterableToArray(traceWordsAsync(words, settings, options));
@@ -64,9 +64,6 @@ export async function* traceWordsAsync(words, settings, options) {
     }
 }
 function dictSourceToFilename(source) {
-    if (source.startsWith('file:')) {
-        return fileURLToPath(source);
-    }
-    return source;
+    return toFilePathOrHref(source);
 }
 //# sourceMappingURL=trace.js.map

package/dist/esm/util/AutoResolve.d.ts

@@ -46,5 +46,20 @@ export declare class AutoResolveWeakCache<K extends object, V> implements IWeakM
     stats(): AutoResolveCacheStats;
 }
 export declare function createAutoResolveWeakCache<K extends object, V>(): AutoResolveWeakCache<K, V>;
+export declare class AutoResolveWeakWeakCache<K extends object, V extends object> implements IWeakMap<K, V> {
+    private _map;
+    private _stats;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    get map(): WeakMap<K, WeakRef<V>>;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+    clear(): void;
+    delete(k: K): boolean;
+    dispose(): void;
+    stats(): AutoResolveCacheStats;
+}
+export declare function createAutoResolveWeakWeakCache<K extends object, V extends object>(): AutoResolveWeakWeakCache<K, V>;
 export {};
 //# sourceMappingURL=AutoResolve.d.ts.map

package/dist/esm/util/AutoResolve.js

@@ -116,4 +116,57 @@ export class AutoResolveWeakCache {
 export function createAutoResolveWeakCache() {
     return new AutoResolveWeakCache();
 }
+export class AutoResolveWeakWeakCache {
+    _map = new WeakMap();
+    _stats = new CacheStatsTracker();
+    get(k, resolve) {
+        const map = this._map;
+        const found = map.get(k);
+        const foundValue = found?.deref();
+        if (found !== undefined && foundValue) {
+            ++this._stats.hits;
+            return foundValue;
+        }
+        ++this._stats.misses;
+        if (!resolve) {
+            if (found) {
+                map.delete(k);
+            }
+            return undefined;
+        }
+        ++this._stats.resolved;
+        const value = resolve(k);
+        map.set(k, new WeakRef(value));
+        return value;
+    }
+    get map() {
+        return this._map;
+    }
+    has(k) {
+        return !!this._map.get(k)?.deref();
+    }
+    set(k, v) {
+        ++this._stats.sets;
+        this._map.set(k, new WeakRef(v));
+        return this;
+    }
+    clear() {
+        this._stats.clear();
+        this._map = new WeakMap();
+    }
+    delete(k) {
+        ++this._stats.deletes;
+        return this._map.delete(k);
+    }
+    dispose() {
+        ++this._stats.disposals;
+        this.clear();
+    }
+    stats() {
+        return this._stats.stats();
+    }
+}
+export function createAutoResolveWeakWeakCache() {
+    return new AutoResolveWeakWeakCache();
+}
 //# sourceMappingURL=AutoResolve.js.map

package/dist/esm/util/TextRange.d.ts

@@ -1,3 +1,7 @@
+/**
+ * A range of text in a document.
+ * The range is inclusive of the startPos and exclusive of the endPos.
+ */
 export interface MatchRange {
     startPos: number;
     endPos: number;

package/dist/esm/util/simpleCache.d.ts

@@ -34,6 +34,7 @@ export declare class SimpleCache<K, T> {
     has(key: K): boolean;
     get(key: K): T | undefined;
     set(key: K, value: T): void;
+    delete(key: K): boolean;
     private _set;
     private caches;
     private rotate;

package/dist/esm/util/simpleCache.js

@@ -103,6 +103,13 @@ export class SimpleCache {
     set(key, value) {
         this._set(key, { v: value });
     }
+    delete(key) {
+        let deleted = false;
+        for (const c of this.caches()) {
+            deleted = c.delete(key) || deleted;
+        }
+        return deleted;
+    }
     _set(key, entry) {
         if (this.L0.has(key)) {
             this.L0.set(key, entry);
@@ -117,9 +124,11 @@ export class SimpleCache {
         return [this.L0, this.L1, this.L2];
     }
     rotate() {
+        const L2 = this.L2;
         this.L2 = this.L1;
         this.L1 = this.L0;
-        this.L0 = new Map();
+        this.L0 = L2;
+        this.L0.clear();
     }
 }
 export class AutoCache extends SimpleCache {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.2.3",
+  "version": "8.3.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -57,21 +57,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.2.3",
-    "@cspell/cspell-pipe": "8.2.3",
-    "@cspell/cspell-resolver": "8.2.3",
-    "@cspell/cspell-types": "8.2.3",
-    "@cspell/dynamic-import": "8.2.3",
-    "@cspell/strong-weak-map": "8.2.3",
+    "@cspell/cspell-bundled-dicts": "8.3.0",
+    "@cspell/cspell-pipe": "8.3.0",
+    "@cspell/cspell-resolver": "8.3.0",
+    "@cspell/cspell-types": "8.3.0",
+    "@cspell/dynamic-import": "8.3.0",
+    "@cspell/strong-weak-map": "8.3.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "cspell-config-lib": "8.2.3",
-    "cspell-dictionary": "8.2.3",
-    "cspell-glob": "8.2.3",
-    "cspell-grammar": "8.2.3",
-    "cspell-io": "8.2.3",
-    "cspell-trie-lib": "8.2.3",
+    "cspell-config-lib": "8.3.0",
+    "cspell-dictionary": "8.3.0",
+    "cspell-glob": "8.3.0",
+    "cspell-grammar": "8.3.0",
+    "cspell-io": "8.3.0",
+    "cspell-trie-lib": "8.3.0",
     "fast-equals": "^5.0.1",
     "gensequence": "^6.0.0",
     "import-fresh": "^3.3.0",
@@ -90,10 +90,10 @@
     "@cspell/dict-fr-fr": "^2.2.2",
     "@cspell/dict-html": "^4.0.5",
     "@cspell/dict-nl-nl": "^2.3.0",
-    "@cspell/dict-python": "^4.1.10",
+    "@cspell/dict-python": "^4.1.11",
     "@types/configstore": "^6.0.2",
     "cspell-dict-nl-nl": "^1.1.2",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "e3098b21e0a199d61226f8ff4989d48b385eddfa"
+  "gitHead": "019c7ccd326b7fc9e106069ddf6008d5079bbd12"
 }