cspell 9.1.5 → 9.2.0

package/dist/esm/app.d.ts

@@ -15,5 +15,5 @@ declare class ApplicationError extends Error {
 //#region src/app.d.mts
 declare function run(command?: Command, argv?: string[]): Promise<void>;
 //#endregion
-export { ApplicationError, CheckFailed, LinterCliOptions as Options, run };
+export { ApplicationError, CheckFailed, type LinterCliOptions as Options, run };
 //# sourceMappingURL=app.d.ts.map

package/dist/esm/app.js

@@ -1,4 +1,4 @@
-import { ApplicationError, CheckFailed, DEFAULT_CACHE_LOCATION, IncludeExcludeFlag, ReportChoicesAll, checkText, console, createInit, lint, listDictionaries, npmPackage, parseApplicationFeatureFlags, suggestions, trace } from "./application-D-NwS6qb.js";
+import { ApplicationError, CheckFailed, DEFAULT_CACHE_LOCATION, IncludeExcludeFlag, ReportChoicesAll, checkText, console, createInit, lint, listDictionaries, npmPackage, parseApplicationFeatureFlags, suggestions, trace } from "./application-_MFvh02K.js";
 import { Option, program } from "commander";
 import { satisfies } from "semver";
 import chalk from "chalk";
@@ -323,16 +323,16 @@ function decorateRowWith(row, ...decorators) {
 
 //#endregion
 //#region src/emitters/helpers.ts
-function trimMidPath(s, w, sep) {
+function trimMidPath(s, w, sep$1) {
 	if (s.length <= w) return s;
-	const parts = s.split(sep);
+	const parts = s.split(sep$1);
 	if (parts[parts.length - 1].length > w) return trimMid(s, w);
 	function join(left$1, right$1) {
 		return [
 			...parts.slice(0, left$1),
 			"…",
 			...parts.slice(right$1)
-		].join(sep);
+		].join(sep$1);
 	}
 	let left = 0, right = parts.length, last = "";
 	for (let i = 0; i < parts.length; ++i) {

package/dist/esm/{application-DbOQYm56.d.ts → application-D8WjsMdV.d.ts}

@@ -112,5 +112,5 @@ declare function suggestions(words: string[], options: SuggestionOptions): Async
 declare function createInit(options: InitOptions): Promise<void>;
 declare function parseApplicationFeatureFlags(flags: string[] | undefined): FeatureFlags;
 //#endregion
-export { AppError, CheckTextResult, IncludeExcludeFlag, TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };
-//# sourceMappingURL=application-DbOQYm56.d.ts.map
+export { AppError, CheckTextResult, IncludeExcludeFlag, type TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };
+//# sourceMappingURL=application-D8WjsMdV.d.ts.map

package/dist/esm/{application-D-NwS6qb.js → application-_MFvh02K.js}

@@ -5,27 +5,25 @@ import * as cspell from "cspell-lib";
 import { ENV_CSPELL_GLOB_ROOT, IncludeExcludeFlag, SuggestionError, Text, checkTextDocument, combineTextAndLanguageSettings, createPerfTimer, extractDependencies, extractImportErrors, fileToDocument, getDefaultSettings, getDictionary, getGlobalSettingsAsync, getSystemFeatureFlags, isBinaryFile, isSpellingDictionaryLoadError, mergeSettings, setLogger, shouldCheckDocument, spellCheckDocument, suggestionsForWords, traceWordsAsync } from "cspell-lib";
 import assert from "node:assert";
 import { format, formatWithOptions } from "node:util";
-import { toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from "@cspell/url";
+import { isUrlLike, toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from "@cspell/url";
 import { makeTemplate } from "chalk-template";
 import fs, { stat } from "node:fs/promises";
 import { MutableCSpellConfigFile, createReaderWriter, cspellConfigFileSchema, isCfgArrayNode } from "cspell-config-lib";
-import * as fs$1 from "node:fs";
-import { mkdirSync, promises } from "node:fs";
+import { promises } from "node:fs";
 import { fileURLToPath } from "node:url";
 import * as path$1 from "node:path";
-import path, { dirname, isAbsolute, posix, relative, resolve } from "node:path";
+import path, { isAbsolute, posix, relative, resolve, sep } from "node:path";
 import { opMap as opMap$1, pipe } from "@cspell/cspell-pipe/sync";
 import { IssueType, MessageTypes, unknownWordsChoices } from "@cspell/cspell-types";
 import { _debug } from "cspell-dictionary";
 import { GitIgnore, findRepoRoot } from "cspell-gitignore";
 import { GlobMatcher, fileOrGlobToGlob, workaroundPicomatchBug } from "cspell-glob";
-import * as crypto from "node:crypto";
+import crypto from "node:crypto";
 import streamConsumers from "node:stream/consumers";
 import { readFileText, toURL } from "cspell-io";
 import { glob } from "tinyglobby";
 import * as readline from "node:readline";
-import { isMainThread } from "node:worker_threads";
-import fileEntryCache from "file-entry-cache";
+import { parse, stringify } from "flatted";
 import { dynamicImport } from "@cspell/dynamic-import";
 
 //#region src/console.ts
@@ -791,7 +789,7 @@ const pkgDir = _dirname;
 //#endregion
 //#region src/pkgInfo.ts
 const name = "cspell";
-const version$1 = "9.1.5";
+const version$1 = "9.2.0";
 const engines = { node: ">=20" };
 const npmPackage = {
 	name,
@@ -813,6 +811,7 @@ const STDIN = "stdin";
 const STDINProtocol = "stdin:";
 const STDINUrlPrefix = "stdin://";
 const FileUrlPrefix = "file://";
+const FileUrlAbsPrefix = "file:///";
 
 //#endregion
 //#region src/util/glob.ts
@@ -972,7 +971,7 @@ function resolveStdinUrl(url, cwd) {
 	assert(url.startsWith(STDINProtocol), `Expected url to start with ${STDINProtocol}`);
 	const path$2 = decodeURIComponent(url).slice(STDINProtocol.length).replace(/^\/\//, "").replace(/^\/([a-z]:)/i, "$1");
 	const fileUrl = toFileURL(path$2, cwd);
-	return fileUrl.toString().replace(/^file:/, STDINProtocol) + (path$2 ? "" : "/");
+	return new URL(fileUrl.toString().replace(/^file:/, STDINProtocol) + (path$2 ? "" : "/"));
 }
 
 //#endregion
@@ -1005,15 +1004,17 @@ function isBinaryFile$1(filename, cwd) {
 	if (uri.protocol.startsWith("stdin")) return false;
 	return isBinaryFile(uri);
 }
+function resolveFilenameToUrl(filename, cwd) {
+	if (filename instanceof URL) return filename;
+	if (filename === STDIN) return new URL(STDINUrlPrefix);
+	if (filename.startsWith(FileUrlAbsPrefix)) return new URL(filename);
+	const cwdUrl = toFileDirURL(cwd || process.cwd());
+	if (filename.startsWith(FileUrlPrefix)) return new URL(filename.slice(FileUrlPrefix.length), cwdUrl);
+	if (isStdinUrl(filename)) return resolveStdinUrl(filename, cwdUrl);
+	return toFileURL(filename, cwdUrl);
+}
 function resolveFilename(filename, cwd) {
-	cwd = cwd || process.cwd();
-	if (filename === STDIN) return STDINUrlPrefix;
-	if (filename.startsWith(FileUrlPrefix)) {
-		const url = new URL(filename.slice(FileUrlPrefix.length), toFileDirURL(cwd));
-		return fileURLToPath(url);
-	}
-	if (isStdinUrl(filename)) return resolveStdinUrl(filename, cwd);
-	return path$1.resolve(cwd, filename);
+	return toFilePathOrHref(resolveFilenameToUrl(filename, cwd));
 }
 function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
 	filename = resolveFilename(filename);
@@ -1114,78 +1115,237 @@ function relativeToCwd(filename, cwd = process.cwd()) {
 }
 
 //#endregion
-//#region src/util/cache/file-entry-cache.mts
-function createFromFile$1(pathToCache, useChecksum) {
-	return fileEntryCache.createFromFile(pathToCache, useChecksum);
+//#region src/util/cache/file-entry-cache/flatCache.ts
+var FlatCache = class {
+	#cache;
+	constructor(cacheFilename) {
+		this.cacheFilename = cacheFilename;
+		this.#cache = /* @__PURE__ */ new Map();
+	}
+	keys() {
+		return this.#cache.keys();
+	}
+	set(key, value) {
+		this.#cache.set(key, value);
+		return this;
+	}
+	removeKey(key) {
+		this.#cache.delete(key);
+	}
+	get(key) {
+		return this.#cache.get(key);
+	}
+	async load(ifFound = true) {
+		this.#cache.clear();
+		try {
+			const content = await fs.readFile(this.cacheFilename, "utf8");
+			this.#cache = new Map(Object.entries(parse(content)));
+		} catch (error) {
+			if (!ifFound) throw error;
+		}
+		return this;
+	}
+	async save() {
+		const dir = new URL(".", this.cacheFilename);
+		await fs.mkdir(dir, { recursive: true });
+		const content = stringify(Object.fromEntries(this.#cache.entries()));
+		await fs.writeFile(this.cacheFilename, content, "utf8");
+	}
+	/**
+	* Clear the cache and remove the cache file from disk.
+	*/
+	async destroy() {
+		this.#cache.clear();
+		try {
+			await fs.unlink(this.cacheFilename);
+		} catch {}
+	}
+};
+/**
+*
+* @param cachefile - The location of the cache file.
+* @returns
+*/
+function loadCacheFile(cachefile) {
+	const cache = new FlatCache(cachefile);
+	return cache.load();
 }
 
 //#endregion
-//#region src/util/cache/fileEntryCache.ts
-function createFromFile(pathToCache, useCheckSum, useRelative) {
-	const absPathToCache = path$1.resolve(pathToCache);
-	const relDir = path$1.dirname(absPathToCache);
-	mkdirSync(relDir, { recursive: true });
-	const create = wrap(() => createFromFile$1(absPathToCache, useCheckSum));
-	const feCache = create();
-	const cacheWrapper = {
-		get cache() {
-			return feCache.cache;
-		},
-		getHash(buffer) {
-			return feCache.getHash(buffer);
-		},
-		hasFileChanged: wrap((cwd, file) => {
-			return feCache.hasFileChanged(resolveFile(cwd, file));
-		}),
-		analyzeFiles: wrap((cwd, files) => {
-			return feCache.analyzeFiles(resolveFiles(cwd, files));
-		}),
-		getFileDescriptor: wrap((cwd, file) => {
-			return feCache.getFileDescriptor(resolveFile(cwd, file));
-		}),
-		getUpdatedFiles: wrap((cwd, files) => {
-			return feCache.getUpdatedFiles(resolveFiles(cwd, files));
-		}),
-		normalizeEntries: wrap((cwd, files) => {
-			return feCache.normalizeEntries(resolveFiles(cwd, files));
-		}),
-		removeEntry: wrap((cwd, file) => {
-			return feCache.removeEntry(resolveFile(cwd, file));
-		}),
-		deleteCacheFile() {
-			feCache.deleteCacheFile();
-		},
-		destroy() {
-			feCache.destroy();
-		},
-		reconcile: wrap((_cwd, noPrune) => {
-			feCache.reconcile(noPrune);
-		})
-	};
-	return cacheWrapper;
-	function resolveFile(cwd, file) {
-		if (!useRelative) return normalizePath(file);
-		const r = path$1.relative(relDir, path$1.resolve(cwd, file));
-		return normalizePath(r);
-	}
-	function resolveFiles(cwd, files) {
-		return files?.map((file) => resolveFile(cwd, file));
-	}
-	function wrap(fn) {
-		return (...params) => {
-			const cwd = process.cwd();
-			try {
-				isMainThread && process.chdir(relDir);
-				return fn(cwd, ...params);
-			} finally {
-				isMainThread && process.chdir(cwd);
-			}
+//#region src/util/cache/file-entry-cache/file-entry-cache.ts
+async function createFromFile$1(cacheFileUrl, useChecksum, currentWorkingDir) {
+	const cache = await loadCacheFile(cacheFileUrl);
+	const fec = new ImplFileEntryCache(cache, useChecksum ?? false, currentWorkingDir);
+	await fec.removeNotFoundFiles();
+	return fec;
+}
+var ImplFileEntryCache = class {
+	cache;
+	useChecksum;
+	#normalizedEntries = /* @__PURE__ */ new Map();
+	/**
+	* To enable relative paths as the key with current working directory
+	*/
+	currentWorkingDir;
+	constructor(cache, useChecksum, currentWorkingDir) {
+		this.cache = cache;
+		this.useChecksum = useChecksum || false;
+		this.currentWorkingDir = currentWorkingDir ? fileURLToPath(currentWorkingDir) : void 0;
+	}
+	async removeNotFoundFiles() {
+		for (const fPath of this.cache.keys()) try {
+			const filePath = this.resolveKeyToFile(fPath);
+			await fs.stat(filePath);
+		} catch (error) {
+			if (isNodeError(error) && error.code === "ENOENT") this.cache.removeKey(fPath);
+		}
+	}
+	/**
+	* Given a buffer, calculate md5 hash of its content.
+	* @param  buffer buffer to calculate hash on
+	* @return content hash digest
+	*/
+	#getHash(buffer) {
+		return crypto.createHash("md5").update(buffer).digest("hex");
+	}
+	async getFileDescriptor(file) {
+		let fstat;
+		try {
+			fstat = await fs.stat(file);
+		} catch (error) {
+			this.#removeEntry(file);
+			return {
+				key: file,
+				notFound: true,
+				err: toError$1(error)
+			};
+		}
+		if (this.useChecksum) return this.#getFileDescriptorUsingChecksum(file);
+		return this.#getFileDescriptorUsingMtimeAndSize(file, fstat);
+	}
+	#getFileDescriptorUsingMtimeAndSize(file, fstat) {
+		const key = this.#getFileKey(file);
+		let meta = this.cache.get(key);
+		const cacheExists = !!meta;
+		const cSize = fstat.size;
+		const cTime = fstat.mtime.getTime();
+		let isDifferentDate;
+		let isDifferentSize;
+		if (meta) {
+			isDifferentDate = cTime !== meta.mtime;
+			isDifferentSize = cSize !== meta.size;
+		} else meta = {
+			size: cSize,
+			mtime: cTime
 		};
+		const nEntry = {
+			key,
+			changed: !cacheExists || isDifferentDate || isDifferentSize,
+			meta
+		};
+		this.#normalizedEntries.set(key, nEntry);
+		return nEntry;
+	}
+	async #getFileDescriptorUsingChecksum(file) {
+		const key = this.#getFileKey(file);
+		let meta = this.cache.get(key);
+		const cacheExists = !!meta;
+		let contentBuffer;
+		try {
+			contentBuffer = await fs.readFile(file);
+		} catch {
+			contentBuffer = "";
+		}
+		let isDifferent = true;
+		const hash = this.#getHash(contentBuffer);
+		if (meta) isDifferent = hash !== meta.hash;
+		else meta = { hash };
+		const nEntry = {
+			key,
+			changed: !cacheExists || isDifferent,
+			meta
+		};
+		this.#normalizedEntries.set(key, nEntry);
+		return nEntry;
+	}
+	/**
+	* Remove an entry from the file-entry-cache. Useful to force the file to still be considered
+	* modified the next time the process is run
+	*/
+	#removeEntry(file) {
+		const key = this.#getFileKey(file);
+		this.#normalizedEntries.delete(key);
+		this.cache.removeKey(key);
+	}
+	/**
+	* Deletes the cache file from the disk and clears the memory cache
+	*/
+	async destroy() {
+		this.#normalizedEntries.clear();
+		await this.cache.destroy();
+	}
+	async #getMetaForFileUsingCheckSum(cacheEntry) {
+		const filePath = this.resolveKeyToFile(cacheEntry.key);
+		const contentBuffer = await fs.readFile(filePath);
+		const hash = this.#getHash(contentBuffer);
+		const meta = {
+			...cacheEntry.meta,
+			hash
+		};
+		delete meta.size;
+		delete meta.mtime;
+		return meta;
+	}
+	async #getMetaForFileUsingMtimeAndSize(cacheEntry) {
+		const filePath = this.resolveKeyToFile(cacheEntry.key);
+		const stat$1 = await fs.stat(filePath);
+		const meta = {
+			...cacheEntry.meta,
+			size: stat$1.size,
+			mtime: stat$1.mtime.getTime()
+		};
+		delete meta.hash;
+		return meta;
+	}
+	/**
+	* Sync the files and persist them to the cache
+	*/
+	async reconcile() {
+		await this.removeNotFoundFiles();
+		for (const [entryKey, cacheEntry] of this.#normalizedEntries.entries()) try {
+			const meta = this.useChecksum ? await this.#getMetaForFileUsingCheckSum(cacheEntry) : await this.#getMetaForFileUsingMtimeAndSize(cacheEntry);
+			this.cache.set(entryKey, meta);
+		} catch (error) {
+			if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+		}
+		this.cache.save();
 	}
+	resolveKeyToFile(entryKey) {
+		if (this.currentWorkingDir) return path.resolve(this.currentWorkingDir, entryKey);
+		return entryKey;
+	}
+	#getFileKey(file) {
+		if (this.currentWorkingDir && path.isAbsolute(file)) return normalizePath$1(path.relative(this.currentWorkingDir, file));
+		return normalizePath$1(file);
+	}
+};
+function isNodeError(error) {
+	return typeof error === "object" && error !== null && "code" in error;
 }
-function normalizePath(filePath) {
-	if (path$1.sep === "/") return filePath;
-	return filePath.split(path$1.sep).join("/");
+function toError$1(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	return new Error("Unknown error", { cause: error });
+}
+function normalizePath$1(filePath) {
+	if (path.sep === "/") return filePath;
+	return filePath.split(path.sep).join("/");
+}
+
+//#endregion
+//#region src/util/cache/fileEntryCache.ts
+function createFromFile(cacheFileUrl, useCheckSum, useRelative) {
+	return createFromFile$1(cacheFileUrl, useCheckSum, useRelative ? new URL("./", cacheFileUrl) : void 0);
 }
 
 //#endregion
@@ -1230,31 +1390,29 @@ const META_DATA_VERSION_SUFFIX = "-" + META_DATA_BASE_VERSION + "-" + Object.key
 * Caches cspell results on disk
 */
 var DiskCache = class {
-	cacheFileLocation;
 	cacheDir;
-	fileEntryCache;
 	dependencyCache = /* @__PURE__ */ new Map();
 	dependencyCacheTree = {};
 	objectCollection = new ShallowObjectCollection();
 	ocCacheFileResult = new ShallowObjectCollection();
 	version;
-	constructor(cacheFileLocation, useCheckSum, cspellVersion, useUniversalCache) {
+	constructor(cacheFileLocation, useCheckSum, cspellVersion, useUniversalCache, fileEntryCache) {
+		this.cacheFileLocation = cacheFileLocation;
 		this.useCheckSum = useCheckSum;
 		this.cspellVersion = cspellVersion;
 		this.useUniversalCache = useUniversalCache;
-		this.cacheFileLocation = resolve(cacheFileLocation);
-		this.cacheDir = dirname(this.cacheFileLocation);
-		this.fileEntryCache = createFromFile(this.cacheFileLocation, useCheckSum, useUniversalCache);
+		this.fileEntryCache = fileEntryCache;
+		this.cacheDir = fileURLToPath(new URL("./", cacheFileLocation));
 		this.version = calcVersion(cspellVersion);
 	}
 	async getCachedLintResults(filename) {
 		filename = normalizePath(filename);
-		const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
+		const fileDescriptor = await this.fileEntryCache.getFileDescriptor(filename);
 		const meta = fileDescriptor.meta;
 		const data = meta?.data;
 		const result = data?.r;
 		const versionMatches = this.version === data?.v;
-		if (fileDescriptor.notFound || fileDescriptor.changed || !meta || !result || !versionMatches || !this.checkDependencies(data.d)) return void 0;
+		if (fileDescriptor.notFound || fileDescriptor.changed || !meta || !result || !versionMatches || !await this.checkDependencies(data.d)) return void 0;
 		const dd = { ...data };
 		if (dd.d) dd.d = setTreeEntry(this.dependencyCacheTree, dd.d);
 		dd.r = dd.r && this.normalizeResult(dd.r);
@@ -1269,22 +1427,22 @@ var DiskCache = class {
 			cached
 		};
 	}
-	setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __,...result }, dependsUponFiles) {
-		const fileDescriptor = this.fileEntryCache.getFileDescriptor(fileInfo.filename);
+	async setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __,...result }, dependsUponFiles) {
+		const fileDescriptor = await this.fileEntryCache.getFileDescriptor(fileInfo.filename);
 		const meta = fileDescriptor.meta;
 		if (fileDescriptor.notFound || !meta) return;
 		const data = this.objectCollection.get({
 			v: this.version,
 			r: this.normalizeResult(result),
-			d: this.calcDependencyHashes(dependsUponFiles)
+			d: await this.calcDependencyHashes(dependsUponFiles)
 		});
 		meta.data = data;
 	}
-	reconcile() {
-		this.fileEntryCache.reconcile();
+	async reconcile() {
+		await this.fileEntryCache.reconcile();
 	}
-	reset() {
-		this.fileEntryCache.destroy();
+	async reset() {
+		await this.fileEntryCache.destroy();
 		this.dependencyCache.clear();
 		this.dependencyCacheTree = {};
 		this.objectCollection = new ShallowObjectCollection();
@@ -1301,19 +1459,19 @@ var DiskCache = class {
 			reportIssueOptions
 		});
 	}
-	calcDependencyHashes(dependsUponFiles) {
+	async calcDependencyHashes(dependsUponFiles) {
 		dependsUponFiles.sort();
 		const c = getTreeEntry(this.dependencyCacheTree, dependsUponFiles);
 		if (c?.d) return c.d;
-		const dependencies = dependsUponFiles.map((f) => this.getDependency(f));
+		const dependencies = await Promise.all(dependsUponFiles.map((f) => this.getDependency(f)));
 		return setTreeEntry(this.dependencyCacheTree, dependencies);
 	}
-	checkDependency(dep) {
+	async checkDependency(dep) {
 		const depFile = this.resolveFile(dep.f);
 		const cDep = this.dependencyCache.get(depFile);
 		if (cDep && compDep(dep, cDep)) return true;
 		if (cDep) return false;
-		const d = this.getFileDep(depFile);
+		const d = await this.getFileDep(depFile);
 		if (compDep(dep, d)) {
 			this.dependencyCache.set(depFile, dep);
 			return true;
@@ -1321,19 +1479,23 @@ var DiskCache = class {
 		this.dependencyCache.set(depFile, d);
 		return false;
 	}
-	getDependency(file) {
+	async getDependency(file) {
 		const dep = this.dependencyCache.get(file);
 		if (dep) return dep;
-		const d = this.getFileDep(file);
+		const d = await this.getFileDep(file);
 		this.dependencyCache.set(file, d);
 		return d;
 	}
-	getFileDep(file) {
+	async getFileDep(file) {
+		if (isUrlLike(file)) {
+			if (!file.startsWith("file://")) return getDependencyForUrl(file);
+			file = toFilePathOrHref(file);
+		}
 		assert(isAbsolute(file), `Dependency must be absolute "${file}"`);
 		const f = this.toRelFile(file);
 		let h;
 		try {
-			const buffer = fs$1.readFileSync(file);
+			const buffer = await fs.readFile(file);
 			h = this.getHash(buffer);
 		} catch {
 			return { f };
@@ -1343,21 +1505,43 @@ var DiskCache = class {
 			h
 		};
 	}
-	checkDependencies(dependencies) {
+	async checkDependencies(dependencies) {
 		if (!dependencies) return false;
-		for (const dep of dependencies) if (!this.checkDependency(dep)) return false;
+		for (const dep of dependencies) if (!await this.checkDependency(dep)) return false;
 		return true;
 	}
 	getHash(buffer) {
 		return crypto.createHash("md5").update(buffer).digest("hex");
 	}
 	resolveFile(file) {
+		if (isUrlLike(file)) return file;
 		return normalizePath(resolve(this.cacheDir, file));
 	}
 	toRelFile(file) {
 		return normalizePath(this.useUniversalCache ? relative(this.cacheDir, file) : file);
 	}
 };
+async function getDependencyForUrl(remoteUrl) {
+	const url = new URL(remoteUrl);
+	try {
+		const response = await fetch(url, { method: "HEAD" });
+		const h = response.headers.get("etag") || response.headers.get("last-modified") || response.headers.get("content-length") || "";
+		return {
+			f: url.href,
+			h: h ? h.trim() : ""
+		};
+	} catch {
+		return {
+			f: url.href,
+			h: ""
+		};
+	}
+}
+async function createDiskCache(cacheFileLocation, useCheckSum, cspellVersion, useUniversalCache) {
+	const fileEntryCache = await createFromFile(cacheFileLocation, useCheckSum, useUniversalCache);
+	const cache = new DiskCache(cacheFileLocation, useCheckSum, cspellVersion, useUniversalCache, fileEntryCache);
+	return cache;
+}
 function getTreeEntry(tree, keys) {
 	let r = tree;
 	for (const k of keys) {
@@ -1389,6 +1573,10 @@ function compDep(a, b) {
 function calcVersion(version$2) {
 	return version$2 + META_DATA_VERSION_SUFFIX;
 }
+function normalizePath(filePath) {
+	if (sep === "/") return filePath;
+	return filePath.split(sep).join("/");
+}
 
 //#endregion
 //#region src/util/cache/DummyCache.ts
@@ -1400,13 +1588,13 @@ var DummyCache = class {
 		return Promise.resolve(void 0);
 	}
 	setCachedLintResults() {
-		return;
+		return Promise.resolve();
 	}
 	reconcile() {
-		return;
+		return Promise.resolve();
 	}
 	reset() {
-		return;
+		return Promise.resolve();
 	}
 };
 
@@ -1417,14 +1605,14 @@ const versionSuffix = "";
 /**
 * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
 */
-function createCache(options) {
+async function createCache(options) {
 	const { useCache, cacheLocation, cacheStrategy, reset } = options;
-	const location = path.resolve(cacheLocation);
+	const location = toFileURL(cacheLocation);
 	const useChecksum = cacheStrategy === "content";
 	const version$2 = normalizeVersion(options.version);
 	const useUniversal = options.cacheFormat === "universal";
-	const cache = useCache ? new DiskCache(location, useChecksum, version$2, useUniversal) : new DummyCache();
-	reset && cache.reset();
+	const cache = useCache ? await createDiskCache(location, useChecksum, version$2, useUniversal) : new DummyCache();
+	if (reset) await cache.reset();
 	return cache;
 }
 async function calcCacheSettings(config, cacheOptions, root) {
@@ -1796,7 +1984,7 @@ async function runLint(cfg) {
 			result: Promise.resolve({ skip: true })
 		};
 		const reportIssueOptions = extractReporterIssueOptions(configInfo.config);
-		async function fetch() {
+		async function fetch$1() {
 			const getElapsedTimeMs = getTimeMeasurer();
 			const cachedResult = await cache.getCachedLintResults(filename);
 			if (cachedResult) {
@@ -1816,7 +2004,7 @@ async function runLint(cfg) {
 				reportIssueOptions
 			};
 		}
-		const result = fetch();
+		const result = fetch$1();
 		return {
 			filename,
 			result
@@ -1902,7 +2090,7 @@ async function runLint(cfg) {
 			reporter.debug(JSON.stringify(debugCfg, void 0, 2));
 		}
 		const dep = calcDependencies(config);
-		cache.setCachedLintResults(result, dep.files);
+		await cache.setCachedLintResults(result, dep.files);
 		return result;
 	}
 	function mapIssue({ doc: _,...tdo }) {
@@ -1915,7 +2103,7 @@ async function runLint(cfg) {
 	async function processFiles(files, configInfo, cacheSettings) {
 		const fileCount = Array.isArray(files) ? files.length : void 0;
 		const status = runResult();
-		const cache = createCache(cacheSettings);
+		const cache = await createCache(cacheSettings);
 		const failFast = cfg.options.failFast ?? configInfo.config.failFast ?? false;
 		function* prefetchFiles(files$1) {
 			const iter = prefetchIterable(pipe(files$1, opMap$1((filename) => prefetch(filename, configInfo, cache))), BATCH_SIZE);
@@ -1975,7 +2163,7 @@ async function runLint(cfg) {
 			}
 			status.errors += result.configErrors;
 		}
-		cache.reconcile();
+		await cache.reconcile();
 		return status;
 	}
 	function calcDependencies(config) {
@@ -2570,4 +2758,4 @@ function parseApplicationFeatureFlags(flags) {
 
 //#endregion
 export { ApplicationError, CheckFailed, DEFAULT_CACHE_LOCATION, IncludeExcludeFlag, ReportChoicesAll, checkText, console, createInit, getReporter, lint, listDictionaries, npmPackage, parseApplicationFeatureFlags, suggestions, trace };
-//# sourceMappingURL=application-D-NwS6qb.js.map
+//# sourceMappingURL=application-_MFvh02K.js.map

package/dist/esm/application.d.ts

@@ -1,3 +1,3 @@
 import "./options-ChaXtdFn.js";
-import { AppError, CheckTextResult, IncludeExcludeFlag, TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-DbOQYm56.js";
+import { AppError, CheckTextResult, IncludeExcludeFlag, TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-D8WjsMdV.js";
 export { AppError, CheckTextResult, IncludeExcludeFlag, TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };

package/dist/esm/application.js

@@ -1,3 +1,3 @@
-import { IncludeExcludeFlag, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-D-NwS6qb.js";
+import { IncludeExcludeFlag, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-_MFvh02K.js";
 
 export { IncludeExcludeFlag, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };

package/dist/esm/index.d.ts

@@ -1,5 +1,5 @@
 import { BaseOptions, LinterCliOptions, TraceOptions } from "./options-ChaXtdFn.js";
-import { AppError, CheckTextResult, IncludeExcludeFlag, TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-DbOQYm56.js";
+import { AppError, CheckTextResult, IncludeExcludeFlag, TraceResult, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-D8WjsMdV.js";
 import "chalk";
 import { CSpellReporter, CSpellSettings, ReporterConfiguration, RunResult } from "@cspell/cspell-types";
 import { WriteStream } from "node:tty";
@@ -51,5 +51,5 @@ interface ReporterOptions extends Pick<LinterCliOptions, "color" | "debug" | "is
 }
 declare function getReporter(options: ReporterOptions, config?: CSpellReporterConfiguration): FinalizedReporter;
 //#endregion
-export { AppError, BaseOptions, LinterCliOptions as CSpellApplicationOptions, CSpellReporterConfiguration, CSpellReporterModule, CheckTextResult, IncludeExcludeFlag, TraceOptions, TraceResult, checkText, createInit, getReporter as getDefaultReporter, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };
+export { AppError, type BaseOptions, type LinterCliOptions as CSpellApplicationOptions, type CSpellReporterConfiguration, type CSpellReporterModule, CheckTextResult, IncludeExcludeFlag, type TraceOptions, TraceResult, checkText, createInit, getReporter as getDefaultReporter, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { IncludeExcludeFlag, checkText, createInit, getReporter, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-D-NwS6qb.js";
+import { IncludeExcludeFlag, checkText, createInit, getReporter, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace } from "./application-_MFvh02K.js";
 
 export * from "@cspell/cspell-types"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "9.1.5",
+  "version": "9.2.0",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "bin": {
@@ -83,22 +83,22 @@
   },
   "homepage": "https://cspell.org/",
   "dependencies": {
-    "@cspell/cspell-json-reporter": "9.1.5",
-    "@cspell/cspell-pipe": "9.1.5",
-    "@cspell/cspell-types": "9.1.5",
-    "@cspell/dynamic-import": "9.1.5",
-    "@cspell/url": "9.1.5",
+    "@cspell/cspell-json-reporter": "9.2.0",
+    "@cspell/cspell-pipe": "9.2.0",
+    "@cspell/cspell-types": "9.2.0",
+    "@cspell/dynamic-import": "9.2.0",
+    "@cspell/url": "9.2.0",
     "chalk": "^5.4.1",
     "chalk-template": "^1.1.0",
     "commander": "^14.0.0",
-    "cspell-config-lib": "9.1.5",
-    "cspell-dictionary": "9.1.5",
-    "cspell-gitignore": "9.1.5",
-    "cspell-glob": "9.1.5",
-    "cspell-io": "9.1.5",
-    "cspell-lib": "9.1.5",
+    "cspell-config-lib": "9.2.0",
+    "cspell-dictionary": "9.2.0",
+    "cspell-gitignore": "9.2.0",
+    "cspell-glob": "9.2.0",
+    "cspell-io": "9.2.0",
+    "cspell-lib": "9.2.0",
     "fast-json-stable-stringify": "^2.1.0",
-    "file-entry-cache": "^9.1.0",
+    "flatted": "^3.3.3",
     "semver": "^7.7.2",
     "tinyglobby": "^0.2.14"
   },
@@ -106,12 +106,11 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@types/file-entry-cache": "^5.0.4",
     "@types/glob": "^8.1.0",
     "@types/micromatch": "^4.0.9",
     "@types/semver": "^7.7.0",
     "micromatch": "^4.0.8",
     "minimatch": "^9.0.5"
   },
-  "gitHead": "6303813cb5da37e88b3ccab7ce5bcf09373f5cf2"
+  "gitHead": "6004e6a19e11985bc61e6578846195be07365049"
 }