cspell 9.4.0 → 9.6.0

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

@@ -1,12 +1,13 @@
 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, getDictionary, 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";
@@ -14,8 +15,8 @@ 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";
@@ -25,7 +26,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 +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 });
@@ -109,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;
@@ -279,6 +618,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);
@@ -305,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++;
@@ -338,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+/, " ");
@@ -447,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;
 	}
 }
@@ -770,7 +1197,7 @@ const pkgDir = _dirname;
 //#endregion
 //#region src/pkgInfo.ts
 const name = "cspell";
-const version$1 = "9.4.0";
+const version$1 = "9.6.0";
 const engines = { node: ">=20" };
 const npmPackage = {
 	name,
@@ -991,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,
@@ -1181,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);
@@ -1296,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 });
@@ -1647,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) {
@@ -1750,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];
@@ -1892,11 +2264,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");
 }
@@ -1983,162 +2355,6 @@ function sizeToNumber(size) {
 	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;
@@ -2199,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;
@@ -2211,7 +2627,7 @@ async function runLint(cfg) {
 	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);
@@ -2260,104 +2676,6 @@ async function runLint(cfg) {
 			result: fetch$1().catch((e) => toApplicationError(e))
 		};
 	}
-	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));
-			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);
-		}
-	}
-	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;
 		const status = runResult();
@@ -2398,7 +2716,7 @@ async function runLint(cfg) {
 			return {
 				filename,
 				fileNum: index,
-				result: await processFile(filename, configInfo, cache, fetchResult)
+				result: await processFile(filename, cache, fetchResult, getProcessFileOptions(configInfo))
 			};
 		}
 		async function* loadAndProcessFiles() {
@@ -2426,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({
@@ -2478,8 +2767,8 @@ async function runLint(cfg) {
 		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 (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 {
@@ -2509,7 +2798,18 @@ 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
+		};
 	}
 }
 function checkGlobs(globs, reporter) {
@@ -2541,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 = {
@@ -2567,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);
-			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();
@@ -2653,20 +2953,12 @@ 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);
 }
@@ -3010,5 +3302,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-BJHh60xM.js.map