cspell 9.3.2 → 9.6.0

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

@@ -1,12 +1,13 @@
 import { createRequire } from "node:module";
-import chalk, { Chalk } from "chalk";
 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, getDictionary, getGlobalSettingsAsync, getSystemFeatureFlags, isBinaryFile, isSpellingDictionaryLoadError, mergeSettings, setLogger, shouldCheckDocument, spellCheckDocument, suggestionsForWords, traceWordsAsync } from "cspell-lib";
 import assert from "node:assert";
-import { format, formatWithOptions } from "node:util";
+import { 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";
@@ -14,13 +15,13 @@ import { fileURLToPath } from "node:url";
 import * as path$1 from "node:path";
 import path, { isAbsolute, posix, relative, resolve, sep } from "node:path";
 import { opMap as opMap$1, pipe } from "@cspell/cspell-pipe/sync";
-import { IssueType, MessageTypes, unknownWordsChoices } from "@cspell/cspell-types";
-import { _debug } from "cspell-dictionary";
+import { 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";
 import streamConsumers from "node:stream/consumers";
-import { readFileText, toURL } from "cspell-io";
+import { getStat, readFileText, toURL } from "cspell-io";
 import { glob } from "tinyglobby";
 import * as readline from "node:readline";
 import { parse, stringify } from "flatted";
@@ -88,7 +89,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 });
@@ -108,10 +109,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;
@@ -199,9 +539,10 @@ function reportProgressFileComplete(io, p, cwd, options) {
 	const { idx, filename } = determineFilename(io, p, cwd);
 	const { verbose, debug } = options;
 	const time = reportTime(io, p.elapsedTimeMs, !!p.cached);
-	const skipped = p.processed === false ? " skipped" : "";
+	const skippedReason = p.skippedReason ? ` (${p.skippedReason})` : "";
+	const skipped = p.processed === false ? ` skipped${skippedReason}` : "";
 	const hasErrors = p.numErrors ? io.chalk.red` X` : "";
-	const msg = `${idx} ${filename} ${time}${skipped}${hasErrors}${(skipped && (verbose || debug) || hasErrors || isSlow(p.elapsedTimeMs) || io.getColorLevel() < 1 ? "\n" : "") || "\r"}`;
+	const msg = `${idx} ${filename} ${time}${skipped}${hasErrors}${(verbose || debug || hasErrors || isSlow(p.elapsedTimeMs) || io.getColorLevel() < 1 ? "\n" : "") || "\r"}`;
 	io.write(msg);
 }
 function reportTime(io, elapsedTimeMs, cached) {
@@ -275,8 +616,9 @@ function getReporter(options, config) {
 	}
 	const resultEmitter = (result) => {
 		if (!fileGlobs.length && !result.files) return;
-		const { files, issues: issues$1, cachedFiles, filesWithIssues, errors } = result;
+		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);
@@ -286,9 +628,11 @@ function getReporter(options, config) {
 			consoleError("Issues found:");
 			issuesCollection.forEach((issue) => consoleError(issue));
 		}
+		const filesChecked = files - (skippedFiles || 0);
 		const cachedFilesText = cachedFiles ? ` (${cachedFiles} from cache)` : "";
+		const skippedFilesText = skippedFiles ? `, skipped: ${skippedFiles}` : "";
 		const withErrorsText = errors ? ` with ${errors} error${errors === 1 ? "" : "s"}` : "";
-		consoleError(`CSpell\u003A Files checked: ${files}${cachedFilesText}, Issues found: ${issues$1} in ${numFilesWithIssues === 1 ? "1 file" : `${numFilesWithIssues} files`}${withErrorsText}.`);
+		consoleError(`CSpell\u003A Files checked: ${filesChecked}${cachedFilesText}${skippedFilesText}, Issues found: ${issues$1} in ${numFilesWithIssues === 1 ? "1 file" : `${numFilesWithIssues} files`}${withErrorsText}.`);
 		if (errorCollection?.length && issues$1 > 5) {
 			consoleError("-------------------------------------------");
 			consoleError("Errors:");
@@ -301,14 +645,80 @@ function getReporter(options, config) {
 			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`);
+			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++;
@@ -334,6 +744,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+/, " ");
@@ -443,7 +874,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;
 	}
 }
@@ -766,7 +1197,7 @@ const pkgDir = _dirname;
 //#endregion
 //#region src/pkgInfo.ts
 const name = "cspell";
-const version$1 = "9.3.2";
+const version$1 = "9.6.0";
 const engines = { node: ">=20" };
 const npmPackage = {
 	name,
@@ -987,7 +1418,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,
@@ -999,6 +1430,11 @@ function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
 		}) : Promise.reject(new IOError(`Error reading file: "${filename}"`, error));
 	});
 }
+async function getFileSize(filename) {
+	const s = await getStat(filename);
+	if (!(s instanceof Error)) return s.size;
+	throw s;
+}
 function readFile(filename, encoding = UTF8) {
 	return readFileInfo(filename, encoding).then((info) => info.text);
 }
@@ -1172,7 +1608,7 @@ var ImplFileEntryCache = class {
 			return {
 				key: file,
 				notFound: true,
-				err: toError$1(error)
+				err: toError(error)
 			};
 		}
 		if (this.useChecksum) return this.#getFileDescriptorUsingChecksum(file);
@@ -1287,7 +1723,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 });
@@ -1376,7 +1812,7 @@ var DiskCache = class {
 			cached
 		};
 	}
-	async setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __,...result }, dependsUponFiles) {
+	async setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }, dependsUponFiles) {
 		const fileDescriptor = await this.fileEntryCache.getFileDescriptor(fileInfo.filename);
 		const meta = fileDescriptor.meta;
 		if (fileDescriptor.notFound || !meta) return;
@@ -1397,7 +1833,7 @@ var DiskCache = class {
 		this.ocCacheFileResult = new ShallowObjectCollection();
 	}
 	normalizeResult(result) {
-		const { issues, processed, errors, configErrors, reportIssueOptions,...rest } = result;
+		const { issues, processed, errors, configErrors, reportIssueOptions, ...rest } = result;
 		if (!Object.keys(rest).length) return this.ocCacheFileResult.get(result);
 		return this.ocCacheFileResult.get({
 			issues,
@@ -1638,61 +2074,6 @@ 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;
-}
-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/util/prefetch.ts
 function* prefetchIterable(iterable, size) {
@@ -1741,7 +2122,7 @@ async function loadReporters(reporters, defaultReporter, config) {
 			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}`);
+			throw new ApplicationError(`Failed to load reporter ${moduleName}: ${toError$1(e).message}`);
 		}
 	}
 	reporters = !reporters || !reporters.length ? ["default"] : [...reporters];
@@ -1852,6 +2233,7 @@ var LintReporter = class {
 				filename,
 				elapsedTimeMs: result.elapsedTimeMs,
 				processed: result.processed,
+				skippedReason: result.skippedReason,
 				numErrors: numIssues || result.errors,
 				cached: result.cached,
 				perf: result.perf,
@@ -1872,6 +2254,144 @@ function getTimeMeasurer() {
 	return () => timer.elapsed;
 }
 
+//#endregion
+//#region src/util/unindent.ts
+/**
+* Indent each line of a multi-line string.
+* @param str - multi-line string to left pad
+* @param padding - the padding to use for all lines except the first.
+* @param firstLinePadding - optional padding of first line.
+* @returns
+*/
+function indent(str, padding, firstLinePadding = "") {
+	let pad$1 = firstLinePadding;
+	const lines = [];
+	for (const line of str.split("\n")) {
+		lines.push(pad$1 + line);
+		pad$1 = padding;
+	}
+	return lines.join("\n");
+}
+/**
+* Inject values into a template string while keeping indentation of multi-line values.
+* @param template - template string
+* @param values- values to inject
+* @returns the injected string
+*/
+function keepIndent(template, ...values) {
+	const strings = template;
+	const adjValues = [];
+	for (let i = 0; i < values.length; ++i) {
+		const prevLines = strings[i].split("\n");
+		const currLine = prevLines[prevLines.length - 1];
+		const padLen = padLength(currLine);
+		const padding = " ".repeat(padLen);
+		adjValues.push(indent(`${values[i]}`, padding));
+	}
+	return String.raw({ raw: strings }, ...adjValues);
+}
+/**
+* Calculate the padding at the start of the string.
+* @param s - string to evaluate
+* @returns number of padding characters
+*/
+function padLength(s) {
+	return s.length - s.trimStart().length;
+}
+function unindent(templateOrString, ...values) {
+	return unindentString(typeof templateOrString === "string" ? templateOrString : keepIndent(templateOrString, ...values));
+}
+function unindentString(str) {
+	const lines = str.split("\n");
+	let curPad = str.length;
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		curPad = Math.min(curPad, padLength(line));
+	}
+	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;
+function wordWrapAnsiText(str, maxWidth, indent$1 = "", sep$1 = wrapSep) {
+	if (!maxWidth || maxWidth <= 0) return str;
+	if (str.length <= maxWidth) return str;
+	if (str.includes("\n")) return str.split("\n").map((line$1) => wordWrapAnsiText(line$1, maxWidth, indent$1)).join("\n");
+	const fragments = fragmentString(str, sep$1, "sep");
+	const lines = [];
+	let line = "";
+	for (const text of joinFragments(fragments)) {
+		const lineWidth = ansiWidth(line);
+		const textWidth = ansiWidth(text);
+		if (line && lineWidth + textWidth > maxWidth) {
+			if (line) lines.push(line);
+			line = indent$1 + text.trimStart();
+			continue;
+		}
+		line += text;
+	}
+	if (line) lines.push(line);
+	return lines.join("\n");
+}
+function* joinFragments(fragments) {
+	let last;
+	for (const frag of fragments) {
+		if (frag.type === "sep") {
+			if (last) yield last.text;
+			last = frag;
+			continue;
+		}
+		yield last ? last.text + frag.text : frag.text;
+		last = void 0;
+	}
+	if (last) yield last.text;
+}
+
 //#endregion
 //#region src/util/writeFile.ts
 async function writeFileOrStream(filename, data) {
@@ -1895,6 +2415,206 @@ function writeStream(stream, data) {
 	});
 }
 
+//#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;
+}
+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, processFileOptions) {
+	if (prefetch?.fileResult) return prefetch.fileResult;
+	const { reporter, cfg, configInfo } = processFileOptions;
+	const getElapsedTimeMs = getTimeMeasurer();
+	const reportIssueOptions = prefetch?.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?.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$1(e));
+		result.errors += 1;
+	}
+	result.elapsedTimeMs = getElapsedTimeMs();
+	const config = spellResult.settingsUsed ?? {};
+	result.reportIssueOptions = mergeReportIssueOptions(spellResult.settingsUsed || configInfo.config, reportIssueOptions);
+	result.configErrors += await reportConfigurationErrors(config, 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({
+			...tdo,
+			context
+		});
+	}
+}
+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] };
+}
+async function reportConfigurationErrors(config, processFileOptions) {
+	const { reporter, configErrors } = processFileOptions;
+	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);
+		});
+	});
+	return count;
+}
+function countConfigErrors(configInfo, processFileOptions) {
+	return reportConfigurationErrors(configInfo.config, processFileOptions);
+}
+
 //#endregion
 //#region src/lint/lint.ts
 const version = npmPackage.version;
@@ -1903,9 +2623,11 @@ 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);
+	if (logDictRequests) dictionaryCacheEnableLogging(true);
 	const lintResult = await run();
 	if (logDictRequests) await writeDictionaryLog();
 	await reporter.result(lintResult);
@@ -1915,7 +2637,10 @@ async function runLint(cfg) {
 	function prefetch(filename, configInfo, cache) {
 		if (isBinaryFile$1(filename, cfg.root)) return {
 			filename,
-			result: Promise.resolve({ skip: true })
+			result: Promise.resolve({
+				skip: true,
+				skipReason: "Binary file."
+			})
 		};
 		const reportIssueOptions = extractReporterIssueOptions(configInfo.config);
 		async function fetch$1() {
@@ -1929,7 +2654,18 @@ async function runLint(cfg) {
 				} };
 			}
 			const uri = filenameToUri(filename, cfg.root).href;
-			if (!(await shouldCheckDocument({ uri }, {}, configInfo.config)).shouldCheck) return { skip: true };
+			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
@@ -1937,97 +2673,8 @@ async function runLint(cfg) {
 		}
 		return {
 			filename,
-			result: fetch$1()
-		};
-	}
-	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
+			result: fetch$1().catch((e) => toApplicationError(e))
 		};
-		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 = {};
-		reporter.info(`Checking: ${filename}, File type: ${doc.languageId ?? "auto"}, Language: ${doc.locale ?? "default"}`, MessageTypes.Info);
-		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));
-			result.errors += 1;
-		}
-		result.elapsedTimeMs = getElapsedTimeMs();
-		const config = spellResult.settingsUsed ?? {};
-		result.reportIssueOptions = mergeReportIssueOptions(spellResult.settingsUsed || configInfo.config, reportIssueOptions);
-		result.configErrors += await reportConfigurationErrors(config);
-		const elapsed$1 = result.elapsedTimeMs;
-		const dictionaries = config.dictionaries || [];
-		reporter.info(`Checked: ${filename}, File type: ${config.languageId}, Language: ${config.language} ... Issues: ${result.issues.length} ${elapsed$1.toFixed(2)}ms`, MessageTypes.Info);
-		reporter.info(`Config file Used: ${spellResult.localConfigFilepath || configInfo.source}`, MessageTypes.Info);
-		reporter.info(`Dictionaries Used: ${dictionaries.join(", ")}`, MessageTypes.Info);
-		if (cfg.options.debug) {
-			const { id: _id, name: _name, __imports, __importRef,...cfg$1 } = config;
-			const debugCfg = {
-				filename,
-				languageId: doc.languageId ?? cfg$1.languageId ?? "default",
-				config: {
-					...cfg$1,
-					source: null
-				},
-				source: spellResult.localConfigFilepath
-			};
-			reporter.debug(JSON.stringify(debugCfg, void 0, 2));
-		}
-		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({
-			...tdo,
-			context
-		});
 	}
 	async function processFiles(files, configInfo, cacheSettings) {
 		const fileCount = Array.isArray(files) ? files.length : void 0;
@@ -2054,6 +2701,7 @@ async function runLint(cfg) {
 			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,
@@ -2061,13 +2709,14 @@ async function runLint(cfg) {
 				result: {
 					...emptyResult,
 					fileInfo: { filename },
-					elapsedTimeMs: getElapsedTimeMs()
+					elapsedTimeMs: getElapsedTimeMs(),
+					skippedReason: fetchResult.skipReason
 				}
 			};
 			return {
 				filename,
 				fileNum: index,
-				result: await processFile(filename, configInfo, cache, fetchResult)
+				result: await processFile(filename, cache, fetchResult, getProcessFileOptions(configInfo))
 			};
 		}
 		async function* loadAndProcessFiles() {
@@ -2082,6 +2731,7 @@ async function runLint(cfg) {
 			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));
@@ -2094,39 +2744,10 @@ async function runLint(cfg) {
 		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);
-			});
-		});
-		return count;
-	}
-	function countConfigErrors(configInfo) {
-		return reportConfigurationErrors(configInfo.config);
-	}
 	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({
@@ -2139,15 +2760,15 @@ async function runLint(cfg) {
 		const reporters = cfg.options.reporter ?? configInfo.config.reporters;
 		reporter.config = reporterConfig;
 		await reporter.loadReportersAndFinalize(reporters);
-		setLogger(getLoggerFromReporter(reporter));
+		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);
-		reporter.info(`Config Files Found:\n    ${configInfo.source}\n`, MessageTypes.Info);
-		const configErrors$1 = await countConfigErrors(configInfo);
+		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 {
@@ -2165,18 +2786,30 @@ async function runLint(cfg) {
 		}
 	}
 	function header(files, cliExcludes) {
+		if (verboseLevel < 2) return;
 		const formattedFiles = files.length > 100 ? [...files.slice(0, 100), "..."] : files;
-		reporter.info(`
-cspell;
-Date: ${(/* @__PURE__ */ new Date()).toUTCString()}
-Options:
-    verbose:   ${yesNo(!!cfg.options.verbose)}
-    config:    ${cfg.configFile || "default"}
-    exclude:   ${cliExcludes.join("\n               ")}
-    files:     ${formattedFiles}
-    wordsOnly: ${yesNo(!!cfg.options.wordsOnly)}
-    unique:    ${yesNo(!!cfg.options.unique)}
-`, MessageTypes.Info);
+		reporter.info(unindent`
+                cspell;
+                Date: ${(/* @__PURE__ */ new Date()).toUTCString()}
+                Options:
+                    verbose:   ${yesNo(!!cfg.options.verbose)}
+                    config:    ${cfg.configFile || "default"}
+                    exclude:   ${wordWrapAnsiText(cliExcludes.join(", "), 60, "  ")}
+                    files:     ${formattedFiles}
+                    wordsOnly: ${yesNo(!!cfg.options.wordsOnly)}
+                    unique:    ${yesNo(!!cfg.options.unique)}
+                `, MessageTypes$1.Info);
+	}
+	function getProcessFileOptions(configInfo) {
+		return {
+			reporter,
+			chalk,
+			configInfo,
+			cfg,
+			verboseLevel,
+			useColor,
+			configErrors
+		};
 	}
 }
 function checkGlobs(globs, reporter) {
@@ -2208,7 +2841,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 = {
@@ -2234,13 +2867,13 @@ async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
 		const r = globMatcherExclude.matchEx(absFilename);
 		if (r.matched) {
 			const { glob: glob$2, source } = extractGlobSource(r.pattern);
-			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());
-		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();
@@ -2265,13 +2898,14 @@ function runResult(init = {}) {
 function yesNo(value) {
 	return value ? "Yes" : "No";
 }
-function getLoggerFromReporter(reporter) {
+function getLoggerFromReporter(reporter, useColor) {
+	const inspectOptions = { colors: useColor };
 	const log = (...params) => {
-		const msg = format(...params);
+		const msg = formatWithOptions(inspectOptions, ...params);
 		reporter.info(msg, "Info");
 	};
 	const error = (...params) => {
-		const msg = format(...params);
+		const msg = formatWithOptions(inspectOptions, ...params);
 		reporter.error(msg, {
 			message: "",
 			name: "error",
@@ -2279,7 +2913,7 @@ function getLoggerFromReporter(reporter) {
 		});
 	};
 	const warn = (...params) => {
-		const msg = format(...params);
+		const msg = formatWithOptions(inspectOptions, ...params);
 		reporter.info(msg, "Warning");
 	};
 	return {
@@ -2319,20 +2953,22 @@ 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
@@ -2347,6 +2983,7 @@ var LintRequest = class {
 	fileLists;
 	files;
 	cspellSettingsFromCliOptions;
+	maxFileSize;
 	constructor(fileGlobs, options, reporter) {
 		this.fileGlobs = fileGlobs;
 		this.options = options;
@@ -2370,6 +3007,7 @@ var LintRequest = class {
 			...extractUnknownWordsConfig(options),
 			languageSettings
 		};
+		this.maxFileSize = options.maxFileSize ? sizeToNumber(options.maxFileSize) : void 0;
 	}
 };
 function mergeFiles(a, b) {
@@ -2411,10 +3049,19 @@ const ReportChoicesAll = [
 	"flagged"
 ];
 function fixLegacy(opts) {
-	const { local,...rest } = opts;
+	const { local, ...rest } = opts;
 	if (local && !rest.locale) rest.locale = local;
 	return rest;
 }
+function cvtLinterCliCommandOptionsToLinterCliOptions(options) {
+	const { verbose: verboseLevel, ...optionsRest } = options;
+	const cliOptions = { ...optionsRest };
+	if (verboseLevel) {
+		cliOptions.verboseLevel = verboseLevel;
+		cliOptions.verbose = true;
+	}
+	return cliOptions;
+}
 
 //#endregion
 //#region src/repl/index.ts
@@ -2655,5 +3302,5 @@ function parseApplicationFeatureFlags(flags) {
 }
 
 //#endregion
-export { parseApplicationFeatureFlags as a, listDictionaries as c, npmPackage as d, getReporter as f, console as h, lint as i, ReportChoicesAll as l, CheckFailed as m, checkText as n, suggestions as o, ApplicationError as p, createInit as r, trace as s, IncludeExcludeFlag as t, DEFAULT_CACHE_LOCATION as u };
-//# sourceMappingURL=application-CGIx5L0D.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-BJHh60xM.js.map