cspell 9.6.0 → 9.6.1

package/dist/esm/app.js

@@ -1,4 +1,4 @@
-import { C as CheckFailed, S as ApplicationError, _ as padLeft, a as parseApplicationFeatureFlags, b as pruneAnsiTextStart, c as listDictionaries, d as validateUnitSize, f as unindent, g as tableToLines, i as lint, l as ReportChoicesAll, m as npmPackage, n as checkText, o as suggestions, p as DEFAULT_CACHE_LOCATION, r as createInit, s as trace, t as IncludeExcludeFlag, u as cvtLinterCliCommandOptionsToLinterCliOptions, v as padWidth, w as console, x as width, y as pruneAnsiTextEnd } from "./application-BJHh60xM.js";
+import { C as CheckFailed, S as ApplicationError, _ as padLeft, a as parseApplicationFeatureFlags, b as pruneAnsiTextStart, c as listDictionaries, d as validateUnitSize, f as unindent, g as tableToLines, i as lint, l as ReportChoicesAll, m as npmPackage, n as checkText, o as suggestions, p as DEFAULT_CACHE_LOCATION, r as createInit, s as trace, t as IncludeExcludeFlag, u as cvtLinterCliCommandOptionsToLinterCliOptions, v as padWidth, w as console, x as width, y as pruneAnsiTextEnd } from "./application-DaQrXF9X.js";
 import { Link } from "cspell-lib";
 import chalk from "chalk";
 import * as iPath from "node:path";

package/dist/esm/{application-BJHh60xM.js → application-DaQrXF9X.js}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { isAsyncIterable, opFilter, opMap, opTap, operators, pipeAsync, pipeAsync as asyncPipe, toAsyncIterable, toAsyncIterable as mergeAsyncIterables } from "@cspell/cspell-pipe";
 import * as cspell from "cspell-lib";
-import { ENV_CSPELL_GLOB_ROOT, IncludeExcludeFlag, MessageTypes, SuggestionError, Text, checkTextDocument, combineTextAndLanguageSettings, createPerfTimer, extractDependencies, extractImportErrors, fileToDocument, getDefaultSettings, getDictionary, getGlobalSettingsAsync, getSystemFeatureFlags, isBinaryFile, isSpellingDictionaryLoadError, mergeSettings, setLogger, shouldCheckDocument, spellCheckDocument, suggestionsForWords, traceWordsAsync } from "cspell-lib";
+import { ENV_CSPELL_GLOB_ROOT, IncludeExcludeFlag, MessageTypes, SuggestionError, Text, checkTextDocument, combineTextAndLanguageSettings, createPerfTimer, extractDependencies, extractImportErrors, fileToDocument, getDefaultSettings, getGlobalSettingsAsync, getSystemFeatureFlags, isBinaryFile, isSpellingDictionaryLoadError, mergeSettings, setLogger, shouldCheckDocument, spellCheckDocument, suggestionsForWords, traceWordsAsync } from "cspell-lib";
 import assert from "node:assert";
 import { format, formatWithOptions, stripVTControlCharacters } from "node:util";
 import { isUrlLike, toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from "@cspell/url";
@@ -14,6 +14,7 @@ import { promises } from "node:fs";
 import { fileURLToPath } from "node:url";
 import * as path$1 from "node:path";
 import path, { isAbsolute, posix, relative, resolve, sep } from "node:path";
+import { enablePerformanceMeasurements, measurePerf } from "@cspell/cspell-performance-monitor";
 import { opMap as opMap$1, pipe } from "@cspell/cspell-pipe/sync";
 import { IssueType, MessageTypes as MessageTypes$1, unknownWordsChoices } from "@cspell/cspell-types";
 import { dictionaryCacheEnableLogging, dictionaryCacheGetLog } from "cspell-dictionary";
@@ -561,7 +562,8 @@ function getReporter(options, config) {
 		filesProcessed: 0,
 		filesSkipped: 0,
 		filesCached: 0,
-		elapsedTimeMs: 0,
+		accumulatedTimeMs: 0,
+		startTime: performance.now(),
 		perf: Object.create(null)
 	};
 	const noColor = options.color === false;
@@ -639,12 +641,14 @@ function getReporter(options, config) {
 			errorCollection.forEach((error) => consoleError(error));
 		}
 		if (options.showPerfSummary) {
+			const elapsedTotal = performance.now() - perfStats.startTime;
 			consoleError("-------------------------------------------");
 			consoleError("Performance Summary:");
-			consoleError(`  Files Processed: ${perfStats.filesProcessed.toString().padStart(6)}`);
-			consoleError(`  Files Skipped  : ${perfStats.filesSkipped.toString().padStart(6)}`);
-			consoleError(`  Files Cached   : ${perfStats.filesCached.toString().padStart(6)}`);
-			consoleError(`  Processing Time: ${perfStats.elapsedTimeMs.toFixed(2).padStart(9)}ms`);
+			consoleError(`  Files Processed : ${perfStats.filesProcessed.toString().padStart(11)}`);
+			consoleError(`  Files Skipped   : ${perfStats.filesSkipped.toString().padStart(11)}`);
+			consoleError(`  Files Cached    : ${perfStats.filesCached.toString().padStart(11)}`);
+			consoleError(`  Processing Time : ${perfStats.accumulatedTimeMs.toFixed(2).padStart(9)}ms`);
+			consoleError(`  Total Time      : ${elapsedTotal.toFixed(2).padStart(9)}ms`);
 			const tableStats = {
 				title: chalk$1.bold("Perf Stats:"),
 				header: ["Name", "Time (ms)"],
@@ -726,7 +730,7 @@ function getReporter(options, config) {
 		}
 		perfStats.filesProcessed += p.processed ? 1 : 0;
 		perfStats.filesSkipped += !p.processed ? 1 : 0;
-		perfStats.elapsedTimeMs += p.elapsedTimeMs || 0;
+		perfStats.accumulatedTimeMs += p.elapsedTimeMs || 0;
 		if (!p.perf) return;
 		for (const [key, value] of Object.entries(p.perf)) if (typeof value === "number") perfStats.perf[key] = (perfStats.perf[key] || 0) + value;
 	}
@@ -1197,8 +1201,8 @@ const pkgDir = _dirname;
 //#endregion
 //#region src/pkgInfo.ts
 const name = "cspell";
-const version$1 = "9.6.0";
-const engines = { node: ">=20" };
+const version$1 = "9.6.1";
+const engines = { node: ">=20.18" };
 const npmPackage = {
 	name,
 	version: version$1,
@@ -2074,22 +2078,6 @@ async function readConfigHandleError(filename) {
 	}
 }
 
-//#endregion
-//#region src/util/prefetch.ts
-function* prefetchIterable(iterable, size) {
-	assert(size >= 0);
-	const buffer = [];
-	for (const value of iterable) {
-		buffer.push(value);
-		if (buffer.length >= size - 1) {
-			const value$1 = buffer[0];
-			buffer.shift();
-			yield value$1;
-		}
-	}
-	yield* buffer;
-}
-
 //#endregion
 //#region src/util/reporters.ts
 function filterFeatureIssues(features, issue, reportOptions) {
@@ -2311,50 +2299,6 @@ function unindentString(str) {
 	return lines.map((line) => line.slice(curPad)).join("\n");
 }
 
-//#endregion
-//#region src/util/unitNumbers.ts
-const regexUnitNumber = /^((?:\d+(?:\.\d*)?)|(?:\.\d+))([a-z]*)$/i;
-const unitSizes = {
-	"": 1,
-	b: 1,
-	k: 1024,
-	kb: 1024,
-	m: 1 << 20,
-	mb: 1 << 20,
-	g: 1 << 30,
-	gb: 1 << 30
-};
-function parseUnitSize(size) {
-	const match = size.match(regexUnitNumber);
-	const digits = match?.[1] || "";
-	const units = (match?.[2] || "").toLowerCase();
-	if (!match) return {
-		size,
-		digits,
-		units,
-		error: "Invalid size."
-	};
-	if (!units || units in unitSizes) return {
-		size,
-		digits,
-		units
-	};
-	return {
-		size,
-		digits,
-		units,
-		error: `Unknown units. Valid units are: ${Object.keys(unitSizes).filter(Boolean).join(", ").toUpperCase()}.`
-	};
-}
-function validateUnitSize(size) {
-	return parseUnitSize(size).error;
-}
-function sizeToNumber(size) {
-	const p = parseUnitSize(size);
-	if (p.error) return NaN;
-	return Number.parseFloat(p.digits) * (unitSizes[p.units] || 1);
-}
-
 //#endregion
 //#region src/util/wrap.ts
 const wrapSep = /\s+|(?<=,)|\.(?=\w)/g;
@@ -2483,11 +2427,11 @@ var LinterError = class extends Error {
 
 //#endregion
 //#region src/lint/processFile.ts
-async function processFile(filename, cache, prefetch, processFileOptions) {
-	if (prefetch?.fileResult) return prefetch.fileResult;
-	const { reporter, cfg, configInfo } = processFileOptions;
+async function processFile(filename, cache, prefetch$1, processFileOptions) {
+	if (prefetch$1?.fileResult) return prefetch$1.fileResult;
+	const { reporter, cfg, configInfo, userSettings } = processFileOptions;
 	const getElapsedTimeMs = getTimeMeasurer();
-	const reportIssueOptions = prefetch?.reportIssueOptions;
+	const reportIssueOptions = prefetch$1?.reportIssueOptions;
 	const cachedResult = await cache.getCachedLintResults(filename);
 	if (cachedResult) {
 		reporter.debug(`Filename: ${filename}, using cache`);
@@ -2509,7 +2453,7 @@ async function processFile(filename, cache, prefetch, processFileOptions) {
 		elapsedTimeMs: 0,
 		reportIssueOptions
 	};
-	const fileInfo = prefetch?.fileInfo || await readFileInfo(filename, void 0, true);
+	const fileInfo = prefetch$1?.fileInfo || await readFileInfo(filename, void 0, true);
 	if (fileInfo.errorCode) {
 		if (fileInfo.errorCode !== "EISDIR" && cfg.options.mustFindFiles) {
 			const err = new LinterError(`File not found: "${filename}"`);
@@ -2530,7 +2474,7 @@ async function processFile(filename, cache, prefetch, processFileOptions) {
 			numSuggestions,
 			validateDirectives,
 			skipValidation
-		}), configInfo.config);
+		}), userSettings);
 		spellResult = r;
 		result.processed = r.checked;
 		result.perf = r.perf ? { ...r.perf } : void 0;
@@ -2542,7 +2486,7 @@ async function processFile(filename, cache, prefetch, processFileOptions) {
 	result.elapsedTimeMs = getElapsedTimeMs();
 	const config = spellResult.settingsUsed ?? {};
 	result.reportIssueOptions = mergeReportIssueOptions(spellResult.settingsUsed || configInfo.config, reportIssueOptions);
-	result.configErrors += await reportConfigurationErrors(config, processFileOptions);
+	result.configErrors += reportSpellingResultConfigErrors(spellResult, processFileOptions);
 	reportCheckResult(result, doc, spellResult, config, processFileOptions);
 	const dep = calcDependencies(config);
 	await cache.setCachedLintResults(result, dep.files);
@@ -2587,9 +2531,11 @@ function calcDependencies(config) {
 	const { configFiles, dictionaryFiles } = extractDependencies(config);
 	return { files: [...configFiles, ...dictionaryFiles] };
 }
-async function reportConfigurationErrors(config, processFileOptions) {
+function reportConfigurationErrors(config, processFileOptions) {
+	return reportImportErrors(extractImportErrors(config), processFileOptions);
+}
+function reportImportErrors(errors, processFileOptions) {
 	const { reporter, configErrors } = processFileOptions;
-	const errors = extractImportErrors(config);
 	let count = 0;
 	errors.forEach((ref) => {
 		const key = ref.error.toString();
@@ -2598,9 +2544,14 @@ async function reportConfigurationErrors(config, processFileOptions) {
 		count += 1;
 		reporter.error("Configuration", ref.error);
 	});
-	(await getDictionary(config)).dictionaries.forEach((dict) => {
-		const dictErrors = dict.getErrors?.() || [];
-		const msg = `Dictionary Error with (${dict.name})`;
+	return count;
+}
+function reportSpellingResultConfigErrors(spellResult, processFileOptions) {
+	const { reporter, configErrors } = processFileOptions;
+	let count = reportImportErrors(spellResult.configErrors || [], processFileOptions);
+	const dictionaryErrors = [...spellResult.dictionaryErrors || []];
+	for (const [dictName, dictErrors] of dictionaryErrors) {
+		const msg = `Dictionary Error with (${dictName})`;
 		dictErrors.forEach((error) => {
 			const key = msg + error.toString();
 			if (configErrors.has(key)) return;
@@ -2608,23 +2559,300 @@ async function reportConfigurationErrors(config, processFileOptions) {
 			count += 1;
 			reporter.error(msg, error);
 		});
-	});
+	}
 	return count;
 }
 function countConfigErrors(configInfo, processFileOptions) {
 	return reportConfigurationErrors(configInfo.config, processFileOptions);
 }
 
+//#endregion
+//#region src/util/prefetch.ts
+function* prefetchIterable(iterable, size) {
+	assert(size >= 0);
+	const buffer = [];
+	for (const value of iterable) {
+		buffer.push(value);
+		if (buffer.length >= size - 1) {
+			const value$1 = buffer[0];
+			buffer.shift();
+			yield value$1;
+		}
+	}
+	yield* buffer;
+}
+
+//#endregion
+//#region src/util/unitNumbers.ts
+const regexUnitNumber = /^((?:\d+(?:\.\d*)?)|(?:\.\d+))([a-z]*)$/i;
+const unitSizes = {
+	"": 1,
+	b: 1,
+	k: 1024,
+	kb: 1024,
+	m: 1 << 20,
+	mb: 1 << 20,
+	g: 1 << 30,
+	gb: 1 << 30
+};
+function parseUnitSize(size) {
+	const match = size.match(regexUnitNumber);
+	const digits = match?.[1] || "";
+	const units = (match?.[2] || "").toLowerCase();
+	if (!match) return {
+		size,
+		digits,
+		units,
+		error: "Invalid size."
+	};
+	if (!units || units in unitSizes) return {
+		size,
+		digits,
+		units
+	};
+	return {
+		size,
+		digits,
+		units,
+		error: `Unknown units. Valid units are: ${Object.keys(unitSizes).filter(Boolean).join(", ").toUpperCase()}.`
+	};
+}
+function validateUnitSize(size) {
+	return parseUnitSize(size).error;
+}
+function sizeToNumber(size) {
+	const p = parseUnitSize(size);
+	if (p.error) return NaN;
+	return Number.parseFloat(p.digits) * (unitSizes[p.units] || 1);
+}
+
+//#endregion
+//#region src/lint/processFiles.ts
+const BATCH_FETCH_SIZE = 12;
+const BATCH_PROCESS_SIZE = 1;
+function prefetch(fileToProcess, cfg) {
+	const { filename } = fileToProcess;
+	if (isBinaryFile$1(filename, cfg.root)) return {
+		...fileToProcess,
+		result: Promise.resolve({
+			skip: true,
+			skipReason: "Binary file."
+		})
+	};
+	const reportIssueOptions = extractReporterIssueOptions(cfg.config);
+	async function fetch$1() {
+		const getElapsedTimeMs = getTimeMeasurer();
+		const cachedResult = await cfg.cache.getCachedLintResults(filename);
+		if (cachedResult) {
+			cfg.reporter.debug(`Filename: ${filename}, using cache`);
+			return { fileResult: {
+				...cachedResult,
+				elapsedTimeMs: getElapsedTimeMs()
+			} };
+		}
+		const uri = filenameToUri(filename, cfg.root).href;
+		const checkResult = await shouldCheckDocument({ uri }, {}, cfg.config);
+		if (!checkResult.shouldCheck) return {
+			skip: true,
+			skipReason: checkResult.reason || "Ignored by configuration."
+		};
+		const maxFileSize = processMaxFileSize(cfg.maxFileSize ?? checkResult.settings.maxFileSize);
+		if (maxFileSize) {
+			if (await getFileSize(filename) > maxFileSize) return {
+				skip: true,
+				skipReason: `File exceeded max file size of ${maxFileSize.toLocaleString()}`
+			};
+		}
+		return {
+			fileInfo: await readFileInfo(filename, void 0, true),
+			reportIssueOptions
+		};
+	}
+	const result = fetch$1().catch((e) => toApplicationError(e));
+	return {
+		...fileToProcess,
+		result
+	};
+}
+async function processFiles(files, options) {
+	const status = runResult();
+	const cache = await createCache(options.cacheSettings);
+	const failFast = options.cfg.options.failFast ?? options.configInfo.config.failFast ?? false;
+	const reporter = options.lintReporter;
+	const prefetchConfig = {
+		reporter,
+		root: options.cfg.root,
+		maxFileSize: options.cfg.maxFileSize,
+		config: options.configInfo.config,
+		cache
+	};
+	const processFileOptionsGeneral = {
+		reporter,
+		chalk: options.chalk,
+		configInfo: options.configInfo,
+		cfg: options.cfg,
+		verboseLevel: options.verboseLevel,
+		useColor: options.useColor,
+		configErrors: options.configErrors,
+		userSettings: options.configInfo.config
+	};
+	function* prefetchFiles(files$1) {
+		yield* prefetchIterable(pipe(files$1, opMap$1((file) => prefetch(file, prefetchConfig))), BATCH_FETCH_SIZE);
+	}
+	async function* prefetchFilesAsync(files$1) {
+		for await (const file of files$1) yield prefetch(file, prefetchConfig);
+	}
+	const emptyResult = {
+		fileInfo: { filename: "" },
+		issues: [],
+		processed: false,
+		errors: 0,
+		configErrors: 0,
+		elapsedTimeMs: 1,
+		reportIssueOptions: void 0
+	};
+	async function processPrefetchFileResult(pf) {
+		const { filename, sequence, sequenceSize, result: pFetchResult } = pf;
+		const getElapsedTimeMs = getTimeMeasurer();
+		const fetchResult = await pFetchResult;
+		if (fetchResult instanceof Error) throw fetchResult;
+		const fileNum = sequence + 1;
+		reporter.emitProgressBegin(filename, fileNum, pf.sequenceSize ?? sequence);
+		if (fetchResult?.skip) return {
+			filename,
+			sequence,
+			sequenceSize,
+			result: {
+				...emptyResult,
+				fileInfo: { filename },
+				elapsedTimeMs: getElapsedTimeMs(),
+				skippedReason: fetchResult.skipReason
+			}
+		};
+		return {
+			filename,
+			sequence,
+			sequenceSize,
+			result: await processFile(filename, cache, fetchResult, processFileOptionsGeneral)
+		};
+	}
+	async function* loadAndProcessFiles() {
+		if (isAsyncIterable(files)) {
+			for await (const pf of prefetchFilesAsync(files)) yield processPrefetchFileResult(pf);
+			return;
+		}
+		if (BATCH_PROCESS_SIZE <= 1) {
+			for (const pf of prefetchFiles(files)) {
+				await pf.result;
+				yield processPrefetchFileResult(pf);
+			}
+			return;
+		}
+		yield* pipe(prefetchIterable(pipe(prefetchFiles(files), opMap$1(async (pf) => processPrefetchFileResult(pf))), BATCH_PROCESS_SIZE));
+	}
+	for await (const fileP of loadAndProcessFiles()) {
+		const { filename, sequence, sequenceSize, result } = fileP;
+		status.files += 1;
+		status.cachedFiles = (status.cachedFiles || 0) + (result.cached ? 1 : 0);
+		status.skippedFiles = (status.skippedFiles || 0) + (result.processed ? 0 : 1);
+		const fileNum = sequence + 1;
+		const numIssues = reporter.emitProgressComplete(filename, fileNum, sequenceSize ?? fileNum, result);
+		if (numIssues || result.errors) {
+			status.filesWithIssues.add(relativeToCwd(filename, options.cfg.root));
+			status.issues += numIssues;
+			status.errors += result.errors;
+			if (failFast) return status;
+		}
+		status.errors += result.configErrors;
+	}
+	await cache.reconcile();
+	return status;
+}
+function processMaxFileSize(value) {
+	if (!value) return void 0;
+	if (typeof value === "number") return value;
+	const num = sizeToNumber(value);
+	if (Number.isNaN(num)) throw new ApplicationError(`Invalid max file size: "${value}"`);
+	return num;
+}
+function runResult(init = {}) {
+	const { files = 0, filesWithIssues = /* @__PURE__ */ new Set(), issues = 0, errors = 0, cachedFiles = 0 } = init;
+	return {
+		files,
+		filesWithIssues,
+		issues,
+		errors,
+		cachedFiles
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.107.0/helpers/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
+		var n$1 = Error();
+		return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+	}, e = {}, n = [];
+	function using(r$1, e$1) {
+		if (null != e$1) {
+			if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o$1() {
+				try {
+					t.call(e$1);
+				} catch (r$2) {
+					return Promise.reject(r$2);
+				}
+			}), n.push({
+				v: e$1,
+				d: o,
+				a: r$1
+			});
+		} else r$1 && n.push({
+			d: e$1,
+			a: r$1
+		});
+		return e$1;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r$1 = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+					} else s |= 1;
+				} catch (r$2) {
+					return err(r$2);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n$1) {
+				return t = t !== e ? new r(n$1, t) : n$1, next();
+			}
+			return next();
+		}
+	};
+}
+
 //#endregion
 //#region src/lint/lint.ts
 const version = npmPackage.version;
-const BATCH_SIZE = 8;
 const { opFilterAsync } = operators;
 async function runLint(cfg) {
 	const reporter = new LintReporter(cfg.reporter, cfg.options);
 	const configErrors = /* @__PURE__ */ new Set();
 	const verboseLevel = calcVerboseLevel(cfg.options);
 	const useColor = cfg.options.color ?? true;
+	if (verboseLevel >= 1 && cfg.options.showPerfSummary) enablePerformanceMeasurements();
 	const timer = getTimeMeasurer();
 	const logDictRequests = truthy(getEnvironmentVariable("CSPELL_ENABLE_DICTIONARY_LOGGING"));
 	if (logDictRequests) dictionaryCacheEnableLogging(true);
@@ -2632,157 +2860,65 @@ async function runLint(cfg) {
 	if (logDictRequests) await writeDictionaryLog();
 	await reporter.result(lintResult);
 	const elapsed = timer();
-	if (getFeatureFlags().getFlag("timer")) console.log(`Elapsed Time: ${elapsed.toFixed(2)}ms`);
+	if (getFeatureFlags().getFlag("timer") || verboseLevel >= 1 || cfg.options.showPerfSummary) console.error(`Elapsed Time: ${elapsed.toFixed(2)}ms`);
 	return lintResult;
-	function prefetch(filename, configInfo, cache) {
-		if (isBinaryFile$1(filename, cfg.root)) return {
-			filename,
-			result: Promise.resolve({
-				skip: true,
-				skipReason: "Binary file."
-			})
-		};
-		const reportIssueOptions = extractReporterIssueOptions(configInfo.config);
-		async function fetch$1() {
-			const getElapsedTimeMs = getTimeMeasurer();
-			const cachedResult = await cache.getCachedLintResults(filename);
-			if (cachedResult) {
-				reporter.debug(`Filename: ${filename}, using cache`);
-				return { fileResult: {
-					...cachedResult,
-					elapsedTimeMs: getElapsedTimeMs()
-				} };
-			}
-			const uri = filenameToUri(filename, cfg.root).href;
-			const checkResult = await shouldCheckDocument({ uri }, {}, configInfo.config);
-			if (!checkResult.shouldCheck) return {
-				skip: true,
-				skipReason: checkResult.reason || "Ignored by configuration."
-			};
-			const maxFileSize = processMaxFileSize(cfg.maxFileSize ?? checkResult.settings.maxFileSize);
-			if (maxFileSize) {
-				if (await getFileSize(filename) > maxFileSize) return {
-					skip: true,
-					skipReason: `File exceeded max file size of ${maxFileSize.toLocaleString()}`
-				};
-			}
-			return {
-				fileInfo: await readFileInfo(filename, void 0, true),
-				reportIssueOptions
-			};
-		}
-		return {
-			filename,
-			result: fetch$1().catch((e) => toApplicationError(e))
-		};
-	}
-	async function processFiles(files, configInfo, cacheSettings) {
-		const fileCount = Array.isArray(files) ? files.length : void 0;
-		const status = runResult();
-		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);
-			for (const v of iter) yield v;
-		}
-		async function* prefetchFilesAsync(files$1) {
-			for await (const filename of files$1) yield prefetch(filename, configInfo, cache);
-		}
-		const emptyResult = {
-			fileInfo: { filename: "" },
-			issues: [],
-			processed: false,
-			errors: 0,
-			configErrors: 0,
-			elapsedTimeMs: 1,
-			reportIssueOptions: void 0
-		};
-		async function processPrefetchFileResult(pf, index) {
-			const { filename, result: pFetchResult } = pf;
-			const getElapsedTimeMs = getTimeMeasurer();
-			const fetchResult = await pFetchResult;
-			if (fetchResult instanceof Error) throw fetchResult;
-			reporter.emitProgressBegin(filename, index, fileCount ?? index);
-			if (fetchResult?.skip) return {
-				filename,
-				fileNum: index,
-				result: {
-					...emptyResult,
-					fileInfo: { filename },
-					elapsedTimeMs: getElapsedTimeMs(),
-					skippedReason: fetchResult.skipReason
-				}
-			};
-			return {
-				filename,
-				fileNum: index,
-				result: await processFile(filename, cache, fetchResult, getProcessFileOptions(configInfo))
-			};
-		}
-		async function* loadAndProcessFiles() {
-			let i = 0;
-			if (isAsyncIterable(files)) for await (const pf of prefetchFilesAsync(files)) yield processPrefetchFileResult(pf, ++i);
-			else for (const pf of prefetchFiles(files)) {
-				await pf.result;
-				yield processPrefetchFileResult(pf, ++i);
-			}
-		}
-		for await (const fileP of loadAndProcessFiles()) {
-			const { filename, fileNum, result } = fileP;
-			status.files += 1;
-			status.cachedFiles = (status.cachedFiles || 0) + (result.cached ? 1 : 0);
-			status.skippedFiles = (status.skippedFiles || 0) + (result.processed ? 0 : 1);
-			const numIssues = reporter.emitProgressComplete(filename, fileNum, fileCount ?? fileNum, result);
-			if (numIssues || result.errors) {
-				status.filesWithIssues.add(relativeToCwd(filename, cfg.root));
-				status.issues += numIssues;
-				status.errors += result.errors;
-				if (failFast) return status;
-			}
-			status.errors += result.configErrors;
-		}
-		await cache.reconcile();
-		return status;
-	}
 	async function run() {
-		if (cfg.options.root) setEnvironmentVariable(ENV_CSPELL_GLOB_ROOT, cfg.root);
-		const configInfo = await readConfig(cfg.configFile, cfg.root, cfg.options.stopConfigSearchAt);
-		const processFileOptions = getProcessFileOptions(configInfo);
-		if (cfg.options.defaultConfiguration !== void 0) configInfo.config.loadDefaultConfiguration = cfg.options.defaultConfiguration;
-		configInfo.config = mergeSettings(configInfo.config, cfg.cspellSettingsFromCliOptions);
-		const reporterConfig = clean({
-			maxNumberOfProblems: configInfo.config.maxNumberOfProblems,
-			maxDuplicateProblems: configInfo.config.maxDuplicateProblems,
-			minWordLength: configInfo.config.minWordLength,
-			...cfg.options,
-			console
-		});
-		const reporters = cfg.options.reporter ?? configInfo.config.reporters;
-		reporter.config = reporterConfig;
-		await reporter.loadReportersAndFinalize(reporters);
-		setLogger(getLoggerFromReporter(reporter, useColor));
-		const globInfo = await determineGlobs(configInfo, cfg);
-		const { fileGlobs, excludeGlobs } = globInfo;
-		const hasFileLists = !!cfg.fileLists.length;
-		if (!fileGlobs.length && !hasFileLists && !cfg.files?.length) return runResult();
-		header(fileGlobs, excludeGlobs);
-		checkGlobs(fileGlobs, reporter);
-		if (verboseLevel > 1) reporter.info(`Config Files Found:\n    ${relativeToCwd(configInfo.source)}\n`, MessageTypes$1.Info);
-		const configErrors$1 = await countConfigErrors(configInfo, processFileOptions);
-		if (configErrors$1 && cfg.options.exitCode !== false && !cfg.options.continueOnError) return runResult({ errors: configErrors$1 });
-		const { root } = cfg;
 		try {
-			const cacheSettings = await calcCacheSettings(configInfo.config, {
+			var _usingCtx$1 = _usingCtx();
+			const _ = _usingCtx$1.u(measurePerf("runLint"));
+			if (cfg.options.root) setEnvironmentVariable(ENV_CSPELL_GLOB_ROOT, cfg.root);
+			const configInfo = await readConfig(cfg.configFile, cfg.root, cfg.options.stopConfigSearchAt);
+			const processFileOptions = getProcessFileOptions(configInfo);
+			if (cfg.options.defaultConfiguration !== void 0) configInfo.config.loadDefaultConfiguration = cfg.options.defaultConfiguration;
+			configInfo.config = mergeSettings(configInfo.config, cfg.cspellSettingsFromCliOptions);
+			const reporterConfig = clean({
+				maxNumberOfProblems: configInfo.config.maxNumberOfProblems,
+				maxDuplicateProblems: configInfo.config.maxDuplicateProblems,
+				minWordLength: configInfo.config.minWordLength,
 				...cfg.options,
-				version
-			}, root);
-			const result = await processFiles(await determineFilesToCheck(configInfo, cfg, reporter, globInfo), configInfo, cacheSettings);
-			if (configErrors$1 && cfg.options.exitCode !== false) result.errors ||= configErrors$1;
-			return result;
-		} catch (e) {
-			const err = toApplicationError(e);
-			reporter.error("Linter", err);
-			return runResult({ errors: 1 });
+				console
+			});
+			const reporters = cfg.options.reporter ?? configInfo.config.reporters;
+			reporter.config = reporterConfig;
+			await reporter.loadReportersAndFinalize(reporters);
+			setLogger(getLoggerFromReporter(reporter, useColor));
+			const globInfo = await determineGlobs(configInfo, cfg);
+			const { fileGlobs, excludeGlobs } = globInfo;
+			const hasFileLists = !!cfg.fileLists.length;
+			if (!fileGlobs.length && !hasFileLists && !cfg.files?.length) return runResult();
+			header(fileGlobs, excludeGlobs);
+			checkGlobs(fileGlobs, reporter);
+			if (verboseLevel > 1) reporter.info(`Config Files Found:\n    ${relativeToCwd(configInfo.source)}\n`, MessageTypes$1.Info);
+			const configErrorCount = countConfigErrors(configInfo, processFileOptions);
+			if (configErrorCount && cfg.options.exitCode !== false && !cfg.options.continueOnError) return runResult({ errors: configErrorCount });
+			const { root } = cfg;
+			try {
+				const cacheSettings = await calcCacheSettings(configInfo.config, {
+					...cfg.options,
+					version
+				}, root);
+				const result = await processFiles(await determineFilesToCheck(configInfo, cfg, reporter, globInfo), {
+					chalk,
+					configInfo,
+					cfg,
+					verboseLevel,
+					useColor,
+					configErrors,
+					userSettings: configInfo.config,
+					lintReporter: reporter,
+					cacheSettings
+				});
+				if (configErrorCount && cfg.options.exitCode !== false) result.errors ||= configErrorCount;
+				return result;
+			} catch (e) {
+				const err = toApplicationError(e);
+				reporter.error("Linter", err);
+				return runResult({ errors: 1 });
+			}
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
 		}
 	}
 	function header(files, cliExcludes) {
@@ -2808,7 +2944,8 @@ async function runLint(cfg) {
 			cfg,
 			verboseLevel,
 			useColor,
-			configErrors
+			configErrors,
+			userSettings: configInfo.config
 		};
 	}
 }
@@ -2831,6 +2968,22 @@ async function determineGlobs(configInfo, cfg) {
 		normalizedExcludes
 	};
 }
+async function* filesToProcessAsync(filenames) {
+	let sequence = 0;
+	for await (const filename of filenames) yield {
+		filename,
+		sequence: sequence++
+	};
+}
+function filesToProcess(files) {
+	const filenames = [...files];
+	const sequenceSize = filenames.length;
+	return filenames.map((filename, sequence) => ({
+		filename,
+		sequence,
+		sequenceSize
+	}));
+}
 async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
 	async function _determineFilesToCheck() {
 		const { fileLists } = cfg;
@@ -2858,7 +3011,7 @@ async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
 		const cliFiles = cfg.options.mustFindFiles ? rawCliFiles : rawCliFiles && pipeAsync(rawCliFiles, opFilterAsync(isFile));
 		const foundFiles = hasFileLists ? concatAsyncIterables(cliFiles, await useFileLists(fileLists, includeFilter)) : cliFiles || await findFiles(fileGlobs, globOptions);
 		const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
-		return isAsyncIterable(filtered) ? pipeAsync(filtered, opFilterExcludedFiles) : [...pipe(filtered, opFilterExcludedFiles)];
+		return isAsyncIterable(filtered) ? pipeAsync(filtered, opFilterExcludedFiles, filesToProcessAsync) : filesToProcess(pipe(filtered, opFilterExcludedFiles));
 	}
 	function isExcluded(filename, globMatcherExclude) {
 		if (isBinaryFile(toFileURL(filename))) return true;
@@ -2885,16 +3038,6 @@ function extractGlobSource(g) {
 		source
 	};
 }
-function runResult(init = {}) {
-	const { files = 0, filesWithIssues = /* @__PURE__ */ new Set(), issues = 0, errors = 0, cachedFiles = 0 } = init;
-	return {
-		files,
-		filesWithIssues,
-		issues,
-		errors,
-		cachedFiles
-	};
-}
 function yesNo(value) {
 	return value ? "Yes" : "No";
 }
@@ -2962,13 +3105,6 @@ function globPattern(g) {
 function calcVerboseLevel(options) {
 	return options.verboseLevel ?? (options.verbose ? 1 : 0);
 }
-function processMaxFileSize(value) {
-	if (!value) return void 0;
-	if (typeof value === "number") return value;
-	const num = sizeToNumber(value);
-	if (Number.isNaN(num)) throw new ApplicationError(`Invalid max file size: "${value}"`);
-	return num;
-}
 
 //#endregion
 //#region src/lint/LintRequest.ts
@@ -3303,4 +3439,4 @@ function parseApplicationFeatureFlags(flags) {
 
 //#endregion
 export { CheckFailed as C, ApplicationError as S, padLeft as _, parseApplicationFeatureFlags as a, pruneAnsiTextStart as b, listDictionaries as c, validateUnitSize as d, unindent as f, tableToLines as g, getReporter as h, lint as i, ReportChoicesAll as l, npmPackage as m, checkText as n, suggestions as o, DEFAULT_CACHE_LOCATION as p, createInit as r, trace as s, IncludeExcludeFlag as t, cvtLinterCliCommandOptionsToLinterCliOptions as u, padWidth as v, console as w, width as x, pruneAnsiTextEnd as y };
-//# sourceMappingURL=application-BJHh60xM.js.map
+//# sourceMappingURL=application-DaQrXF9X.js.map

package/dist/esm/application.js

@@ -1,3 +1,3 @@
-import { a as parseApplicationFeatureFlags, c as listDictionaries, i as lint, n as checkText, o as suggestions, r as createInit, s as trace, t as IncludeExcludeFlag } from "./application-BJHh60xM.js";
+import { a as parseApplicationFeatureFlags, c as listDictionaries, i as lint, n as checkText, o as suggestions, r as createInit, s as trace, t as IncludeExcludeFlag } from "./application-DaQrXF9X.js";
 
 export { IncludeExcludeFlag, checkText, createInit, lint, listDictionaries, parseApplicationFeatureFlags, suggestions, trace };

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { a as parseApplicationFeatureFlags, c as listDictionaries, h as getReporter, i as lint, n as checkText, o as suggestions, r as createInit, s as trace, t as IncludeExcludeFlag } from "./application-BJHh60xM.js";
+import { a as parseApplicationFeatureFlags, c as listDictionaries, h as getReporter, i as lint, n as checkText, o as suggestions, r as createInit, s as trace, t as IncludeExcludeFlag } from "./application-DaQrXF9X.js";
 
 export * from "@cspell/cspell-types"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "9.6.0",
+  "version": "9.6.1",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "bin": {
@@ -86,28 +86,30 @@
   },
   "homepage": "https://cspell.org/",
   "dependencies": {
-    "@cspell/cspell-json-reporter": "9.6.0",
-    "@cspell/cspell-pipe": "9.6.0",
-    "@cspell/cspell-types": "9.6.0",
-    "@cspell/dynamic-import": "9.6.0",
-    "@cspell/url": "9.6.0",
+    "@cspell/cspell-json-reporter": "9.6.1",
+    "@cspell/cspell-performance-monitor": "9.6.1",
+    "@cspell/cspell-pipe": "9.6.1",
+    "@cspell/cspell-types": "9.6.1",
+    "@cspell/cspell-worker": "9.6.1",
+    "@cspell/dynamic-import": "9.6.1",
+    "@cspell/url": "9.6.1",
     "ansi-regex": "^6.2.2",
     "chalk": "^5.6.2",
     "chalk-template": "^1.1.2",
     "commander": "^14.0.2",
-    "cspell-config-lib": "9.6.0",
-    "cspell-dictionary": "9.6.0",
-    "cspell-gitignore": "9.6.0",
-    "cspell-glob": "9.6.0",
-    "cspell-io": "9.6.0",
-    "cspell-lib": "9.6.0",
+    "cspell-config-lib": "9.6.1",
+    "cspell-dictionary": "9.6.1",
+    "cspell-gitignore": "9.6.1",
+    "cspell-glob": "9.6.1",
+    "cspell-io": "9.6.1",
+    "cspell-lib": "9.6.1",
     "fast-json-stable-stringify": "^2.1.0",
     "flatted": "^3.3.3",
     "semver": "^7.7.3",
     "tinyglobby": "^0.2.15"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.18"
   },
   "devDependencies": {
     "@types/micromatch": "^4.0.10",
@@ -115,5 +117,5 @@
     "micromatch": "^4.0.8",
     "minimatch": "^9.0.5"
   },
-  "gitHead": "163793ddf2a0ad90bc7c90351698a106003297af"
+  "gitHead": "666fb79096d25c53af9519cad07030e7aca597e1"
 }