cspell 9.4.0 → 9.6.1

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

@@ -1,21 +1,23 @@
 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, 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";
 import chalk, { Chalk } from "chalk";
 import { makeTemplate } from "chalk-template";
+import ansiRegex from "ansi-regex";
 import fs, { stat } from "node:fs/promises";
 import { MutableCSpellConfigFile, createReaderWriter, cspellConfigFileSchema, isCfgArrayNode } from "cspell-config-lib";
 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, unknownWordsChoices } from "@cspell/cspell-types";
-import { _debug } from "cspell-dictionary";
+import { IssueType, MessageTypes as MessageTypes$1, unknownWordsChoices } from "@cspell/cspell-types";
+import { dictionaryCacheEnableLogging, dictionaryCacheGetLog } from "cspell-dictionary";
 import { GitIgnore, findRepoRoot } from "cspell-gitignore";
 import { GlobMatcher, fileOrGlobToGlob, workaroundPicomatchBug } from "cspell-glob";
 import crypto from "node:crypto";
@@ -25,7 +27,6 @@ import { glob } from "tinyglobby";
 import * as readline from "node:readline";
 import { parse, stringify } from "flatted";
 import { dynamicImport } from "@cspell/dynamic-import";
-import ansiRegex from "ansi-regex";
 
 //#region src/console.ts
 var ImplChannel = class {
@@ -89,7 +90,7 @@ var IOError = class extends ApplicationError {
 		return this.cause.code === "ENOENT";
 	}
 };
-function toError(e) {
+function toError$1(e) {
 	if (isError(e)) return e;
 	if (isErrorLike(e)) {
 		const ex = new Error(e.message, { cause: e });
@@ -109,10 +110,349 @@ function isErrorLike(e) {
 }
 function toApplicationError(e, message) {
 	if (e instanceof ApplicationError && !message) return e;
-	const err = toError(e);
+	const err = toError$1(e);
 	return new ApplicationError(message ?? err.message, void 0, err);
 }
 
+//#endregion
+//#region src/util/perfMeasurements.ts
+function getPerfMeasurements() {
+	const measurements = performance.getEntriesByType("measure");
+	const root = {
+		depth: -1,
+		totalTimeMs: 0,
+		nestedTimeMs: 0,
+		children: /* @__PURE__ */ new Map()
+	};
+	if (!measurements.length) return [];
+	const stack = [];
+	let depth = 0;
+	for (let i = 0; i < measurements.length; i++) {
+		const m = measurements[i];
+		rollUpStack(m.startTime);
+		const s = {
+			m,
+			p: addToParent(depth === 0 ? root : stack[depth - 1].p, m)
+		};
+		stack[depth++] = s;
+	}
+	sortChildren(root);
+	return [...root.children.values()].flatMap((r) => [...flattenChildren(r)]);
+	function contains(m, t) {
+		const stop = m.startTime + m.duration;
+		return t >= m.startTime && t < stop;
+	}
+	function rollUpStack(t) {
+		for (; depth > 0 && !contains(stack[depth - 1].m, t); --depth);
+	}
+	function addToParent(p, m) {
+		p.children ??= /* @__PURE__ */ new Map();
+		p.nestedTimeMs += m.duration;
+		return updateChild(p.children, m, p.depth + 1);
+	}
+	function updateChild(children, m, depth$1) {
+		const p = children.get(m.name);
+		if (p) {
+			p.totalTimeMs += m.duration;
+			p.count += 1;
+			p.minTimeMs = Math.min(p.minTimeMs, m.duration);
+			p.maxTimeMs = Math.max(p.maxTimeMs, m.duration);
+			return p;
+		}
+		const n = {
+			name: m.name,
+			depth: depth$1,
+			totalTimeMs: m.duration,
+			nestedTimeMs: 0,
+			count: 1,
+			minTimeMs: m.duration,
+			maxTimeMs: m.duration
+		};
+		children.set(m.name, n);
+		return n;
+	}
+	function* flattenChildren(m) {
+		yield m;
+		if (!m.children) return;
+		for (const child of m.children.values()) yield* flattenChildren(child);
+	}
+	function sortChildren(m) {
+		if (!m.children) return;
+		m.children = new Map([...m.children.entries()].sort((a, b) => b[1].totalTimeMs - a[1].totalTimeMs));
+		m.children.forEach(sortChildren);
+	}
+}
+
+//#endregion
+//#region src/util/ansi.ts
+function isAnsiString(s) {
+	return s.includes("\x1B") || s.includes("›");
+}
+/**
+*
+* @param s - the string to measure - should NOT contains ANSI codes
+* @param tabWidth -
+* @returns
+*/
+function width(s, tabWidth = 1) {
+	return s.replaceAll("…", ".").replaceAll("	", " ".repeat(tabWidth)).replaceAll(/\p{M}/gu, "").replaceAll(/\p{L}/gu, ".").replaceAll(/[\u0000-\u001F\u0300-\u036F]/g, "").replaceAll(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, ".").length;
+}
+/**
+* Measure the width of a string containing ANSI control characters.
+* @param s - string to measure with width in characters.
+* @returns the approximate number of screen characters.
+*/
+function ansiWidth(s) {
+	return width(stripVTControlCharacters(s));
+}
+function fragmentString(str, splitOnRegex, sType) {
+	const fragments = [];
+	let lastIndex = 0;
+	for (const match of str.matchAll(new RegExp(splitOnRegex))) {
+		if (match.index > lastIndex) fragments.push({
+			type: "text",
+			text: str.slice(lastIndex, match.index)
+		});
+		fragments.push({
+			type: sType,
+			text: match[0]
+		});
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < str.length) fragments.push({
+		type: "text",
+		text: str.slice(lastIndex)
+	});
+	return fragments;
+}
+const ansi = ansiRegex();
+function parseAnsiStr(str) {
+	return fragmentString(str, ansi, "ansi");
+}
+/**
+* Prune the end of a string to fit within a specified width, adding an ellipsis if necessary.
+* @param str - the text to prune - ANSI is supported
+* @param maxWidth - the maximum width of the text
+* @param pad - the string to use for padding, default is '…'
+* @returns the pruned text
+*/
+function pruneAnsiTextEnd(str, maxWidth, pad$1 = "…") {
+	if (!maxWidth || maxWidth <= 0) return str;
+	if (str.length <= maxWidth) return str;
+	if (ansiWidth(str) <= maxWidth) return str;
+	const padWidth$1 = ansiWidth(pad$1);
+	const fragments = parseAnsiStr(str);
+	let remaining = maxWidth - padWidth$1;
+	for (const frag of fragments) {
+		if (frag.type !== "text") continue;
+		if (remaining <= 0) {
+			frag.text = "";
+			continue;
+		}
+		const pruned = pruneTextEnd(frag.text, remaining, pad$1);
+		if (pruned !== frag.text) {
+			frag.text = pruned;
+			remaining = 0;
+			continue;
+		}
+		remaining -= width(frag.text);
+	}
+	return fragments.map((frag) => frag.text).join("");
+}
+/**
+* Prune the start of a string to fit within a specified width, adding an ellipsis if necessary.
+* @param str - the text to prune - ANSI is supported
+* @param maxWidth - the maximum width of the text
+* @param pad - the string to use for padding, default is '…'
+* @returns the pruned text
+*/
+function pruneAnsiTextStart(str, maxWidth, pad$1 = "…") {
+	if (!maxWidth || maxWidth <= 0) return str;
+	if (str.length <= maxWidth) return str;
+	if (ansiWidth(str) <= maxWidth) return str;
+	const padWidth$1 = ansiWidth(pad$1);
+	const fragments = parseAnsiStr(str);
+	let remaining = maxWidth - padWidth$1;
+	for (const frag of fragments.reverse()) {
+		if (frag.type !== "text") continue;
+		if (remaining <= 0) {
+			frag.text = "";
+			continue;
+		}
+		const pruned = pruneTextStart(frag.text, remaining, pad$1);
+		if (pruned !== frag.text) {
+			frag.text = pruned;
+			remaining = 0;
+			continue;
+		}
+		remaining -= width(frag.text);
+	}
+	return fragments.reverse().map((frag) => frag.text).join("");
+}
+/**
+* Prune the end of a string to fit within a specified width, adding an ellipsis if necessary.
+* @param str - the text to prune - ANSI is not supported
+* @param maxWidth - the maximum width of the text
+* @param pad - the string to use for padding, default is '…'
+* @returns the pruned text
+*/
+function pruneTextEnd(str, maxWidth, pad$1 = "…") {
+	if (!maxWidth || maxWidth <= 0) return str;
+	if (str.length <= maxWidth) return str;
+	if (isAnsiString(str)) return pruneAnsiTextEnd(str, maxWidth, pad$1);
+	const maxWidthWithPad = maxWidth - width(pad$1);
+	const letters = [...str];
+	let len = 0;
+	for (let i = 0; i < letters.length; i++) {
+		const c = letters[i];
+		len += width(c);
+		if (len > maxWidthWithPad) {
+			let j = i + 1;
+			while (j < letters.length && width(letters[j]) === 0) ++j;
+			return j === letters.length ? str : letters.slice(0, i).join("") + pad$1;
+		}
+	}
+	return str;
+}
+/**
+* Prune the start of a string to fit within a specified width, adding an ellipsis if necessary.
+* @param str - the text to prune - ANSI is not supported
+* @param maxWidth - the maximum width of the text
+* @param pad - the string to use for padding, default is '…'
+* @returns the pruned text
+*/
+function pruneTextStart(str, maxWidth, pad$1 = "…") {
+	if (!maxWidth || maxWidth <= 0) return str;
+	if (str.length <= maxWidth) return str;
+	const maxWidthWithPad = maxWidth - width(pad$1);
+	const letters = [...str];
+	let len = 0;
+	for (let i = letters.length - 1; i >= 1; i--) {
+		const c = letters[i];
+		len += width(c);
+		if (len > maxWidthWithPad) {
+			i += 1;
+			while (i < letters.length && width(letters[i]) === 0) ++i;
+			return pad$1 + letters.slice(i).join("");
+		}
+	}
+	return str;
+}
+
+//#endregion
+//#region src/util/pad.ts
+function pad(s, w) {
+	const p = padWidth(s, w);
+	if (!p) return s;
+	return s.padEnd(p + s.length);
+}
+function padWidth(s, target) {
+	const sWidth = ansiWidth(s);
+	return Math.max(target - sWidth, 0);
+}
+function padLeft(s, w) {
+	const p = padWidth(s, w);
+	if (!p) return s;
+	return s.padStart(p + s.length);
+}
+
+//#endregion
+//#region src/util/table.ts
+function tableToLines(table, deliminator) {
+	const del = deliminator || table.deliminator || " | ";
+	const columnWidths = [];
+	const columnAlignments = table.columnAlignments || [];
+	const maxColumnWidthsMap = table.maxColumnWidths || {};
+	const tableIndent = table.indent ? typeof table.indent === "number" ? " ".repeat(table.indent) : table.indent : "";
+	const { header, rows } = table;
+	const simpleHeader = header.map((col) => Array.isArray(col) ? col[1] : col);
+	const columnFieldNames = header.map((col) => Array.isArray(col) ? col[0] : col);
+	const maxColumnWidths = columnFieldNames.map((field, idx) => maxColumnWidthsMap[field] ?? maxColumnWidthsMap[idx]);
+	function getCell(row, col) {
+		return getCellFromRow(rows[row], col);
+	}
+	function getCellFromRow(row, col) {
+		if (!row) return void 0;
+		if (Array.isArray(row)) return row[col];
+		return row[columnFieldNames[col]];
+	}
+	function rowToCells(row) {
+		if (Array.isArray(row)) return row;
+		return columnFieldNames.map((fieldName) => row[fieldName]);
+	}
+	function getText(col, maxWidth) {
+		return !col ? "" : typeof col === "string" ? pruneTextEnd(col, maxWidth) : col(maxWidth);
+	}
+	function getRCText(row, col, maxWidth) {
+		return getText(getCell(row, col), maxWidth);
+	}
+	function recordHeaderWidths(header$1) {
+		header$1.forEach((col, idx) => {
+			columnWidths[idx] = Math.max(ansiWidth(col), columnWidths[idx] || 0);
+		});
+	}
+	function recordColWidths() {
+		for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) for (let colIndex = 0; colIndex < columnFieldNames.length; colIndex++) columnWidths[colIndex] = Math.max(ansiWidth(getRCText(rowIndex, colIndex, void 0)), columnWidths[colIndex] || 0);
+	}
+	function justifyRow(c, i) {
+		return columnAlignments[i] === "R" ? padLeft(c, columnWidths[i]) : pad(c, columnWidths[i]);
+	}
+	function toHeaderLine(header$1) {
+		return tableIndent + decorateRowWith(header$1.map((c, i) => getText(c, columnWidths[i])), justifyRow, headerDecorator).join(del);
+	}
+	function toLine(row) {
+		return tableIndent + decorateRowWith(rowToCells(row).map((c, i) => getText(c, columnWidths[i])), justifyRow).join(del);
+	}
+	function* process$1() {
+		if (table.title) yield table.title;
+		yield toHeaderLine(simpleHeader);
+		yield* rows.map(toLine);
+	}
+	function sumColumnWidths() {
+		return columnWidths.reduce((sum, width$1) => sum + width$1, 0);
+	}
+	function adjustColWidths() {
+		for (let i = 0; i < columnWidths.length; i++) {
+			const mw = maxColumnWidths[i];
+			if (!mw) continue;
+			columnWidths[i] = Math.min(columnWidths[i], mw);
+		}
+		if (!table.terminalWidth) return;
+		const dWidth = (columnWidths.length - 1) * ansiWidth(del);
+		const lineWidth = table.terminalWidth - dWidth;
+		if (lineWidth <= columnWidths.length * 2) {
+			const fixedWidth = Math.max(Math.min(...columnWidths), 5);
+			for (let i = 0; i < columnWidths.length; i++) columnWidths[i] = fixedWidth;
+			return;
+		}
+		if (columnWidths.length === 1) {
+			columnWidths[0] = lineWidth;
+			return;
+		}
+		function trimWidestColumn(neededToTrim) {
+			let first = 0;
+			let second = 0;
+			for (let i = 0; i < columnWidths.length; i++) if (columnWidths[i] > columnWidths[first]) {
+				second = first;
+				first = i;
+			} else if (columnWidths[i] > columnWidths[second]) second = i;
+			const diff = Math.max(columnWidths[first] - columnWidths[second], 1);
+			columnWidths[first] -= Math.min(diff, neededToTrim);
+		}
+		for (let sum = sumColumnWidths(); sum > lineWidth; sum = sumColumnWidths()) trimWidestColumn(sum - lineWidth);
+	}
+	recordHeaderWidths(simpleHeader);
+	recordColWidths();
+	adjustColWidths();
+	return [...process$1()];
+}
+function headerDecorator(t) {
+	return chalk.bold(chalk.underline(t));
+}
+function decorateRowWith(row, ...decorators) {
+	return decorators.reduce((row$1, decorator) => row$1.map(decorator), row);
+}
+
 //#endregion
 //#region src/util/util.ts
 const uniqueFn = uniqueFilterFnGenerator;
@@ -222,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;
@@ -279,6 +620,7 @@ function getReporter(options, config) {
 		if (!fileGlobs.length && !result.files) return;
 		const { files, issues: issues$1, cachedFiles, filesWithIssues, errors, skippedFiles } = result;
 		const numFilesWithIssues = filesWithIssues.size;
+		const chalk$1 = stderr.chalk;
 		if (stderr.getColorLevel() > 0) {
 			stderr.write("\r");
 			stderr.clearLine(0);
@@ -299,20 +641,88 @@ 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("Stats:");
-			const stats = Object.entries(perfStats.perf).filter((p) => !!p[1]).map(([key, value]) => [key, value.toFixed(2)]);
-			const padName = Math.max(...stats.map((s) => s[0].length));
-			const padValue = Math.max(...stats.map((s) => s[1].length));
-			stats.sort((a, b) => a[0].localeCompare(b[0]));
-			for (const [key, value] of stats) value && consoleError(`  ${key.padEnd(padName)}: ${value.padStart(padValue)}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)"],
+				columnAlignments: ["L", "R"],
+				indent: 2,
+				rows: Object.entries(perfStats.perf).filter((p) => !!p[1]).map(([key, value]) => [key, value.toFixed(2)])
+			};
+			consoleError("");
+			for (const line of tableToLines(tableStats)) consoleError(line);
+			if (options.verboseLevel) verbosePerfReport();
 		}
 	};
+	function verbosePerfReport() {
+		const perfMeasurements = getPerfMeasurements();
+		if (!perfMeasurements.length) return;
+		const notable = extractNotableBySelfTimeInGroup(perfMeasurements);
+		const chalk$1 = stderr.chalk;
+		const maxDepth = Math.max(...perfMeasurements.map((m) => m.depth));
+		const depthIndicator = (d) => "⋅".repeat(d) + " ".repeat(maxDepth - d);
+		const rows = perfMeasurements.map((m) => {
+			const cbd = (text) => colorByDepth(chalk$1, m.depth, text);
+			const cNotable = (text) => notable.has(m) ? chalk$1.yellow(text) : text;
+			return [
+				chalk$1.dim("⋅".repeat(m.depth)) + colorByDepthGrayscale(stderr.chalk, m.depth, m.name),
+				cbd(m.totalTimeMs.toFixed(2) + chalk$1.dim(depthIndicator(m.depth))),
+				cbd(cNotable((m.totalTimeMs - m.nestedTimeMs).toFixed(2))),
+				cbd(m.count.toString()),
+				cbd(m.minTimeMs.toFixed(2)),
+				cbd(m.maxTimeMs.toFixed(2)),
+				cbd((m.totalTimeMs / m.count).toFixed(2))
+			];
+		});
+		const table = tableToLines({
+			title: chalk$1.bold("Detailed Measurements:"),
+			header: [
+				"Name",
+				"Total Time (ms)",
+				"Self (ms)",
+				"Count",
+				"Min (ms)",
+				"Max (ms)",
+				"Avg (ms)"
+			],
+			rows,
+			columnAlignments: [
+				"L",
+				"R",
+				"R",
+				"R",
+				"R",
+				"R",
+				"R"
+			],
+			indent: 2
+		});
+		consoleError("\n-------------------------------------------\n");
+		for (const line of table) consoleError(line);
+	}
+	function colorByDepth(chalk$1, depth, text) {
+		const colors = [
+			chalk$1.green,
+			chalk$1.cyan,
+			chalk$1.blue,
+			chalk$1.magenta,
+			chalk$1.red
+		];
+		const color = colors[depth % colors.length];
+		if (depth / colors.length >= 1) return chalk$1.dim(color(text));
+		return color(text);
+	}
+	function colorByDepthGrayscale(chalk$1, depth, text) {
+		const grayLevel = Math.max(32, 255 - depth * 20);
+		return chalk$1.rgb(grayLevel, grayLevel, grayLevel)(text);
+	}
 	function collectPerfStats(p) {
 		if (p.cached) {
 			perfStats.filesCached++;
@@ -320,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;
 	}
@@ -338,6 +748,27 @@ function getReporter(options, config) {
 		features: void 0
 	};
 }
+function extractNotableBySelfTimeInGroup(measurements) {
+	const notable = /* @__PURE__ */ new Set();
+	if (!measurements.length) return notable;
+	let highest;
+	let highestSelfTime = 0;
+	for (const m of measurements) {
+		if (m.depth === 0 || !highest) {
+			if (highest) notable.add(highest);
+			highest = m;
+			highestSelfTime = m.totalTimeMs - m.nestedTimeMs;
+			continue;
+		}
+		const selfTime = m.totalTimeMs - m.nestedTimeMs;
+		if (selfTime > highestSelfTime) {
+			highest = m;
+			highestSelfTime = selfTime;
+		}
+	}
+	if (highest) notable.add(highest);
+	return notable;
+}
 function formatIssue(io, templateStr, issue, maxIssueTextWidth) {
 	function clean$1(t$1) {
 		return t$1.replace(/\s+/, " ");
@@ -447,7 +878,7 @@ async function fileExists(url) {
 	try {
 		return (await promises.stat(url)).isFile();
 	} catch (e) {
-		if (toError(e).code === "ENOENT") return false;
+		if (toError$1(e).code === "ENOENT") return false;
 		throw e;
 	}
 }
@@ -770,8 +1201,8 @@ const pkgDir = _dirname;
 //#endregion
 //#region src/pkgInfo.ts
 const name = "cspell";
-const version$1 = "9.4.0";
-const engines = { node: ">=20" };
+const version$1 = "9.6.1";
+const engines = { node: ">=20.18" };
 const npmPackage = {
 	name,
 	version: version$1,
@@ -991,7 +1422,7 @@ function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
 		text,
 		filename
 	}), (e) => {
-		const error = toError(e);
+		const error = toError$1(e);
 		return handleNotFound && error.code === "EISDIR" ? Promise.resolve({
 			text: "",
 			filename,
@@ -1181,7 +1612,7 @@ var ImplFileEntryCache = class {
 			return {
 				key: file,
 				notFound: true,
-				err: toError$1(error)
+				err: toError(error)
 			};
 		}
 		if (this.useChecksum) return this.#getFileDescriptorUsingChecksum(file);
@@ -1296,7 +1727,7 @@ var ImplFileEntryCache = class {
 function isNodeError(error) {
 	return typeof error === "object" && error !== null && "code" in error;
 }
-function toError$1(error) {
+function toError(error) {
 	if (error instanceof Error) return error;
 	if (typeof error === "string") return new Error(error);
 	return new Error("Unknown error", { cause: error });
@@ -1648,109 +2079,38 @@ async function readConfigHandleError(filename) {
 }
 
 //#endregion
-//#region src/util/extractContext.ts
-function prefCharIndex(text, offset, count = 1) {
-	if (offset - count < 0) return 0;
-	for (; count > 0 && offset > 0; count--) {
-		let code = text.charCodeAt(--offset) || 0;
-		if (code === 65039) code = text.charCodeAt(--offset) || 0;
-		offset -= (code & 64512) === 56320 ? 1 : 0;
-	}
-	return offset < 0 ? 0 : offset;
+//#region src/util/reporters.ts
+function filterFeatureIssues(features, issue, reportOptions) {
+	if (issue.issueType === IssueType.directive) return features?.issueType && reportOptions?.validateDirectives || false;
+	if (features?.unknownWords) return true;
+	if (!reportOptions) return true;
+	if (issue.isFlagged || !reportOptions.unknownWords || reportOptions.unknownWords === unknownWordsChoices.ReportAll) return true;
+	if (issue.hasPreferredSuggestions && reportOptions.unknownWords !== unknownWordsChoices.ReportFlagged) return true;
+	if (issue.hasSimpleSuggestions && reportOptions.unknownWords === unknownWordsChoices.ReportSimple) return true;
+	return false;
 }
-function nextCharIndex(text, offset, count = 1) {
-	if (offset + count >= text.length) return text.length;
-	for (; count > 0 && offset < text.length; count--) {
-		const code = text.charCodeAt(offset++) || 0;
-		offset += (code & 64512) === 55296 ? 1 : 0;
-		if (text.charCodeAt(offset) === 65039) offset++;
+function handleIssue(reporter, issue, reportOptions) {
+	if (!reporter.issue) return;
+	if (!filterFeatureIssues(reporter.features, issue, reportOptions)) return;
+	if (!reporter.features?.contextGeneration && !issue.context) {
+		issue = { ...issue };
+		issue.context = issue.line;
 	}
-	return offset > text.length ? text.length : offset;
+	return reporter.issue(issue, reportOptions);
 }
-function lineContext(lineText, start, end, contextRange) {
-	let left = prefCharIndex(lineText, start, contextRange);
-	let right = nextCharIndex(lineText, end, contextRange);
-	const isLetter = /^\p{L}$/u;
-	const isMark = /^\p{M}$/u;
-	for (let n = contextRange / 2; n > 0 && left > 0; n--, left--) {
-		const c = lineText[left - 1];
-		if (isMark.test(c)) {
-			if (!isLetter.test(lineText[left - 2])) break;
-			left--;
-			continue;
-		}
-		if (!isLetter.test(lineText[left - 1])) break;
-	}
-	for (let n = contextRange / 2; n > 0 && right < lineText.length; n--, right++) {
-		if (!isLetter.test(lineText[right])) break;
-		if (isMark.test(lineText[right + 1])) right++;
-	}
-	left = left < 0 ? 0 : left;
-	const t0 = lineText.slice(left, right);
-	const tLeft = t0.trimStart();
-	left = Math.min(left + t0.length - tLeft.length, start);
-	return {
-		text: tLeft.trimEnd(),
-		offset: left
-	};
-}
-function extractContext(tdo, contextRange) {
-	const { line, offset, text } = tdo;
-	const start = offset - line.offset;
-	const context = lineContext(line.text, start, start + text.length, contextRange);
-	context.offset += line.offset;
-	return context;
-}
-
-//#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) {
-	if (issue.issueType === IssueType.directive) return features?.issueType && reportOptions?.validateDirectives || false;
-	if (features?.unknownWords) return true;
-	if (!reportOptions) return true;
-	if (issue.isFlagged || !reportOptions.unknownWords || reportOptions.unknownWords === unknownWordsChoices.ReportAll) return true;
-	if (issue.hasPreferredSuggestions && reportOptions.unknownWords !== unknownWordsChoices.ReportFlagged) return true;
-	if (issue.hasSimpleSuggestions && reportOptions.unknownWords === unknownWordsChoices.ReportSimple) return true;
-	return false;
-}
-function handleIssue(reporter, issue, reportOptions) {
-	if (!reporter.issue) return;
-	if (!filterFeatureIssues(reporter.features, issue, reportOptions)) return;
-	if (!reporter.features?.contextGeneration && !issue.context) {
-		issue = { ...issue };
-		issue.context = issue.line;
-	}
-	return reporter.issue(issue, reportOptions);
-}
-/**
-* Loads reporter modules configured in cspell config file
-*/
-async function loadReporters(reporters, defaultReporter, config) {
-	async function loadReporter(reporterSettings) {
-		if (reporterSettings === "default") return defaultReporter;
-		if (!Array.isArray(reporterSettings)) reporterSettings = [reporterSettings];
-		const [moduleName, settings] = reporterSettings;
-		try {
-			const { getReporter: getReporter$1 } = await dynamicImport(moduleName, [process.cwd(), pkgDir]);
-			return getReporter$1(settings, config);
-		} catch (e) {
-			throw new ApplicationError(`Failed to load reporter ${moduleName}: ${toError(e).message}`);
+/**
+* Loads reporter modules configured in cspell config file
+*/
+async function loadReporters(reporters, defaultReporter, config) {
+	async function loadReporter(reporterSettings) {
+		if (reporterSettings === "default") return defaultReporter;
+		if (!Array.isArray(reporterSettings)) reporterSettings = [reporterSettings];
+		const [moduleName, settings] = reporterSettings;
+		try {
+			const { getReporter: getReporter$1 } = await dynamicImport(moduleName, [process.cwd(), pkgDir]);
+			return getReporter$1(settings, config);
+		} catch (e) {
+			throw new ApplicationError(`Failed to load reporter ${moduleName}: ${toError$1(e).message}`);
 		}
 	}
 	reporters = !reporters || !reporters.length ? ["default"] : [...reporters];
@@ -1892,11 +2252,11 @@ function getTimeMeasurer() {
 * @returns
 */
 function indent(str, padding, firstLinePadding = "") {
-	let pad = firstLinePadding;
+	let pad$1 = firstLinePadding;
 	const lines = [];
 	for (const line of str.split("\n")) {
-		lines.push(pad + line);
-		pad = padding;
+		lines.push(pad$1 + line);
+		pad$1 = padding;
 	}
 	return lines.join("\n");
 }
@@ -1939,206 +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/ansi.ts
-function isAnsiString(s) {
-	return s.includes("\x1B") || s.includes("›");
-}
-/**
-*
-* @param s - the string to measure - should NOT contains ANSI codes
-* @param tabWidth -
-* @returns
-*/
-function width(s, tabWidth = 1) {
-	return s.replaceAll("…", ".").replaceAll("	", " ".repeat(tabWidth)).replaceAll(/\p{M}/gu, "").replaceAll(/\p{L}/gu, ".").replaceAll(/[\u0000-\u001F\u0300-\u036F]/g, "").replaceAll(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, ".").length;
-}
-/**
-* Measure the width of a string containing ANSI control characters.
-* @param s - string to measure with width in characters.
-* @returns the approximate number of screen characters.
-*/
-function ansiWidth(s) {
-	return width(stripVTControlCharacters(s));
-}
-function fragmentString(str, splitOnRegex, sType) {
-	const fragments = [];
-	let lastIndex = 0;
-	for (const match of str.matchAll(new RegExp(splitOnRegex))) {
-		if (match.index > lastIndex) fragments.push({
-			type: "text",
-			text: str.slice(lastIndex, match.index)
-		});
-		fragments.push({
-			type: sType,
-			text: match[0]
-		});
-		lastIndex = match.index + match[0].length;
-	}
-	if (lastIndex < str.length) fragments.push({
-		type: "text",
-		text: str.slice(lastIndex)
-	});
-	return fragments;
-}
-const ansi = ansiRegex();
-function parseAnsiStr(str) {
-	return fragmentString(str, ansi, "ansi");
-}
-/**
-* Prune the end of a string to fit within a specified width, adding an ellipsis if necessary.
-* @param str - the text to prune - ANSI is supported
-* @param maxWidth - the maximum width of the text
-* @param pad - the string to use for padding, default is '…'
-* @returns the pruned text
-*/
-function pruneAnsiTextEnd(str, maxWidth, pad = "…") {
-	if (!maxWidth || maxWidth <= 0) return str;
-	if (str.length <= maxWidth) return str;
-	if (ansiWidth(str) <= maxWidth) return str;
-	const padWidth = ansiWidth(pad);
-	const fragments = parseAnsiStr(str);
-	let remaining = maxWidth - padWidth;
-	for (const frag of fragments) {
-		if (frag.type !== "text") continue;
-		if (remaining <= 0) {
-			frag.text = "";
-			continue;
-		}
-		const pruned = pruneTextEnd(frag.text, remaining, pad);
-		if (pruned !== frag.text) {
-			frag.text = pruned;
-			remaining = 0;
-			continue;
-		}
-		remaining -= width(frag.text);
-	}
-	return fragments.map((frag) => frag.text).join("");
-}
-/**
-* Prune the start of a string to fit within a specified width, adding an ellipsis if necessary.
-* @param str - the text to prune - ANSI is supported
-* @param maxWidth - the maximum width of the text
-* @param pad - the string to use for padding, default is '…'
-* @returns the pruned text
-*/
-function pruneAnsiTextStart(str, maxWidth, pad = "…") {
-	if (!maxWidth || maxWidth <= 0) return str;
-	if (str.length <= maxWidth) return str;
-	if (ansiWidth(str) <= maxWidth) return str;
-	const padWidth = ansiWidth(pad);
-	const fragments = parseAnsiStr(str);
-	let remaining = maxWidth - padWidth;
-	for (const frag of fragments.reverse()) {
-		if (frag.type !== "text") continue;
-		if (remaining <= 0) {
-			frag.text = "";
-			continue;
-		}
-		const pruned = pruneTextStart(frag.text, remaining, pad);
-		if (pruned !== frag.text) {
-			frag.text = pruned;
-			remaining = 0;
-			continue;
-		}
-		remaining -= width(frag.text);
-	}
-	return fragments.reverse().map((frag) => frag.text).join("");
-}
-/**
-* Prune the end of a string to fit within a specified width, adding an ellipsis if necessary.
-* @param str - the text to prune - ANSI is not supported
-* @param maxWidth - the maximum width of the text
-* @param pad - the string to use for padding, default is '…'
-* @returns the pruned text
-*/
-function pruneTextEnd(str, maxWidth, pad = "…") {
-	if (!maxWidth || maxWidth <= 0) return str;
-	if (str.length <= maxWidth) return str;
-	if (isAnsiString(str)) return pruneAnsiTextEnd(str, maxWidth, pad);
-	const maxWidthWithPad = maxWidth - width(pad);
-	const letters = [...str];
-	let len = 0;
-	for (let i = 0; i < letters.length; i++) {
-		const c = letters[i];
-		len += width(c);
-		if (len > maxWidthWithPad) {
-			let j = i + 1;
-			while (j < letters.length && width(letters[j]) === 0) ++j;
-			return j === letters.length ? str : letters.slice(0, i).join("") + pad;
-		}
-	}
-	return str;
-}
-/**
-* Prune the start of a string to fit within a specified width, adding an ellipsis if necessary.
-* @param str - the text to prune - ANSI is not supported
-* @param maxWidth - the maximum width of the text
-* @param pad - the string to use for padding, default is '…'
-* @returns the pruned text
-*/
-function pruneTextStart(str, maxWidth, pad = "…") {
-	if (!maxWidth || maxWidth <= 0) return str;
-	if (str.length <= maxWidth) return str;
-	const maxWidthWithPad = maxWidth - width(pad);
-	const letters = [...str];
-	let len = 0;
-	for (let i = letters.length - 1; i >= 1; i--) {
-		const c = letters[i];
-		len += width(c);
-		if (len > maxWidthWithPad) {
-			i += 1;
-			while (i < letters.length && width(letters[i]) === 0) ++i;
-			return pad + letters.slice(i).join("");
-		}
-	}
-	return str;
-}
-
 //#endregion
 //#region src/util/wrap.ts
 const wrapSep = /\s+|(?<=,)|\.(?=\w)/g;
@@ -2200,157 +2360,137 @@ function writeStream(stream, data) {
 }
 
 //#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;
-	const timer = getTimeMeasurer();
-	const logDictRequests = truthy(getEnvironmentVariable("CSPELL_ENABLE_DICTIONARY_LOGGING"));
-	if (logDictRequests) _debug.cacheDictionaryEnableLogging(true);
-	const lintResult = await run();
-	if (logDictRequests) await writeDictionaryLog();
-	await reporter.result(lintResult);
-	const elapsed = timer();
-	if (getFeatureFlags().getFlag("timer")) console.log(`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
-			};
+//#region src/util/extractContext.ts
+function prefCharIndex(text, offset, count = 1) {
+	if (offset - count < 0) return 0;
+	for (; count > 0 && offset > 0; count--) {
+		let code = text.charCodeAt(--offset) || 0;
+		if (code === 65039) code = text.charCodeAt(--offset) || 0;
+		offset -= (code & 64512) === 56320 ? 1 : 0;
+	}
+	return offset < 0 ? 0 : offset;
+}
+function nextCharIndex(text, offset, count = 1) {
+	if (offset + count >= text.length) return text.length;
+	for (; count > 0 && offset < text.length; count--) {
+		const code = text.charCodeAt(offset++) || 0;
+		offset += (code & 64512) === 55296 ? 1 : 0;
+		if (text.charCodeAt(offset) === 65039) offset++;
+	}
+	return offset > text.length ? text.length : offset;
+}
+function lineContext(lineText, start, end, contextRange) {
+	let left = prefCharIndex(lineText, start, contextRange);
+	let right = nextCharIndex(lineText, end, contextRange);
+	const isLetter = /^\p{L}$/u;
+	const isMark = /^\p{M}$/u;
+	for (let n = contextRange / 2; n > 0 && left > 0; n--, left--) {
+		const c = lineText[left - 1];
+		if (isMark.test(c)) {
+			if (!isLetter.test(lineText[left - 2])) break;
+			left--;
+			continue;
 		}
+		if (!isLetter.test(lineText[left - 1])) break;
+	}
+	for (let n = contextRange / 2; n > 0 && right < lineText.length; n--, right++) {
+		if (!isLetter.test(lineText[right])) break;
+		if (isMark.test(lineText[right + 1])) right++;
+	}
+	left = left < 0 ? 0 : left;
+	const t0 = lineText.slice(left, right);
+	const tLeft = t0.trimStart();
+	left = Math.min(left + t0.length - tLeft.length, start);
+	return {
+		text: tLeft.trimEnd(),
+		offset: left
+	};
+}
+function extractContext(tdo, contextRange) {
+	const { line, offset, text } = tdo;
+	const start = offset - line.offset;
+	const context = lineContext(line.text, start, start + text.length, contextRange);
+	context.offset += line.offset;
+	return context;
+}
+
+//#endregion
+//#region src/lint/LinterError.ts
+var LinterError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+	toString() {
+		return this.message;
+	}
+};
+
+//#endregion
+//#region src/lint/processFile.ts
+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$1?.reportIssueOptions;
+	const cachedResult = await cache.getCachedLintResults(filename);
+	if (cachedResult) {
+		reporter.debug(`Filename: ${filename}, using cache`);
 		return {
-			filename,
-			result: fetch$1().catch((e) => toApplicationError(e))
+			...cachedResult,
+			elapsedTimeMs: getElapsedTimeMs(),
+			reportIssueOptions: {
+				...cachedResult.reportIssueOptions,
+				...reportIssueOptions
+			}
 		};
 	}
-	async function processFile(filename, configInfo, cache, prefetch$1) {
-		if (prefetch$1?.fileResult) return prefetch$1.fileResult;
-		const getElapsedTimeMs = getTimeMeasurer();
-		const reportIssueOptions = prefetch$1?.reportIssueOptions;
-		const cachedResult = await cache.getCachedLintResults(filename);
-		if (cachedResult) {
-			reporter.debug(`Filename: ${filename}, using cache`);
-			return {
-				...cachedResult,
-				elapsedTimeMs: getElapsedTimeMs(),
-				reportIssueOptions: {
-					...cachedResult.reportIssueOptions,
-					...reportIssueOptions
-				}
-			};
-		}
-		const result = {
-			fileInfo: { filename },
-			issues: [],
-			processed: false,
-			errors: 0,
-			configErrors: 0,
-			elapsedTimeMs: 0,
-			reportIssueOptions
-		};
-		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}"`);
-				reporter.error("Linter:", err);
-				result.errors += 1;
-			}
-			return result;
-		}
-		const doc = fileInfoToDocument(fileInfo, cfg.options.languageId, cfg.locale);
-		const { text } = fileInfo;
-		result.fileInfo = fileInfo;
-		let spellResult = {};
-		try {
-			const { showSuggestions: generateSuggestions, validateDirectives, skipValidation } = cfg.options;
-			const numSuggestions = configInfo.config.numSuggestions ?? 5;
-			const r = await spellCheckDocument(doc, clean({
-				generateSuggestions,
-				numSuggestions,
-				validateDirectives,
-				skipValidation
-			}), configInfo.config);
-			spellResult = r;
-			result.processed = r.checked;
-			result.perf = r.perf ? { ...r.perf } : void 0;
-			result.issues = Text.calculateTextDocumentOffsets(doc.uri, text, r.issues).map(mapIssue);
-		} catch (e) {
-			reporter.error(`Failed to process "${filename}"`, toError(e));
+	const result = {
+		fileInfo: { filename },
+		issues: [],
+		processed: false,
+		errors: 0,
+		configErrors: 0,
+		elapsedTimeMs: 0,
+		reportIssueOptions
+	};
+	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}"`);
+			reporter.error("Linter:", err);
 			result.errors += 1;
 		}
-		result.elapsedTimeMs = getElapsedTimeMs();
-		const config = spellResult.settingsUsed ?? {};
-		result.reportIssueOptions = mergeReportIssueOptions(spellResult.settingsUsed || configInfo.config, reportIssueOptions);
-		result.configErrors += await reportConfigurationErrors(config);
-		reportCheckResult(result, doc, spellResult, configInfo, config);
-		const dep = calcDependencies(config);
-		await cache.setCachedLintResults(result, dep.files);
 		return result;
 	}
-	function reportCheckResult(result, _doc, spellResult, configInfo, config) {
-		const elapsed$1 = result.elapsedTimeMs || 0;
-		const dictionaries = config.dictionaries || [];
-		if (verboseLevel > 1) {
-			const dictsUsed = [...dictionaries].sort().map((name$1) => chalk.green(name$1)).join(", ");
-			const msg = unindent`
-                    File type: ${config.languageId}, Language: ${config.language}, Issues: ${result.issues.length} ${elapsed$1.toFixed(2)}ms
-                    Config file Used: ${relativeToCwd(spellResult.localConfigFilepath || configInfo.source, cfg.root)}
-                    Dictionaries Used:
-                      ${wordWrapAnsiText(dictsUsed, 70)}`;
-			reporter.info(indent(msg, "  "), MessageTypes.Info);
-		}
-		if (cfg.options.debug) {
-			const { enabled, language, languageId, dictionaries: dictionaries$1 } = config;
-			const msg = unindent`\
-                Debug Config: ${formatWithOptions({
-				depth: 2,
-				colors: useColor
-			}, {
-				languageId,
-				enabled,
-				language,
-				dictionaries: dictionaries$1
-			})}`;
-			reporter.debug(msg);
-		}
-	}
+	const doc = fileInfoToDocument(fileInfo, cfg.options.languageId, cfg.locale);
+	const { text } = fileInfo;
+	result.fileInfo = fileInfo;
+	let spellResult = {};
+	try {
+		const { showSuggestions: generateSuggestions, validateDirectives, skipValidation } = cfg.options;
+		const numSuggestions = configInfo.config.numSuggestions ?? 5;
+		const r = await spellCheckDocument(doc, clean({
+			generateSuggestions,
+			numSuggestions,
+			validateDirectives,
+			skipValidation
+		}), userSettings);
+		spellResult = r;
+		result.processed = r.checked;
+		result.perf = r.perf ? { ...r.perf } : void 0;
+		result.issues = Text.calculateTextDocumentOffsets(doc.uri, text, r.issues).map(mapIssue);
+	} catch (e) {
+		reporter.error(`Failed to process "${filename}"`, toError$1(e));
+		result.errors += 1;
+	}
+	result.elapsedTimeMs = getElapsedTimeMs();
+	const config = spellResult.settingsUsed ?? {};
+	result.reportIssueOptions = mergeReportIssueOptions(spellResult.settingsUsed || configInfo.config, reportIssueOptions);
+	result.configErrors += reportSpellingResultConfigErrors(spellResult, processFileOptions);
+	reportCheckResult(result, doc, spellResult, config, processFileOptions);
+	const dep = calcDependencies(config);
+	await cache.setCachedLintResults(result, dep.files);
+	return result;
 	function mapIssue({ doc: _, ...tdo }) {
 		const context = cfg.showContext ? extractContext(tdo, cfg.showContext) : void 0;
 		return clean({
@@ -2358,142 +2498,427 @@ async function runLint(cfg) {
 			context
 		});
 	}
-	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;
+}
+function reportCheckResult(result, _doc, spellResult, config, processFileOptions) {
+	const { configInfo, reporter, verboseLevel, useColor, cfg, chalk: chalk$1 } = processFileOptions;
+	const elapsed = result.elapsedTimeMs || 0;
+	const dictionaries = config.dictionaries || [];
+	if (verboseLevel > 1) {
+		const dictsUsed = [...dictionaries].sort().map((name$1) => chalk$1.green(name$1)).join(", ");
+		const msg = unindent`
+                    File type: ${config.languageId}, Language: ${config.language}, Issues: ${result.issues.length} ${elapsed.toFixed(2)}ms
+                    Config file Used: ${relativeToCwd(spellResult.localConfigFilepath || configInfo.source, cfg.root)}
+                    Dictionaries Used:
+                      ${wordWrapAnsiText(dictsUsed, 70)}`;
+		reporter.info(indent(msg, "  "), MessageTypes.Info);
+	}
+	if (cfg.options.debug) {
+		const { enabled, language, languageId, dictionaries: dictionaries$1 } = config;
+		const msg = unindent`\
+                Debug Config: ${formatWithOptions({
+			depth: 2,
+			colors: useColor
+		}, {
+			languageId,
+			enabled,
+			language,
+			dictionaries: dictionaries$1
+		})}`;
+		reporter.debug(msg);
+	}
+}
+function calcDependencies(config) {
+	const { configFiles, dictionaryFiles } = extractDependencies(config);
+	return { files: [...configFiles, ...dictionaryFiles] };
+}
+function reportConfigurationErrors(config, processFileOptions) {
+	return reportImportErrors(extractImportErrors(config), processFileOptions);
+}
+function reportImportErrors(errors, processFileOptions) {
+	const { reporter, configErrors } = processFileOptions;
+	let count = 0;
+	errors.forEach((ref) => {
+		const key = ref.error.toString();
+		if (configErrors.has(key)) return;
+		configErrors.add(key);
+		count += 1;
+		reporter.error("Configuration", ref.error);
+	});
+	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;
+			configErrors.add(key);
+			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;
 		}
-		async function* prefetchFilesAsync(files$1) {
-			for await (const filename of files$1) yield prefetch(filename, configInfo, cache);
+	}
+	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 emptyResult = {
-			fileInfo: { filename: "" },
-			issues: [],
-			processed: false,
-			errors: 0,
-			configErrors: 0,
-			elapsedTimeMs: 1,
-			reportIssueOptions: void 0
+		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."
 		};
-		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, configInfo, cache, fetchResult)
+		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()}`
 			};
 		}
-		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);
+		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;
 		}
-		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;
+		if (BATCH_PROCESS_SIZE <= 1) {
+			for (const pf of prefetchFiles(files)) {
+				await pf.result;
+				yield processPrefetchFileResult(pf);
 			}
-			status.errors += result.configErrors;
+			return;
 		}
-		await cache.reconcile();
-		return status;
-	}
-	function calcDependencies(config) {
-		const { configFiles, dictionaryFiles } = extractDependencies(config);
-		return { files: [...configFiles, ...dictionaryFiles] };
-	}
-	async function reportConfigurationErrors(config) {
-		const errors = extractImportErrors(config);
-		let count = 0;
-		errors.forEach((ref) => {
-			const key = ref.error.toString();
-			if (configErrors.has(key)) return;
-			configErrors.add(key);
-			count += 1;
-			reporter.error("Configuration", ref.error);
-		});
-		(await getDictionary(config)).dictionaries.forEach((dict) => {
-			const dictErrors = dict.getErrors?.() || [];
-			const msg = `Dictionary Error with (${dict.name})`;
-			dictErrors.forEach((error) => {
-				const key = msg + error.toString();
-				if (configErrors.has(key)) return;
-				configErrors.add(key);
-				count += 1;
-				reporter.error(msg, error);
+		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 count;
-	}
-	function countConfigErrors(configInfo) {
-		return reportConfigurationErrors(configInfo.config);
+		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 { 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);
+	const lintResult = await run();
+	if (logDictRequests) await writeDictionaryLog();
+	await reporter.result(lintResult);
+	const elapsed = timer();
+	if (getFeatureFlags().getFlag("timer") || verboseLevel >= 1 || cfg.options.showPerfSummary) console.error(`Elapsed Time: ${elapsed.toFixed(2)}ms`);
+	return lintResult;
 	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);
-		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.Info);
-		const configErrors$1 = await countConfigErrors(configInfo);
-		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) {
@@ -2509,7 +2934,19 @@ async function runLint(cfg) {
                     files:     ${formattedFiles}
                     wordsOnly: ${yesNo(!!cfg.options.wordsOnly)}
                     unique:    ${yesNo(!!cfg.options.unique)}
-                `, MessageTypes.Info);
+                `, MessageTypes$1.Info);
+	}
+	function getProcessFileOptions(configInfo) {
+		return {
+			reporter,
+			chalk,
+			configInfo,
+			cfg,
+			verboseLevel,
+			useColor,
+			configErrors,
+			userSettings: configInfo.config
+		};
 	}
 }
 function checkGlobs(globs, reporter) {
@@ -2531,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;
@@ -2541,7 +2994,7 @@ async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
 		const globsToExclude = globsToExcludeRaw.filter((g) => !globPattern(g).startsWith("!"));
 		if (globsToExclude.length !== globsToExcludeRaw.length) {
 			const msg = `Negative glob exclusions are not supported: ${globsToExcludeRaw.map((g) => globPattern(g)).filter((g) => g.startsWith("!")).join(", ")}`;
-			reporter.info(msg, MessageTypes.Warning);
+			reporter.info(msg, MessageTypes$1.Warning);
 		}
 		const globMatcher = buildGlobMatcher(globsToExclude, root, true);
 		const globOptions = {
@@ -2558,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;
@@ -2567,13 +3020,13 @@ async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
 		const r = globMatcherExclude.matchEx(absFilename);
 		if (r.matched) {
 			const { glob: glob$2, source } = extractGlobSource(r.pattern);
-			if (calcVerboseLevel(cfg.options) > 1) reporter.info(`Excluded File: ${path$1.relative(root, absFilename)}; Excluded by ${glob$2} from ${source}`, MessageTypes.Info);
+			if (calcVerboseLevel(cfg.options) > 1) reporter.info(`Excluded File: ${path$1.relative(root, absFilename)}; Excluded by ${glob$2} from ${source}`, MessageTypes$1.Info);
 		}
 		return r.matched;
 	}
 	function filterOutExcludedFilesFn(globMatcherExclude) {
 		const excludeInfo = globMatcherExclude.patterns.map(extractGlobSource).map(({ glob: glob$2, source }) => `Glob: ${glob$2} from ${source}`).filter(uniqueFn());
-		if (calcVerboseLevel(cfg.options) > 1) reporter.info(`Exclusion Globs: \n    ${excludeInfo.join("\n    ")}\n`, MessageTypes.Info);
+		if (calcVerboseLevel(cfg.options) > 1) reporter.info(`Exclusion Globs: \n    ${excludeInfo.join("\n    ")}\n`, MessageTypes$1.Info);
 		return (filename) => !isExcluded(filename, globMatcherExclude);
 	}
 	return _determineFilesToCheck();
@@ -2585,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";
 }
@@ -2653,30 +3096,15 @@ async function* concatAsyncIterables(...iterables) {
 }
 async function writeDictionaryLog() {
 	const fields = (getEnvironmentVariable("CSPELL_ENABLE_DICTIONARY_LOG_FIELDS") || "time, word, value").split(",").map((f) => f.trim());
-	const data = fields.join(", ") + "\n" + _debug.cacheDictionaryGetLog().filter((d) => d.method === "has").map((d) => fields.map((f) => f in d ? `${d[f]}` : "").join(", ")).join("\n") + "\n";
+	const data = fields.join(", ") + "\n" + dictionaryCacheGetLog().filter((d) => d.method === "has").map((d) => fields.map((f) => f in d ? `${d[f]}` : "").join(", ")).join("\n") + "\n";
 	await writeFileOrStream(getEnvironmentVariable("CSPELL_ENABLE_DICTIONARY_LOG_FILE") || "cspell-dictionary-log.csv", data);
 }
 function globPattern(g) {
 	return typeof g === "string" ? g : g.glob;
 }
-var LinterError = class extends Error {
-	constructor(message) {
-		super(message);
-	}
-	toString() {
-		return this.message;
-	}
-};
 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
@@ -3010,5 +3438,5 @@ function parseApplicationFeatureFlags(flags) {
 }
 
 //#endregion
-export { console as C, CheckFailed as S, unindent as _, parseApplicationFeatureFlags as a, getReporter as b, listDictionaries as c, ansiWidth as d, pruneAnsiTextEnd as f, validateUnitSize as g, width as h, lint as i, ReportChoicesAll as l, pruneTextEnd as m, checkText as n, suggestions as o, pruneAnsiTextStart as p, createInit as r, trace as s, IncludeExcludeFlag as t, cvtLinterCliCommandOptionsToLinterCliOptions as u, DEFAULT_CACHE_LOCATION as v, ApplicationError as x, npmPackage as y };
-//# sourceMappingURL=application-DCyfKhGm.js.map
+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-DaQrXF9X.js.map