cspell-lib 8.0.0 → 8.1.0

package/dist/esm/Settings/mergeCache.js

@@ -0,0 +1,22 @@
+import { onClearCache } from '../events/index.js';
+import { AutoResolveWeakCache } from '../util/AutoResolve.js';
+export class CalcLeftRightResultWeakCache {
+    map = new AutoResolveWeakCache();
+    _toDispose;
+    constructor() {
+        this._toDispose = onClearCache(() => {
+            this.clear();
+        });
+    }
+    get(left, right, calc) {
+        const m = this.map.get(left, () => new AutoResolveWeakCache());
+        return m.get(right, () => calc(left, right));
+    }
+    clear() {
+        this.map.clear();
+    }
+    dispose() {
+        this._toDispose.dispose();
+    }
+}
+//# sourceMappingURL=mergeCache.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Merges two lists and removes duplicates.  Order is NOT preserved.
+ */
+export declare function mergeListUnique(left: undefined, right: undefined): undefined;
+export declare function mergeListUnique<T>(left: T[], right: T[]): T[];
+export declare function mergeListUnique<T>(left: undefined, right: T[]): T[];
+export declare function mergeListUnique<T>(left: T[], right: undefined): T[];
+export declare function mergeListUnique<T>(left: T[] | undefined, right: T[] | undefined): T[] | undefined;
+/**
+ * Merges two lists.
+ * Order is preserved.
+ */
+export declare function mergeList(left: undefined, right: undefined): undefined;
+export declare function mergeList<T>(left: T[], right: T[]): T[];
+export declare function mergeList<T>(left: undefined, right: T[]): T[];
+export declare function mergeList<T>(left: T[], right: undefined): T[];
+export declare function mergeList<T>(left: T[] | undefined, right: T[] | undefined): T[] | undefined;
+//# sourceMappingURL=mergeList.d.ts.map

package/dist/esm/Settings/mergeList.js

@@ -0,0 +1,34 @@
+import { CalcLeftRightResultWeakCache } from './mergeCache.js';
+const cacheMergeListUnique = new CalcLeftRightResultWeakCache();
+const cacheMergeLists = new CalcLeftRightResultWeakCache();
+export function mergeListUnique(left, right) {
+    if (!Array.isArray(left))
+        return Array.isArray(right) ? right : undefined;
+    if (!Array.isArray(right))
+        return left;
+    if (!right.length)
+        return left;
+    if (!left.length)
+        return right;
+    const result = cacheMergeListUnique.get(left, right, (left, right) => [...new Set([...left, ...right])]);
+    Object.freeze(left);
+    Object.freeze(right);
+    Object.freeze(result);
+    return result;
+}
+export function mergeList(left, right) {
+    if (!Array.isArray(left))
+        return Array.isArray(right) ? right : undefined;
+    if (!Array.isArray(right))
+        return left;
+    if (!left.length)
+        return right;
+    if (!right.length)
+        return left;
+    const result = cacheMergeLists.get(left, right, (left, right) => left.concat(right));
+    Object.freeze(left);
+    Object.freeze(right);
+    Object.freeze(result);
+    return result;
+}
+//# sourceMappingURL=mergeList.js.map

package/dist/esm/Settings/patterns.js

@@ -1,6 +1,13 @@
 import { stringToRegExp } from '../util/textRegex.js';
 import { isDefined } from '../util/util.js';
-export function resolvePatterns(regExpList = [], patternDefinitions = []) {
+import { CalcLeftRightResultWeakCache } from './mergeCache.js';
+const emptyRegExpList = [];
+const emptyPatternDefinitions = [];
+const cache = new CalcLeftRightResultWeakCache();
+export function resolvePatterns(regExpList = emptyRegExpList, patternDefinitions = emptyPatternDefinitions) {
+    return cache.get(regExpList, patternDefinitions, _resolvePatterns);
+}
+function _resolvePatterns(regExpList, patternDefinitions) {
     const patternMap = new Map(patternDefinitions.map((def) => [def.name.toLowerCase(), def.pattern]));
     const resolved = new Set();
     function resolvePattern(p) {
@@ -20,7 +27,11 @@ export function resolvePatterns(regExpList = [], patternDefinitions = []) {
         }
     }
     const patternList = regExpList.map(resolvePattern).filter(isDefined);
-    return [...flatten(patternList)].map(toRegExp).filter(isDefined);
+    const result = [...flatten(patternList)].map(toRegExp).filter(isDefined);
+    Object.freeze(regExpList);
+    Object.freeze(patternDefinitions);
+    Object.freeze(result);
+    return result;
 }
 function toRegExp(pattern) {
     return pattern instanceof RegExp ? new RegExp(pattern) : stringToRegExp(pattern, 'gim', 'g');

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

@@ -27,5 +27,6 @@ export declare class DictionaryLoader {
     private isEqual;
     private normalizeOptions;
     private loadInlineDict;
+    private calcKey;
 }
 //# sourceMappingURL=DictionaryLoader.d.ts.map

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

@@ -55,7 +55,7 @@ export class DictionaryLoader {
         if (entry?.dictionary && entry.loadingState === LoadingState.Loaded) {
             return entry.dictionary;
         }
-        const loadedEntry = this.loadEntrySync(def.path, def);
+        const loadedEntry = this.loadEntrySync(this.cspellIO.toFileURL(def.path), def);
         this.setCacheEntry(key, loadedEntry, def);
         return loadedEntry.dictionary;
     }
@@ -72,7 +72,7 @@ export class DictionaryLoader {
         if (defEntry) {
             return defEntry;
         }
-        const key = calcKey(def);
+        const key = this.calcKey(def);
         const entry = this.dictionaryCache.get(key);
         if (entry) {
             // replace old entry so it can be released.
@@ -96,21 +96,22 @@ export class DictionaryLoader {
             const sigMatches = entry.sig === sig;
             if (sigMatches && hasChanged) {
                 entry.loadingState = LoadingState.Loading;
-                const key = calcKey(entry.options);
+                const key = this.calcKey(entry.options);
                 const newEntry = this.loadEntry(entry.uri, entry.options);
                 this.dictionaryCache.set(key, newEntry);
                 this.dictionaryCacheByDef.set(entry.options, { key, entry: newEntry });
             }
         }
     }
-    loadEntry(uri, options, now = Date.now()) {
-        options = this.normalizeOptions(uri, options);
-        const pDictionary = load(this.reader, uri, options).catch((e) => createFailedToLoadDictionary(options.name, uri, new SpellingDictionaryLoadError(uri, options, e, 'failed to load'), options));
-        const pStat = this.getStat(uri);
+    loadEntry(fileOrUri, options, now = Date.now()) {
+        const url = this.cspellIO.toFileURL(fileOrUri);
+        options = this.normalizeOptions(url, options);
+        const pDictionary = load(this.reader, this.cspellIO.toFileURL(fileOrUri), options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
+        const pStat = this.getStat(fileOrUri);
         const pending = Promise.all([pDictionary, pStat]);
         const sig = now + Math.random();
         const entry = {
-            uri,
+            uri: url.href,
             options,
             ts: now,
             stat: undefined,
@@ -128,15 +129,16 @@ export class DictionaryLoader {
         });
         return entry;
     }
-    loadEntrySync(uri, options, now = Date.now()) {
-        options = this.normalizeOptions(uri, options);
-        const stat = this.getStatSync(uri);
+    loadEntrySync(fileOrUri, options, now = Date.now()) {
+        const url = this.cspellIO.toFileURL(fileOrUri);
+        options = this.normalizeOptions(url, options);
+        const stat = this.getStatSync(url);
         const sig = now + Math.random();
         try {
-            const dictionary = loadSync(this.reader, uri, options);
+            const dictionary = loadSync(this.reader, url, options);
             const pending = Promise.resolve([dictionary, stat]);
             return {
-                uri,
+                uri: url.href,
                 options,
                 ts: now,
                 stat,
@@ -148,10 +150,10 @@ export class DictionaryLoader {
         }
         catch (e) {
             const error = toError(e);
-            const dictionary = createFailedToLoadDictionary(options.name, uri, new SpellingDictionaryLoadError(uri, options, error, 'failed to load'), options);
+            const dictionary = createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, error, 'failed to load'), options);
             const pending = Promise.resolve([dictionary, stat]);
             return {
-                uri,
+                uri: url.href,
                 options,
                 ts: now,
                 stat,
@@ -163,11 +165,11 @@ export class DictionaryLoader {
         }
     }
     getStat(uri) {
-        return this.cspellIO.getStat(uri).catch(toError);
+        return this.cspellIO.getStat(this.cspellIO.toFileURL(uri)).catch(toError);
     }
     getStatSync(uri) {
         try {
-            return this.cspellIO.getStatSync(uri);
+            return this.cspellIO.getStatSync(this.cspellIO.toFileURL(uri));
         }
         catch (e) {
             return toError(e);
@@ -184,28 +186,28 @@ export class DictionaryLoader {
     normalizeOptions(uri, options) {
         if (options.name)
             return options;
-        return { ...options, name: this.cspellIO.uriBasename(uri) };
+        return { ...options, name: this.cspellIO.urlBasename(uri) };
     }
     loadInlineDict(def) {
         return this.inlineDictionaryCache.get(def, (def) => createInlineSpellingDictionary(def, def.__source || 'memory'));
     }
+    calcKey(def) {
+        const path = def.path;
+        const loaderType = determineType(this.cspellIO.toFileURL(path), def);
+        const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
+        const parts = [path, loaderType].concat(optValues);
+        return parts.join('|');
+    }
 }
 function toReader(cspellIO) {
     return {
-        read: async (filename) => (await cspellIO.readFile(filename)).content,
-        readLines: async (filename) => toLines((await cspellIO.readFile(filename)).content),
-        readSync: (filename) => cspellIO.readFileSync(filename).content,
-        readLinesSync: (filename) => toLines(cspellIO.readFileSync(filename).content),
+        read: async (filename) => (await cspellIO.readFile(filename)).getText(),
+        readLines: async (filename) => toLines((await cspellIO.readFile(filename)).getText()),
+        readSync: (filename) => cspellIO.readFileSync(filename).getText(),
+        readLinesSync: (filename) => toLines(cspellIO.readFileSync(filename).getText()),
     };
 }
 const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
-function calcKey(def) {
-    const path = def.path;
-    const loaderType = determineType(path, def);
-    const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
-    const parts = [path, loaderType].concat(optValues);
-    return parts.join('|');
-}
 function isError(e) {
     const err = e;
     return !!err.message;
@@ -213,9 +215,9 @@ function isError(e) {
 function determineType(uri, opts) {
     const t = (opts.type && opts.type in loaders && opts.type) || 'S';
     const defLoaderType = t;
-    const defType = uri.endsWith('.trie.gz') ? 'T' : defLoaderType;
+    const defType = uri.pathname.endsWith('.trie.gz') ? 'T' : defLoaderType;
     const regTrieTest = /\.trie\b/i;
-    return regTrieTest.test(uri) ? 'T' : defType;
+    return regTrieTest.test(uri.pathname) ? 'T' : defType;
 }
 function load(reader, uri, options) {
     const type = determineType(uri, options);
@@ -241,15 +243,15 @@ function _legacyWordListSync(lines, filename, options) {
     opMap((line) => line.replace(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename, options);
+    return createSpellingDictionary(words, options.name, filename.toString(), options);
 }
 async function wordsPerLineWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
-    return _wordsPerLineWordList(lines, filename, options);
+    return _wordsPerLineWordList(lines, filename.toString(), options);
 }
 function wordsPerLineWordListSync(reader, filename, options) {
     const lines = reader.readLinesSync(filename);
-    return _wordsPerLineWordList(lines, filename, options);
+    return _wordsPerLineWordList(lines, filename.toString(), options);
 }
 function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
@@ -261,19 +263,19 @@ function _wordsPerLineWordList(lines, filename, options) {
 }
 async function loadSimpleWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
-    return createSpellingDictionary(lines, options.name, filename, options);
+    return createSpellingDictionary(lines, options.name, filename.href, options);
 }
 function loadSimpleWordListSync(reader, filename, options) {
     const lines = reader.readLinesSync(filename);
-    return createSpellingDictionary(lines, options.name, filename, options);
+    return createSpellingDictionary(lines, options.name, filename.href, options);
 }
 async function loadTrie(reader, filename, options) {
     const content = await reader.read(filename);
-    return createSpellingDictionaryFromTrieFile(content, options.name, filename, options);
+    return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
 }
 function loadTrieSync(reader, filename, options) {
     const content = reader.readSync(filename);
-    return createSpellingDictionaryFromTrieFile(content, options.name, filename, options);
+    return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
 }
 function toLines(content) {
     return content.split(/\n|\r\n|\r/);

package/dist/esm/clearCachedFiles.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Clear the cached files and other cached data.
+ * Calling this function will cause the next spell check to take longer because it will need to reload configuration files and dictionaries.
+ * Call this function if configuration files have changed.
+ *
+ * It is safe to replace {@link clearCachedFiles} with {@link clearCaches}
+ */
 export declare function clearCachedFiles(): Promise<void>;
+/**
+ * Sends and event to clear the caches.
+ * It resets the configuration files and dictionaries.
+ *
+ * It is safe to replace {@link clearCaches} with {@link clearCachedFiles}
+ */
+export declare function clearCaches(): void;
 //# sourceMappingURL=clearCachedFiles.d.ts.map

package/dist/esm/clearCachedFiles.js

@@ -1,6 +1,32 @@
-import { clearCachedSettingsFiles } from './Settings/index.js';
+import { dispatchClearCache } from './events/index.js';
 import { refreshDictionaryCache } from './SpellingDictionary/index.js';
-export async function clearCachedFiles() {
-    await Promise.all([clearCachedSettingsFiles(), refreshDictionaryCache(0)]);
+/**
+ * Clear the cached files and other cached data.
+ * Calling this function will cause the next spell check to take longer because it will need to reload configuration files and dictionaries.
+ * Call this function if configuration files have changed.
+ *
+ * It is safe to replace {@link clearCachedFiles} with {@link clearCaches}
+ */
+export function clearCachedFiles() {
+    return _clearCachedFiles();
+}
+/**
+ * Clear the cached files and other cached data.
+ * Calling this function will cause the next spell check to take longer because it will need to reload configuration files and dictionaries.
+ * Call this function if configuration files have changed.
+ */
+function _clearCachedFiles() {
+    // We want to dispatch immediately.
+    dispatchClearCache();
+    return Promise.all([refreshDictionaryCache(0)]).then(() => undefined);
+}
+/**
+ * Sends and event to clear the caches.
+ * It resets the configuration files and dictionaries.
+ *
+ * It is safe to replace {@link clearCaches} with {@link clearCachedFiles}
+ */
+export function clearCaches() {
+    clearCachedFiles().catch(() => { });
 }
 //# sourceMappingURL=clearCachedFiles.js.map

package/dist/esm/events/events.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Event indicating that the cache should be cleared.
+ */
+export declare class ClearCacheEvent extends Event {
+    constructor();
+    static eventName: "clear-cache";
+}
+export type EventNames = typeof ClearCacheEvent.eventName;
+export type EventTypes = ClearCacheEvent;
+export interface DisposableListener {
+    dispose(): void;
+}
+export declare function addEventListener(event: EventNames, listener: (event: ClearCacheEvent) => void): DisposableListener;
+export declare function dispatchEvent(event: EventTypes): void;
+export declare function onClearCache(listener: () => void): DisposableListener;
+export declare function dispatchClearCache(): void;
+//# sourceMappingURL=events.d.ts.map

package/dist/esm/events/events.js

@@ -0,0 +1,28 @@
+/**
+ * Event indicating that the cache should be cleared.
+ */
+export class ClearCacheEvent extends Event {
+    constructor() {
+        super(ClearCacheEvent.eventName);
+    }
+    static eventName = 'clear-cache';
+}
+const eventEmitter = new EventTarget();
+export function addEventListener(event, listener) {
+    eventEmitter.addEventListener(event, listener);
+    return {
+        dispose() {
+            eventEmitter.removeEventListener(event, listener);
+        },
+    };
+}
+export function dispatchEvent(event) {
+    eventEmitter.dispatchEvent(event);
+}
+export function onClearCache(listener) {
+    return addEventListener(ClearCacheEvent.eventName, listener);
+}
+export function dispatchClearCache() {
+    dispatchEvent(new ClearCacheEvent());
+}
+//# sourceMappingURL=events.js.map

package/dist/esm/events/index.d.ts

@@ -0,0 +1,3 @@
+export type { DisposableListener, EventNames, EventTypes } from './events.js';
+export { addEventListener, ClearCacheEvent, dispatchClearCache, dispatchEvent, onClearCache } from './events.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/events/index.js

@@ -0,0 +1,2 @@
+export { addEventListener, ClearCacheEvent, dispatchClearCache, dispatchEvent, onClearCache } from './events.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/getDictionary.js

@@ -5,7 +5,7 @@ import { getDictionaryInternal } from './SpellingDictionary/index.js';
  * @param settings - that defines the dictionaries and the ones to load.
  * @returns a dictionary collection that represents all the enabled dictionaries.
  */
-export function getDictionary(settings) {
+export async function getDictionary(settings) {
     return getDictionaryInternal(toInternalSettings(settings));
 }
 //# sourceMappingURL=getDictionary.js.map

package/dist/esm/globs/checkFilenameMatchesGlob.d.ts

@@ -0,0 +1,8 @@
+import type { Glob } from '@cspell/cspell-types';
+/**
+ * @param filename - filename
+ * @param globs - globs
+ * @returns true if it matches
+ */
+export declare function checkFilenameMatchesExcludeGlob(filename: string, globs: Glob | Glob[]): boolean;
+//# sourceMappingURL=checkFilenameMatchesGlob.d.ts.map

package/dist/esm/globs/checkFilenameMatchesGlob.js

@@ -0,0 +1,11 @@
+import { getGlobMatcherForExcluding } from './getGlobMatcher.js';
+/**
+ * @param filename - filename
+ * @param globs - globs
+ * @returns true if it matches
+ */
+export function checkFilenameMatchesExcludeGlob(filename, globs) {
+    const m = getGlobMatcherForExcluding(globs);
+    return m.match(filename);
+}
+//# sourceMappingURL=checkFilenameMatchesGlob.js.map

package/dist/esm/globs/getGlobMatcher.d.ts

@@ -0,0 +1,4 @@
+import type { Glob } from '@cspell/cspell-types';
+import { GlobMatcher } from 'cspell-glob';
+export declare function getGlobMatcherForExcluding(glob: Glob | Glob[] | undefined): GlobMatcher;
+//# sourceMappingURL=getGlobMatcher.d.ts.map

package/dist/esm/globs/getGlobMatcher.js

@@ -0,0 +1,31 @@
+import { GlobMatcher } from 'cspell-glob';
+import { onClearCache } from '../events/index.js';
+const simpleGlobCache = new Map();
+let globCache = new WeakMap();
+onClearCache(() => {
+    globCache = new WeakMap();
+    simpleGlobCache.clear();
+});
+const emptyIgnorePaths = [];
+export function getGlobMatcherForExcluding(glob) {
+    if (!glob || (Array.isArray(glob) && !glob.length))
+        return getGlobMatcherGlobGlob(emptyIgnorePaths);
+    return typeof glob === 'string' ? getGlobMatcherGlobString(glob) : getGlobMatcherGlobGlob(glob);
+}
+function getGlobMatcherGlobString(glob) {
+    const cached = simpleGlobCache.get(glob);
+    if (cached)
+        return cached;
+    const m = new GlobMatcher(glob);
+    simpleGlobCache.set(glob, m);
+    return m;
+}
+function getGlobMatcherGlobGlob(glob) {
+    const cached = globCache.get(glob);
+    if (cached)
+        return cached;
+    const m = new GlobMatcher(glob);
+    globCache.set(glob, m);
+    return m;
+}
+//# sourceMappingURL=getGlobMatcher.js.map

package/dist/esm/index.d.ts

@@ -8,7 +8,7 @@ export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagErr
 export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesForExt } from './LanguageIds.js';
 export type { CreateTextDocumentParams, TextDocument, TextDocumentLine, TextDocumentRef, } from './Models/TextDocument.js';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument.js';
-export { calcOverrideSettings, checkFilenameMatchesGlob, clearCachedSettingsFiles, type ConfigurationDependencies, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettings, getDefaultSettings, getGlobalSettings, getSources, ImportError, type ImportFileRefWithError, loadConfig, loadPnP, loadPnPSync, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Settings/index.js';
+export { calcOverrideSettings, checkFilenameMatchesGlob, type ConfigurationDependencies, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, type ImportFileRefWithError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
 export { determineFinalDocumentSettings, DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckFile, SpellCheckFileOptions, SpellCheckFileResult, } from './spellCheckFile.js';
@@ -25,6 +25,8 @@ export * from '@cspell/cspell-types';
 export { asyncIterableToArray, readFileText as readFile, readFileTextSync as readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from 'cspell-io';
 export { Link, Text };
 export { ExclusionHelper };
-export { clearCachedFiles } from './clearCachedFiles.js';
+export { clearCachedFiles, clearCaches } from './clearCachedFiles.js';
 export { getDictionary } from './getDictionary.js';
+export type { PerfTimer } from './perf/index.js';
+export { createPerfTimer } from './perf/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -5,7 +5,7 @@ export { fileToDocument, fileToTextDocument, isBinaryFile } from './Document/ind
 export { FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags/index.js';
 export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesForExt } from './LanguageIds.js';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument.js';
-export { calcOverrideSettings, checkFilenameMatchesGlob, clearCachedSettingsFiles, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettings, getDefaultSettings, getGlobalSettings, getSources, ImportError, loadConfig, loadPnP, loadPnPSync, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Settings/index.js';
+export { calcOverrideSettings, checkFilenameMatchesGlob, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
 export { determineFinalDocumentSettings, spellCheckDocument, spellCheckFile, } from './spellCheckFile.js';
@@ -20,6 +20,7 @@ export * from '@cspell/cspell-types';
 export { asyncIterableToArray, readFileText as readFile, readFileTextSync as readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from 'cspell-io';
 export { Link, Text };
 export { ExclusionHelper };
-export { clearCachedFiles } from './clearCachedFiles.js';
+export { clearCachedFiles, clearCaches } from './clearCachedFiles.js';
 export { getDictionary } from './getDictionary.js';
+export { createPerfTimer } from './perf/index.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/perf/index.d.ts

@@ -0,0 +1,3 @@
+export type { PerfTimer } from './timer.js';
+export { createPerfTimer } from './timer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/perf/index.js

@@ -0,0 +1,2 @@
+export { createPerfTimer } from './timer.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/perf/perf.d.ts

@@ -0,0 +1,14 @@
+declare class PerfMonitor {
+    private _performance;
+    private _enabled;
+    constructor(_performance?: Performance);
+    mark(name: string): void;
+    measure(name: string, startMark: string, endMark: string): void;
+    clearMarks(name?: string): void;
+    clearMeasures(name?: string): void;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+}
+export declare const perf: PerfMonitor;
+export {};
+//# sourceMappingURL=perf.d.ts.map

package/dist/esm/perf/perf.js

@@ -0,0 +1,27 @@
+class PerfMonitor {
+    _performance;
+    _enabled = false;
+    constructor(_performance = performance) {
+        this._performance = _performance;
+    }
+    mark(name) {
+        this._enabled && this._performance.mark(name);
+    }
+    measure(name, startMark, endMark) {
+        this._enabled && this._performance.measure(name, startMark, endMark);
+    }
+    clearMarks(name) {
+        this._enabled && this._performance.clearMarks(name);
+    }
+    clearMeasures(name) {
+        this._enabled && this._performance.clearMeasures(name);
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+    }
+}
+export const perf = new PerfMonitor();
+//# sourceMappingURL=perf.js.map

package/dist/esm/perf/timer.d.ts

@@ -0,0 +1,11 @@
+export interface PerfTimer {
+    readonly name: string;
+    readonly startTime: number;
+    readonly elapsed: number;
+    start(): void;
+    end(): void;
+}
+type TimeNowFn = () => number;
+export declare function createPerfTimer(name: string, onEnd?: (elapsed: number, name: string) => void, timeNowFn?: TimeNowFn): PerfTimer;
+export {};
+//# sourceMappingURL=timer.d.ts.map

package/dist/esm/perf/timer.js

@@ -0,0 +1,37 @@
+// Symbol.dispose ??= Symbol('Symbol.dispose');
+// Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
+export function createPerfTimer(name, onEnd, timeNowFn) {
+    return new SimpleTimer(name, onEnd, timeNowFn);
+}
+class SimpleTimer {
+    name;
+    onEnd;
+    timeNowFn;
+    _start = performance.now();
+    _elapsed = undefined;
+    _running = true;
+    constructor(name, onEnd, timeNowFn = performance.now) {
+        this.name = name;
+        this.onEnd = onEnd;
+        this.timeNowFn = timeNowFn;
+    }
+    get startTime() {
+        return this._start;
+    }
+    get elapsed() {
+        return this._elapsed ?? performance.now() - this._start;
+    }
+    end() {
+        if (!this._running)
+            return;
+        this._running = false;
+        const end = performance.now();
+        this._elapsed = end - this._start;
+        this.onEnd?.(this._elapsed, this.name);
+    }
+    start() {
+        this._start = performance.now();
+        this._running = true;
+    }
+}
+//# sourceMappingURL=timer.js.map