cspell 9.6.2 → 9.6.4

package/dist/esm/{application-BBOBF62T.js → application-DYABxs7R.js}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { isAsyncIterable, opFilter, opMap, opTap, operators, pipeAsync, pipeAsync as asyncPipe, toAsyncIterable, toAsyncIterable as mergeAsyncIterables } from "@cspell/cspell-pipe";
 import * as cspell from "cspell-lib";
-import { ENV_CSPELL_GLOB_ROOT, IncludeExcludeFlag, MessageTypes, SuggestionError, Text, checkTextDocument, combineTextAndLanguageSettings, createPerfTimer, extractDependencies, extractImportErrors, fileToDocument, getDefaultSettings, getGlobalSettingsAsync, getSystemFeatureFlags, isBinaryFile, isSpellingDictionaryLoadError, mergeSettings, setLogger, shouldCheckDocument, spellCheckDocument, suggestionsForWords, traceWordsAsync } from "cspell-lib";
+import { ENV_CSPELL_GLOB_ROOT, IncludeExcludeFlag, MessageTypes, SuggestionError, Text, checkTextDocument, combineTextAndLanguageSettings, createDictionaryReferenceCollection, createPerfTimer, extractDependencies, extractImportErrors, fileToDocument, getDefaultSettings, getGlobalSettingsAsync, getSystemFeatureFlags, isBinaryFile, isSpellingDictionaryLoadError, mergeSettings, setLogger, shouldCheckDocument, spellCheckDocument, suggestionsForWords, traceWordsAsync } from "cspell-lib";
 import assert from "node:assert";
 import { format, formatWithOptions, stripVTControlCharacters } from "node:util";
 import { isUrlLike, toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from "@cspell/url";
@@ -20,13 +20,13 @@ import { IssueType, MessageTypes as MessageTypes$1, unknownWordsChoices } from "
 import { dictionaryCacheEnableLogging, dictionaryCacheGetLog } from "cspell-dictionary";
 import { GitIgnore, findRepoRoot } from "cspell-gitignore";
 import { GlobMatcher, fileOrGlobToGlob, workaroundPicomatchBug } from "cspell-glob";
+import { dynamicImport } from "@cspell/dynamic-import";
 import crypto from "node:crypto";
 import streamConsumers from "node:stream/consumers";
 import { getStat, readFileText, toURL } from "cspell-io";
 import { glob } from "tinyglobby";
 import * as readline from "node:readline";
 import { parse, stringify } from "flatted";
-import { dynamicImport } from "@cspell/dynamic-import";
 
 //#region src/console.ts
 var ImplChannel = class {
@@ -150,7 +150,7 @@ function getPerfMeasurements() {
 		p.nestedTimeMs += m.duration;
 		return updateChild(p.children, m, p.depth + 1);
 	}
-	function updateChild(children, m, depth$1) {
+	function updateChild(children, m, depth) {
 		const p = children.get(m.name);
 		if (p) {
 			p.totalTimeMs += m.duration;
@@ -161,7 +161,7 @@ function getPerfMeasurements() {
 		}
 		const n = {
 			name: m.name,
-			depth: depth$1,
+			depth,
 			totalTimeMs: m.duration,
 			nestedTimeMs: 0,
 			count: 1,
@@ -236,20 +236,20 @@ function parseAnsiStr(str) {
 * @param pad - the string to use for padding, default is '…'
 * @returns the pruned text
 */
-function pruneAnsiTextEnd(str, maxWidth, pad$1 = "…") {
+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$1 = ansiWidth(pad$1);
+	const padWidth = ansiWidth(pad);
 	const fragments = parseAnsiStr(str);
-	let remaining = maxWidth - padWidth$1;
+	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$1);
+		const pruned = pruneTextEnd(frag.text, remaining, pad);
 		if (pruned !== frag.text) {
 			frag.text = pruned;
 			remaining = 0;
@@ -266,20 +266,20 @@ function pruneAnsiTextEnd(str, maxWidth, pad$1 = "…") {
 * @param pad - the string to use for padding, default is '…'
 * @returns the pruned text
 */
-function pruneAnsiTextStart(str, maxWidth, pad$1 = "…") {
+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$1 = ansiWidth(pad$1);
+	const padWidth = ansiWidth(pad);
 	const fragments = parseAnsiStr(str);
-	let remaining = maxWidth - padWidth$1;
+	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$1);
+		const pruned = pruneTextStart(frag.text, remaining, pad);
 		if (pruned !== frag.text) {
 			frag.text = pruned;
 			remaining = 0;
@@ -296,11 +296,11 @@ function pruneAnsiTextStart(str, maxWidth, pad$1 = "…") {
 * @param pad - the string to use for padding, default is '…'
 * @returns the pruned text
 */
-function pruneTextEnd(str, maxWidth, pad$1 = "…") {
+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$1);
-	const maxWidthWithPad = maxWidth - width(pad$1);
+	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++) {
@@ -309,7 +309,7 @@ function pruneTextEnd(str, maxWidth, pad$1 = "…") {
 		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 j === letters.length ? str : letters.slice(0, i).join("") + pad;
 		}
 	}
 	return str;
@@ -321,10 +321,10 @@ function pruneTextEnd(str, maxWidth, pad$1 = "…") {
 * @param pad - the string to use for padding, default is '…'
 * @returns the pruned text
 */
-function pruneTextStart(str, maxWidth, pad$1 = "…") {
+function pruneTextStart(str, maxWidth, pad = "…") {
 	if (!maxWidth || maxWidth <= 0) return str;
 	if (str.length <= maxWidth) return str;
-	const maxWidthWithPad = maxWidth - width(pad$1);
+	const maxWidthWithPad = maxWidth - width(pad);
 	const letters = [...str];
 	let len = 0;
 	for (let i = letters.length - 1; i >= 1; i--) {
@@ -333,7 +333,7 @@ function pruneTextStart(str, maxWidth, pad$1 = "…") {
 		if (len > maxWidthWithPad) {
 			i += 1;
 			while (i < letters.length && width(letters[i]) === 0) ++i;
-			return pad$1 + letters.slice(i).join("");
+			return pad + letters.slice(i).join("");
 		}
 	}
 	return str;
@@ -386,8 +386,8 @@ function tableToLines(table, deliminator) {
 	function getRCText(row, col, maxWidth) {
 		return getText(getCell(row, col), maxWidth);
 	}
-	function recordHeaderWidths(header$1) {
-		header$1.forEach((col, idx) => {
+	function recordHeaderWidths(header) {
+		header.forEach((col, idx) => {
 			columnWidths[idx] = Math.max(ansiWidth(col), columnWidths[idx] || 0);
 		});
 	}
@@ -397,19 +397,19 @@ function tableToLines(table, deliminator) {
 	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 toHeaderLine(header) {
+		return tableIndent + decorateRowWith(header.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() {
+	function* process() {
 		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);
+		return columnWidths.reduce((sum, width) => sum + width, 0);
 	}
 	function adjustColWidths() {
 		for (let i = 0; i < columnWidths.length; i++) {
@@ -444,13 +444,13 @@ function tableToLines(table, deliminator) {
 	recordHeaderWidths(simpleHeader);
 	recordColWidths();
 	adjustColWidths();
-	return [...process$1()];
+	return [...process()];
 }
 function headerDecorator(t) {
 	return chalk.bold(chalk.underline(t));
 }
 function decorateRowWith(row, ...decorators) {
-	return decorators.reduce((row$1, decorator) => row$1.map(decorator), row);
+	return decorators.reduce((row, decorator) => row.map(decorator), row);
 }
 
 //#endregion
@@ -618,9 +618,9 @@ function getReporter(options, config) {
 	}
 	const resultEmitter = (result) => {
 		if (!fileGlobs.length && !result.files) return;
-		const { files, issues: issues$1, cachedFiles, filesWithIssues, errors, skippedFiles } = result;
+		const { files, issues, cachedFiles, filesWithIssues, errors, skippedFiles } = result;
 		const numFilesWithIssues = filesWithIssues.size;
-		const chalk$1 = stderr.chalk;
+		const chalk = stderr.chalk;
 		if (stderr.getColorLevel() > 0) {
 			stderr.write("\r");
 			stderr.clearLine(0);
@@ -634,8 +634,8 @@ function getReporter(options, config) {
 		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: ${filesChecked}${cachedFilesText}${skippedFilesText}, Issues found: ${issues$1} in ${numFilesWithIssues === 1 ? "1 file" : `${numFilesWithIssues} files`}${withErrorsText}.`);
-		if (errorCollection?.length && issues$1 > 5) {
+		consoleError(`CSpell\u003A Files checked: ${filesChecked}${cachedFilesText}${skippedFilesText}, Issues found: ${issues} in ${numFilesWithIssues === 1 ? "1 file" : `${numFilesWithIssues} files`}${withErrorsText}.`);
+		if (errorCollection?.length && issues > 5) {
 			consoleError("-------------------------------------------");
 			consoleError("Errors:");
 			errorCollection.forEach((error) => consoleError(error));
@@ -650,7 +650,7 @@ function getReporter(options, config) {
 			consoleError(`  Processing Time : ${perfStats.accumulatedTimeMs.toFixed(2).padStart(9)}ms`);
 			consoleError(`  Total Time      : ${elapsedTotal.toFixed(2).padStart(9)}ms`);
 			const tableStats = {
-				title: chalk$1.bold("Perf Stats:"),
+				title: chalk.bold("Perf Stats:"),
 				header: ["Name", "Time (ms)"],
 				columnAlignments: ["L", "R"],
 				indent: 2,
@@ -665,15 +665,15 @@ function getReporter(options, config) {
 		const perfMeasurements = getPerfMeasurements();
 		if (!perfMeasurements.length) return;
 		const notable = extractNotableBySelfTimeInGroup(perfMeasurements);
-		const chalk$1 = stderr.chalk;
+		const chalk = 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;
+			const cbd = (text) => colorByDepth(chalk, m.depth, text);
+			const cNotable = (text) => notable.has(m) ? chalk.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))),
+				chalk.dim("⋅".repeat(m.depth)) + colorByDepthGrayscale(stderr.chalk, m.depth, m.name),
+				cbd(m.totalTimeMs.toFixed(2) + chalk.dim(depthIndicator(m.depth))),
 				cbd(cNotable((m.totalTimeMs - m.nestedTimeMs).toFixed(2))),
 				cbd(m.count.toString()),
 				cbd(m.minTimeMs.toFixed(2)),
@@ -682,7 +682,7 @@ function getReporter(options, config) {
 			];
 		});
 		const table = tableToLines({
-			title: chalk$1.bold("Detailed Measurements:"),
+			title: chalk.bold("Detailed Measurements:"),
 			header: [
 				"Name",
 				"Total Time (ms)",
@@ -707,21 +707,21 @@ function getReporter(options, config) {
 		consoleError("\n-------------------------------------------\n");
 		for (const line of table) consoleError(line);
 	}
-	function colorByDepth(chalk$1, depth, text) {
+	function colorByDepth(chalk, depth, text) {
 		const colors = [
-			chalk$1.green,
-			chalk$1.cyan,
-			chalk$1.blue,
-			chalk$1.magenta,
-			chalk$1.red
+			chalk.green,
+			chalk.cyan,
+			chalk.blue,
+			chalk.magenta,
+			chalk.red
 		];
 		const color = colors[depth % colors.length];
-		if (depth / colors.length >= 1) return chalk$1.dim(color(text));
+		if (depth / colors.length >= 1) return chalk.dim(color(text));
 		return color(text);
 	}
-	function colorByDepthGrayscale(chalk$1, depth, text) {
+	function colorByDepthGrayscale(chalk, depth, text) {
 		const grayLevel = Math.max(32, 255 - depth * 20);
-		return chalk$1.rgb(grayLevel, grayLevel, grayLevel)(text);
+		return chalk.rgb(grayLevel, grayLevel, grayLevel)(text);
 	}
 	function collectPerfStats(p) {
 		if (p.cached) {
@@ -770,18 +770,18 @@ function extractNotableBySelfTimeInGroup(measurements) {
 	return notable;
 }
 function formatIssue(io, templateStr, issue, maxIssueTextWidth) {
-	function clean$1(t$1) {
-		return t$1.replace(/\s+/, " ");
+	function clean(t) {
+		return t.replace(/\s+/, " ");
 	}
 	const { uri = "", filename, row, col, text, context = issue.line, offset } = issue;
-	const contextLeft = clean$1(context.text.slice(0, offset - context.offset));
-	const contextRight = clean$1(context.text.slice(offset + text.length - context.offset));
-	const contextFull = clean$1(context.text);
+	const contextLeft = clean(context.text.slice(0, offset - context.offset));
+	const contextRight = clean(context.text.slice(offset + text.length - context.offset));
+	const contextFull = clean(context.text);
 	const padContext = " ".repeat(Math.max(maxIssueTextWidth - text.length, 0));
 	const rowText = row.toString();
 	const colText = col.toString();
 	const padRowCol = " ".repeat(Math.max(1, 8 - (rowText.length + colText.length)));
-	const suggestions$1 = formatSuggestions(io, issue);
+	const suggestions = formatSuggestions(io, issue);
 	const msg = issue.message || (issue.isFlagged ? "Forbidden word" : "Unknown word");
 	const messageColored = issue.isFlagged ? `{yellow ${msg}}` : msg;
 	const substitutions = {
@@ -793,7 +793,7 @@ function formatIssue(io, templateStr, issue, maxIssueTextWidth) {
 		$padContext: padContext,
 		$padRowCol: padRowCol,
 		$row: rowText,
-		$suggestions: suggestions$1,
+		$suggestions: suggestions,
 		$text: text,
 		$uri: uri,
 		$quickFix: formatQuickFix(io, issue),
@@ -818,16 +818,16 @@ function substitute(text, substitutions) {
 	const subs = [];
 	for (const [match, replaceWith] of Object.entries(substitutions)) {
 		const len = match.length;
-		for (let i$1 = text.indexOf(match); i$1 >= 0; i$1 = text.indexOf(match, i$1)) {
-			const end = i$1 + len;
+		for (let i = text.indexOf(match); i >= 0; i = text.indexOf(match, i)) {
+			const end = i + len;
 			const reg = /\b/y;
 			reg.lastIndex = end;
 			if (reg.test(text)) subs.push([
-				i$1,
+				i,
 				end,
 				replaceWith
 			]);
-			i$1 = end;
+			i = end;
 		}
 	}
 	subs.sort((a, b) => a[0] - b[0]);
@@ -886,9 +886,9 @@ async function resolveImports(configFile, imports) {
 	const fromConfigDir = new URL("./", configFile.url);
 	const fromCurrentDir = toFileDirURL("./");
 	const require = createRequire(fromConfigDir);
-	function isPackageName(name$1) {
+	function isPackageName(name) {
 		try {
-			require.resolve(name$1, { paths: [fileURLToPath(fromConfigDir)] });
+			require.resolve(name, { paths: [fileURLToPath(fromConfigDir)] });
 			return true;
 		} catch {
 			return false;
@@ -957,12 +957,12 @@ function setConfigFieldValue(configFile, key, value, comment) {
 function addDictionariesToConfigFile(configFile, dictionaries, comment) {
 	if (configFile instanceof MutableCSpellConfigFile) {
 		const found = configFile.getValue("dictionaries");
-		const dicts$1 = configFile.getNode("dictionaries", []);
-		assert(isCfgArrayNode(dicts$1));
-		const knownDicts$1 = new Set(dicts$1.value);
-		for (const dict of dictionaries) if (!knownDicts$1.has(dict)) {
-			dicts$1.push(dict);
-			knownDicts$1.add(dict);
+		const dicts = configFile.getNode("dictionaries", []);
+		assert(isCfgArrayNode(dicts));
+		const knownDicts = new Set(dicts.value);
+		for (const dict of dictionaries) if (!knownDicts.has(dict)) {
+			dicts.push(dict);
+			knownDicts.add(dict);
 		}
 		if (!found && comment) configFile.setComment("dictionaries", comment);
 		return;
@@ -1109,9 +1109,9 @@ function determineFileNameURL(options) {
 	if (options.config) return toFileURL(options.config);
 	const defaultFileName = determineDefaultFileName(options);
 	const outputUrl = toFileURL(options.output || defaultFileName);
-	const path$2 = outputUrl.pathname;
-	if (path$2.endsWith(".json") || path$2.endsWith(".jsonc") || path$2.endsWith(".yaml") || path$2.endsWith(".yml")) return outputUrl;
-	if (/\.{m,c}?{j,t}s$/.test(path$2)) throw new Error(`Unsupported file extension: ${path$2}`);
+	const path = outputUrl.pathname;
+	if (path.endsWith(".json") || path.endsWith(".jsonc") || path.endsWith(".yaml") || path.endsWith(".yml")) return outputUrl;
+	if (/\.{m,c}?{j,t}s$/.test(path)) throw new Error(`Unsupported file extension: ${path}`);
 	return new URL(defaultFileName, toFileDirURL(outputUrl));
 }
 function determineDefaultFileName(options) {
@@ -1150,11 +1150,11 @@ function parseFeatureFlags(flags, featureFlags = getFeatureFlags()) {
 	if (!flags) return featureFlags;
 	const flagsKvP = flags.map((f) => f.split(":", 2));
 	for (const flag of flagsKvP) {
-		const [name$1, value] = flag;
+		const [name, value] = flag;
 		try {
-			featureFlags.setFlag(name$1, value);
+			featureFlags.setFlag(name, value);
 		} catch {
-			console.warn(`Unknown flag: "${name$1}"`);
+			console.warn(`Unknown flag: "${name}"`);
 		}
 	}
 	return featureFlags;
@@ -1201,7 +1201,7 @@ const pkgDir = _dirname;
 //#endregion
 //#region src/pkgInfo.ts
 const name = "cspell";
-const version$1 = "9.6.2";
+const version$1 = "9.6.4";
 const engines = { node: ">=20.18" };
 const npmPackage = {
 	name,
@@ -1209,6 +1209,209 @@ const npmPackage = {
 	engines
 };
 
+//#endregion
+//#region src/reporters/reporters.ts
+function filterFeatureIssues(features, issue, reportOptions) {
+	if (issue.issueType === IssueType.directive) return features?.issueType && reportOptions?.validateDirectives || false;
+	if (features?.unknownWords) return true;
+	if (!reportOptions) return true;
+	if (issue.isFlagged || !reportOptions.unknownWords || reportOptions.unknownWords === unknownWordsChoices.ReportAll) return true;
+	if (issue.hasPreferredSuggestions && reportOptions.unknownWords !== unknownWordsChoices.ReportFlagged) return true;
+	if (issue.hasSimpleSuggestions && reportOptions.unknownWords === unknownWordsChoices.ReportSimple) return true;
+	return false;
+}
+function handleIssue(reporter, issue, reportOptions) {
+	if (!reporter.issue) return;
+	if (!filterFeatureIssues(reporter.features, issue, reportOptions)) return;
+	if (!reporter.features?.contextGeneration && !issue.context) {
+		issue = { ...issue };
+		issue.context = issue.line;
+	}
+	return reporter.issue(issue, reportOptions);
+}
+/**
+* Loads reporter modules configured in cspell config file
+*/
+async function loadReporters(reporters, defaultReporter, config) {
+	async function loadReporter(reporterSettings) {
+		if (reporterSettings === "default") return defaultReporter;
+		if (!Array.isArray(reporterSettings)) reporterSettings = [reporterSettings];
+		const [moduleName, settings] = reporterSettings;
+		try {
+			const { getReporter } = await dynamicImport(moduleName, [process.cwd(), pkgDir]);
+			return getReporter(settings, config);
+		} catch (e) {
+			throw new ApplicationError(`Failed to load reporter ${moduleName}: ${toError$1(e).message}`);
+		}
+	}
+	reporters = !reporters || !reporters.length ? ["default"] : [...reporters];
+	return (await Promise.all(reporters.map(loadReporter))).filter((v) => v !== void 0);
+}
+function finalizeReporter(reporter) {
+	if (!reporter) return void 0;
+	if (reporterIsFinalized(reporter)) return reporter;
+	return {
+		issue: (...params) => reporter.issue?.(...params),
+		info: (...params) => reporter.info?.(...params),
+		debug: (...params) => reporter.debug?.(...params),
+		progress: (...params) => reporter.progress?.(...params),
+		error: (...params) => reporter.error?.(...params),
+		result: (...params) => reporter.result?.(...params),
+		features: reporter.features
+	};
+}
+function reporterIsFinalized(reporter) {
+	return !!reporter && reporter.features && typeof reporter.issue === "function" && typeof reporter.info === "function" && typeof reporter.debug === "function" && typeof reporter.error === "function" && typeof reporter.progress === "function" && typeof reporter.result === "function" || false;
+}
+const reportIssueOptionsKeyMap = {
+	unknownWords: "unknownWords",
+	validateDirectives: "validateDirectives",
+	showContext: "showContext"
+};
+function setValue(options, key, value) {
+	if (value !== void 0) options[key] = value;
+}
+function extractReporterIssueOptions(settings) {
+	const src = settings;
+	const options = {};
+	for (const key in reportIssueOptionsKeyMap) {
+		const k = key;
+		setValue(options, k, src[k]);
+	}
+	return options;
+}
+function mergeReportIssueOptions(a, b) {
+	const options = extractReporterIssueOptions(a);
+	if (!b) return options;
+	for (const key in reportIssueOptionsKeyMap) {
+		const k = key;
+		setValue(options, k, b[k]);
+	}
+	return options;
+}
+var LintReporter = class {
+	#reporters = [];
+	#config;
+	#finalized = false;
+	constructor(defaultReporter, config) {
+		this.defaultReporter = defaultReporter;
+		this.#config = config;
+		if (defaultReporter) this.#reporters.push(finalizeReporter(defaultReporter));
+	}
+	get config() {
+		return this.#config;
+	}
+	set config(config) {
+		assert(!this.#finalized, "Cannot change the configuration of a finalized reporter");
+		this.#config = config;
+	}
+	issue(issue, reportOptions) {
+		for (const reporter of this.#reporters) handleIssue(reporter, issue, reportOptions);
+	}
+	info(...params) {
+		for (const reporter of this.#reporters) reporter.info(...params);
+	}
+	debug(...params) {
+		for (const reporter of this.#reporters) reporter.debug(...params);
+	}
+	error(...params) {
+		for (const reporter of this.#reporters) reporter.error(...params);
+	}
+	progress(...params) {
+		for (const reporter of this.#reporters) reporter.progress(...params);
+	}
+	async result(result) {
+		await Promise.all(this.#reporters.map((reporter) => reporter.result?.(result)));
+	}
+	get features() {
+		return {
+			unknownWords: true,
+			issueType: true
+		};
+	}
+	async loadReportersAndFinalize(reporters) {
+		assert(!this.#finalized, "Cannot change the configuration of a finalized reporter");
+		const loaded = await loadReporters(reporters, this.defaultReporter, this.config);
+		this.#reporters = [...new Set(loaded)].map((reporter) => finalizeReporter(reporter));
+	}
+	emitProgressBegin(filename, fileNum, fileCount) {
+		this.progress({
+			type: "ProgressFileBegin",
+			fileNum,
+			fileCount,
+			filename
+		});
+	}
+	emitProgressComplete(filename, fileNum, fileCount, result) {
+		const numIssues = result.issues.filter((issue) => filterFeatureIssues({}, issue, result.reportIssueOptions)).length;
+		for (const reporter of this.#reporters) {
+			const progress = clean({
+				type: "ProgressFileComplete",
+				fileNum,
+				fileCount,
+				filename,
+				elapsedTimeMs: result.elapsedTimeMs,
+				processed: result.processed,
+				skippedReason: result.skippedReason,
+				numErrors: numIssues || result.errors,
+				cached: result.cached,
+				perf: result.perf,
+				issues: reporter.features && result.issues,
+				reportIssueOptions: reporter.features && result.reportIssueOptions
+			});
+			reporter.progress(progress);
+		}
+		result.issues.forEach((issue) => this.issue(issue, result.reportIssueOptions));
+		return numIssues;
+	}
+};
+var ReportItemCollector = class {
+	#collection;
+	constructor(collection) {
+		this.#collection = collection;
+	}
+	get #items() {
+		if (!this.#collection.reportItems) this.#collection.reportItems = [];
+		return this.#collection.reportItems;
+	}
+	get items() {
+		return this.#collection.reportItems;
+	}
+	info(...params) {
+		this.#items.push({
+			type: "info",
+			payload: params
+		});
+	}
+	debug(...params) {
+		this.#items.push({
+			type: "debug",
+			payload: params
+		});
+	}
+	error(...params) {
+		this.#items.push({
+			type: "error",
+			payload: params
+		});
+	}
+};
+function replayReportItems(reportItemsCollection, reporter) {
+	const items = reportItemsCollection.reportItems;
+	if (!items) return;
+	for (const item of items) switch (item.type) {
+		case "info":
+			reporter.info(...item.payload);
+			break;
+		case "debug":
+			reporter.debug(...item.payload);
+			break;
+		case "error":
+			reporter.error(...item.payload);
+			break;
+	}
+}
+
 //#endregion
 //#region src/util/async.ts
 const asyncMap = operators.opMapAsync;
@@ -1248,12 +1451,12 @@ async function globP(pattern, options) {
 		followSymbolicLinks: false,
 		expandDirectories: false
 	});
-	const compare$1 = new Intl.Collator("en").compare;
-	return (await glob$1(patterns, useOptions)).sort(compare$1).map((absFilename) => path$1.relative(cwd, absFilename));
+	const compare = new Intl.Collator("en").compare;
+	return (await glob$1(patterns, useOptions)).sort(compare).map((absFilename) => path$1.relative(cwd, absFilename));
 }
 function calcGlobs(commandLineExclude) {
 	const commandLineExcludes = {
-		globs: [...new Set((commandLineExclude || []).flatMap((glob$2) => glob$2.split(/(?<!\\)\s+/g)).map((g) => g.replaceAll("\\ ", " ")))],
+		globs: [...new Set((commandLineExclude || []).flatMap((glob) => glob.split(/(?<!\\)\s+/g)).map((g) => g.replaceAll("\\ ", " ")))],
 		source: "arguments"
 	};
 	const defaultExcludes = {
@@ -1266,8 +1469,8 @@ function extractPatterns(globs) {
 	return globs.reduce((info, g) => {
 		const source = g.source;
 		const patterns = g.matcher.patternsNormalizedToRoot;
-		return [...info, ...patterns.map((glob$2) => ({
-			glob: glob$2,
+		return [...info, ...patterns.map((glob) => ({
+			glob,
 			source
 		}))];
 	}, []);
@@ -1314,29 +1517,29 @@ const isPossibleUrlRegExp = /^[\d_a-z-]{3,}:\/\//;
 * @param root - root to use.
 * @returns `**` is appended directories.
 */
-async function adjustPossibleDirectory(glob$2, root) {
-	const g = typeof glob$2 === "string" ? {
-		glob: glob$2,
+async function adjustPossibleDirectory(glob, root) {
+	const g = typeof glob === "string" ? {
+		glob,
 		root
 	} : {
-		glob: glob$2.glob,
-		root: glob$2.root ?? root
+		glob: glob.glob,
+		root: glob.root ?? root
 	};
-	if (isPossibleGlobRegExp.test(g.glob)) return glob$2;
-	if (isPossibleUrlRegExp.test(g.glob)) return glob$2;
+	if (isPossibleGlobRegExp.test(g.glob)) return glob;
+	if (isPossibleUrlRegExp.test(g.glob)) return glob;
 	const dirPath = path$1.resolve(g.root, g.glob);
 	try {
 		if ((await promises.stat(dirPath)).isDirectory()) {
 			const useGlob = posix.join(posixPath(g.glob), "**");
-			return typeof glob$2 === "string" ? useGlob : {
-				...glob$2,
+			return typeof glob === "string" ? useGlob : {
+				...glob,
 				glob: useGlob
 			};
 		}
 	} catch {
-		return glob$2;
+		return glob;
 	}
-	return glob$2;
+	return glob;
 }
 function posixPath(p) {
 	return path$1.sep === "\\" ? p.replaceAll("\\", "/") : p;
@@ -1369,9 +1572,9 @@ function isStdinUrl(url) {
 */
 function resolveStdinUrl(url, cwd) {
 	assert(url.startsWith(STDINProtocol), `Expected url to start with ${STDINProtocol}`);
-	const path$2 = decodeURIComponent(url).slice(STDINProtocol.length).replace(/^\/\//, "").replace(/^\/([a-z]:)/i, "$1");
-	const fileUrl = toFileURL(path$2, cwd);
-	return new URL(fileUrl.toString().replace(/^file:/, STDINProtocol) + (path$2 ? "" : "/"));
+	const path = decodeURIComponent(url).slice(STDINProtocol.length).replace(/^\/\//, "").replace(/^\/([a-z]:)/i, "$1");
+	const fileUrl = toFileURL(path, cwd);
+	return new URL(fileUrl.toString().replace(/^file:/, STDINProtocol) + (path ? "" : "/"));
 }
 
 //#endregion
@@ -1463,9 +1666,9 @@ const resolveFilenames = asyncMap(resolveFilename);
 function readFileListFiles(listFiles) {
 	let useStdin = false;
 	return asyncPipe(mergeAsyncIterables(asyncPipe(listFiles.filter((file) => {
-		const isStdin$1 = file === "stdin";
-		useStdin = useStdin || isStdin$1;
-		return !isStdin$1;
+		const isStdin = file === "stdin";
+		useStdin = useStdin || isStdin;
+		return !isStdin;
 	}), asyncMap((file) => readFileListFile(file)), asyncAwait(), asyncFlatten()), useStdin ? readStdin() : []), resolveFilenames);
 }
 /**
@@ -1693,11 +1896,11 @@ var ImplFileEntryCache = class {
 	}
 	async #getMetaForFileUsingMtimeAndSize(cacheEntry) {
 		const filePath = this.resolveKeyToFile(cacheEntry.key);
-		const stat$1 = await fs.stat(filePath);
+		const stat = await fs.stat(filePath);
 		const meta = {
 			...cacheEntry.meta,
-			size: stat$1.size,
-			mtime: stat$1.mtime.getTime()
+			size: stat.size,
+			mtime: stat.mtime.getTime()
 		};
 		delete meta.hash;
 		return meta;
@@ -1938,8 +2141,8 @@ function getTreeEntry(tree, keys) {
 }
 function setTreeEntry(tree, deps, update = false) {
 	let r = tree;
-	for (const d$1 of deps) {
-		const k = d$1.f;
+	for (const d of deps) {
+		const k = d.f;
 		if (!r.c) r.c = /* @__PURE__ */ new Map();
 		const cn = r.c.get(k);
 		const n = cn ?? {};
@@ -1956,8 +2159,8 @@ function setTreeEntry(tree, deps, update = false) {
 function compDep(a, b) {
 	return a.f === b.f && a.h === b.h;
 }
-function calcVersion(version$2) {
-	return version$2 + META_DATA_VERSION_SUFFIX;
+function calcVersion(version) {
+	return version + META_DATA_VERSION_SUFFIX;
 }
 function normalizePath(filePath) {
 	if (sep === "/") return filePath;
@@ -1995,9 +2198,9 @@ async function createCache(options) {
 	const { useCache, cacheLocation, cacheStrategy, reset } = options;
 	const location = toFileURL(cacheLocation);
 	const useChecksum = cacheStrategy === "content";
-	const version$2 = normalizeVersion(options.version);
+	const version = normalizeVersion(options.version);
 	const useUniversal = options.cacheFormat === "universal";
-	const cache = useCache ? await createDiskCache(location, useChecksum, version$2, useUniversal) : new DummyCache();
+	const cache = useCache ? await createDiskCache(location, useChecksum, version, useUniversal) : new DummyCache();
 	if (reset) await cache.reset();
 	return cache;
 }
@@ -2031,8 +2234,8 @@ async function resolveCacheLocation(cacheLocation) {
 * Normalizes the version and return only `major.minor + versionSuffix`
 * @param version The cspell semantic version.
 */
-function normalizeVersion(version$2) {
-	const parts = version$2.split(".").slice(0, 2);
+function normalizeVersion(version) {
+	const parts = version.split(".").slice(0, 2);
 	assert(parts.length === 2);
 	return parts.join(".") + versionSuffix;
 }
@@ -2078,163 +2281,6 @@ async function readConfigHandleError(filename) {
 	}
 }
 
-//#endregion
-//#region src/util/reporters.ts
-function filterFeatureIssues(features, issue, reportOptions) {
-	if (issue.issueType === IssueType.directive) return features?.issueType && reportOptions?.validateDirectives || false;
-	if (features?.unknownWords) return true;
-	if (!reportOptions) return true;
-	if (issue.isFlagged || !reportOptions.unknownWords || reportOptions.unknownWords === unknownWordsChoices.ReportAll) return true;
-	if (issue.hasPreferredSuggestions && reportOptions.unknownWords !== unknownWordsChoices.ReportFlagged) return true;
-	if (issue.hasSimpleSuggestions && reportOptions.unknownWords === unknownWordsChoices.ReportSimple) return true;
-	return false;
-}
-function handleIssue(reporter, issue, reportOptions) {
-	if (!reporter.issue) return;
-	if (!filterFeatureIssues(reporter.features, issue, reportOptions)) return;
-	if (!reporter.features?.contextGeneration && !issue.context) {
-		issue = { ...issue };
-		issue.context = issue.line;
-	}
-	return reporter.issue(issue, reportOptions);
-}
-/**
-* Loads reporter modules configured in cspell config file
-*/
-async function loadReporters(reporters, defaultReporter, config) {
-	async function loadReporter(reporterSettings) {
-		if (reporterSettings === "default") return defaultReporter;
-		if (!Array.isArray(reporterSettings)) reporterSettings = [reporterSettings];
-		const [moduleName, settings] = reporterSettings;
-		try {
-			const { getReporter: getReporter$1 } = await dynamicImport(moduleName, [process.cwd(), pkgDir]);
-			return getReporter$1(settings, config);
-		} catch (e) {
-			throw new ApplicationError(`Failed to load reporter ${moduleName}: ${toError$1(e).message}`);
-		}
-	}
-	reporters = !reporters || !reporters.length ? ["default"] : [...reporters];
-	return (await Promise.all(reporters.map(loadReporter))).filter((v) => v !== void 0);
-}
-function finalizeReporter(reporter) {
-	if (!reporter) return void 0;
-	if (reporterIsFinalized(reporter)) return reporter;
-	return {
-		issue: (...params) => reporter.issue?.(...params),
-		info: (...params) => reporter.info?.(...params),
-		debug: (...params) => reporter.debug?.(...params),
-		progress: (...params) => reporter.progress?.(...params),
-		error: (...params) => reporter.error?.(...params),
-		result: (...params) => reporter.result?.(...params),
-		features: reporter.features
-	};
-}
-function reporterIsFinalized(reporter) {
-	return !!reporter && reporter.features && typeof reporter.issue === "function" && typeof reporter.info === "function" && typeof reporter.debug === "function" && typeof reporter.error === "function" && typeof reporter.progress === "function" && typeof reporter.result === "function" || false;
-}
-const reportIssueOptionsKeyMap = {
-	unknownWords: "unknownWords",
-	validateDirectives: "validateDirectives",
-	showContext: "showContext"
-};
-function setValue(options, key, value) {
-	if (value !== void 0) options[key] = value;
-}
-function extractReporterIssueOptions(settings) {
-	const src = settings;
-	const options = {};
-	for (const key in reportIssueOptionsKeyMap) {
-		const k = key;
-		setValue(options, k, src[k]);
-	}
-	return options;
-}
-function mergeReportIssueOptions(a, b) {
-	const options = extractReporterIssueOptions(a);
-	if (!b) return options;
-	for (const key in reportIssueOptionsKeyMap) {
-		const k = key;
-		setValue(options, k, b[k]);
-	}
-	return options;
-}
-var LintReporter = class {
-	#reporters = [];
-	#config;
-	#finalized = false;
-	constructor(defaultReporter, config) {
-		this.defaultReporter = defaultReporter;
-		this.#config = config;
-		if (defaultReporter) this.#reporters.push(finalizeReporter(defaultReporter));
-	}
-	get config() {
-		return this.#config;
-	}
-	set config(config) {
-		assert(!this.#finalized, "Cannot change the configuration of a finalized reporter");
-		this.#config = config;
-	}
-	issue(issue, reportOptions) {
-		for (const reporter of this.#reporters) handleIssue(reporter, issue, reportOptions);
-	}
-	info(...params) {
-		for (const reporter of this.#reporters) reporter.info(...params);
-	}
-	debug(...params) {
-		for (const reporter of this.#reporters) reporter.debug(...params);
-	}
-	error(...params) {
-		for (const reporter of this.#reporters) reporter.error(...params);
-	}
-	progress(...params) {
-		for (const reporter of this.#reporters) reporter.progress(...params);
-	}
-	async result(result) {
-		await Promise.all(this.#reporters.map((reporter) => reporter.result?.(result)));
-	}
-	get features() {
-		return {
-			unknownWords: true,
-			issueType: true
-		};
-	}
-	async loadReportersAndFinalize(reporters) {
-		assert(!this.#finalized, "Cannot change the configuration of a finalized reporter");
-		const loaded = await loadReporters(reporters, this.defaultReporter, this.config);
-		this.#reporters = [...new Set(loaded)].map((reporter) => finalizeReporter(reporter));
-	}
-	emitProgressBegin(filename, fileNum, fileCount) {
-		this.progress({
-			type: "ProgressFileBegin",
-			fileNum,
-			fileCount,
-			filename
-		});
-	}
-	emitProgressComplete(filename, fileNum, fileCount, result) {
-		const numIssues = result.issues.filter((issue) => filterFeatureIssues({}, issue, result.reportIssueOptions)).length;
-		for (const reporter of this.#reporters) {
-			const progress = clean({
-				type: "ProgressFileComplete",
-				fileNum,
-				fileCount,
-				filename,
-				elapsedTimeMs: result.elapsedTimeMs,
-				processed: result.processed,
-				skippedReason: result.skippedReason,
-				numErrors: numIssues || result.errors,
-				cached: result.cached,
-				perf: result.perf,
-				issues: reporter.features && result.issues,
-				reportIssueOptions: reporter.features && result.reportIssueOptions
-			});
-			reporter.progress(progress);
-		}
-		result.issues.forEach((issue) => this.issue(issue, result.reportIssueOptions));
-		return numIssues;
-	}
-};
-
 //#endregion
 //#region src/util/timer.ts
 function getTimeMeasurer() {
@@ -2252,11 +2298,11 @@ function getTimeMeasurer() {
 * @returns
 */
 function indent(str, padding, firstLinePadding = "") {
-	let pad$1 = firstLinePadding;
+	let pad = firstLinePadding;
 	const lines = [];
 	for (const line of str.split("\n")) {
-		lines.push(pad$1 + line);
-		pad$1 = padding;
+		lines.push(pad + line);
+		pad = padding;
 	}
 	return lines.join("\n");
 }
@@ -2302,11 +2348,11 @@ function unindentString(str) {
 //#endregion
 //#region src/util/wrap.ts
 const wrapSep = /\s+|(?<=,)|\.(?=\w)/g;
-function wordWrapAnsiText(str, maxWidth, indent$1 = "", sep$1 = wrapSep) {
+function wordWrapAnsiText(str, maxWidth, indent = "", sep = 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");
+	if (str.includes("\n")) return str.split("\n").map((line) => wordWrapAnsiText(line, maxWidth, indent)).join("\n");
+	const fragments = fragmentString(str, sep, "sep");
 	const lines = [];
 	let line = "";
 	for (const text of joinFragments(fragments)) {
@@ -2314,7 +2360,7 @@ function wordWrapAnsiText(str, maxWidth, indent$1 = "", sep$1 = wrapSep) {
 		const textWidth = ansiWidth(text);
 		if (line && lineWidth + textWidth > maxWidth) {
 			if (line) lines.push(line);
-			line = indent$1 + text.trimStart();
+			line = indent + text.trimStart();
 			continue;
 		}
 		line += text;
@@ -2351,10 +2397,10 @@ async function writeFileOrStream(filename, data) {
 	return fs.writeFile(filename, data);
 }
 function writeStream(stream, data) {
-	return new Promise((resolve$1, reject) => {
+	return new Promise((resolve, reject) => {
 		stream.write(data, (err) => {
 			if (err) reject(err);
-			else resolve$1();
+			else resolve();
 		});
 	});
 }
@@ -2427,23 +2473,21 @@ var LinterError = class extends Error {
 
 //#endregion
 //#region src/lint/processFile.ts
-async function processFile(filename, cache, prefetch$1, processFileOptions) {
-	if (prefetch$1?.fileResult) return prefetch$1.fileResult;
-	const { reporter, cfg, configInfo, userSettings } = processFileOptions;
+async function processFile(file, cache, prefetch, processFileOptions) {
+	if (prefetch?.fileResult) return prefetch.fileResult;
+	const { filename } = file;
+	const { cfg, configInfo, userSettings } = processFileOptions;
 	const getElapsedTimeMs = getTimeMeasurer();
-	const reportIssueOptions = prefetch$1?.reportIssueOptions;
+	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
-			}
-		};
-	}
+	if (cachedResult) return {
+		...cachedResult,
+		elapsedTimeMs: getElapsedTimeMs(),
+		reportIssueOptions: {
+			...cachedResult.reportIssueOptions,
+			...reportIssueOptions
+		}
+	};
 	const result = {
 		fileInfo: { filename },
 		issues: [],
@@ -2451,9 +2495,11 @@ async function processFile(filename, cache, prefetch$1, processFileOptions) {
 		errors: 0,
 		configErrors: 0,
 		elapsedTimeMs: 0,
-		reportIssueOptions
+		reportIssueOptions,
+		reportItems: void 0
 	};
-	const fileInfo = prefetch$1?.fileInfo || await readFileInfo(filename, void 0, true);
+	const reporter = new ReportItemCollector(result);
+	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}"`);
@@ -2486,7 +2532,7 @@ async function processFile(filename, cache, prefetch$1, processFileOptions) {
 	result.elapsedTimeMs = getElapsedTimeMs();
 	const config = spellResult.settingsUsed ?? {};
 	result.reportIssueOptions = mergeReportIssueOptions(spellResult.settingsUsed || configInfo.config, reportIssueOptions);
-	result.configErrors += reportSpellingResultConfigErrors(spellResult, processFileOptions);
+	result.configErrors += reportSpellingResultConfigErrors(reporter, spellResult, processFileOptions);
 	reportCheckResult(result, doc, spellResult, config, processFileOptions);
 	const dep = calcDependencies(config);
 	await cache.setCachedLintResults(result, dep.files);
@@ -2500,11 +2546,12 @@ async function processFile(filename, cache, prefetch$1, processFileOptions) {
 	}
 }
 function reportCheckResult(result, _doc, spellResult, config, processFileOptions) {
-	const { configInfo, reporter, verboseLevel, useColor, cfg, chalk: chalk$1 } = processFileOptions;
+	const { configInfo, verboseLevel, useColor, cfg, chalk } = processFileOptions;
 	const elapsed = result.elapsedTimeMs || 0;
 	const dictionaries = config.dictionaries || [];
+	const reporter = new ReportItemCollector(result);
 	if (verboseLevel > 1) {
-		const dictsUsed = [...dictionaries].sort().map((name$1) => chalk$1.green(name$1)).join(", ");
+		const dictsUsed = [...dictionaries].sort().map((name) => chalk.green(name)).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)}
@@ -2513,7 +2560,7 @@ function reportCheckResult(result, _doc, spellResult, config, processFileOptions
 		reporter.info(indent(msg, "  "), MessageTypes.Info);
 	}
 	if (cfg.options.debug) {
-		const { enabled, language, languageId, dictionaries: dictionaries$1 } = config;
+		const { enabled, language, languageId, dictionaries } = config;
 		const msg = unindent`\
                 Debug Config: ${formatWithOptions({
 			depth: 2,
@@ -2522,7 +2569,7 @@ function reportCheckResult(result, _doc, spellResult, config, processFileOptions
 			languageId,
 			enabled,
 			language,
-			dictionaries: dictionaries$1
+			dictionaries
 		})}`;
 		reporter.debug(msg);
 	}
@@ -2531,11 +2578,11 @@ function calcDependencies(config) {
 	const { configFiles, dictionaryFiles } = extractDependencies(config);
 	return { files: [...configFiles, ...dictionaryFiles] };
 }
-function reportConfigurationErrors(config, processFileOptions) {
-	return reportImportErrors(extractImportErrors(config), processFileOptions);
+function reportConfigurationErrors(reporter, config, processFileOptions) {
+	return reportImportErrors(reporter, extractImportErrors(config), processFileOptions);
 }
-function reportImportErrors(errors, processFileOptions) {
-	const { reporter, configErrors } = processFileOptions;
+function reportImportErrors(reporter, errors, processFileOptions) {
+	const { configErrors } = processFileOptions;
 	let count = 0;
 	errors.forEach((ref) => {
 		const key = ref.error.toString();
@@ -2546,9 +2593,9 @@ function reportImportErrors(errors, processFileOptions) {
 	});
 	return count;
 }
-function reportSpellingResultConfigErrors(spellResult, processFileOptions) {
-	const { reporter, configErrors } = processFileOptions;
-	let count = reportImportErrors(spellResult.configErrors || [], processFileOptions);
+function reportSpellingResultConfigErrors(reporter, spellResult, processFileOptions) {
+	const { configErrors } = processFileOptions;
+	let count = reportImportErrors(reporter, spellResult.configErrors || [], processFileOptions);
 	const dictionaryErrors = [...spellResult.dictionaryErrors || []];
 	for (const [dictName, dictErrors] of dictionaryErrors) {
 		const msg = `Dictionary Error with (${dictName})`;
@@ -2562,8 +2609,8 @@ function reportSpellingResultConfigErrors(spellResult, processFileOptions) {
 	}
 	return count;
 }
-function countConfigErrors(configInfo, processFileOptions) {
-	return reportConfigurationErrors(configInfo.config, processFileOptions);
+function countConfigErrors(reporter, configInfo, processFileOptions) {
+	return reportConfigurationErrors(reporter, configInfo.config, processFileOptions);
 }
 
 //#endregion
@@ -2574,9 +2621,9 @@ function* prefetchIterable(iterable, size) {
 	for (const value of iterable) {
 		buffer.push(value);
 		if (buffer.length >= size - 1) {
-			const value$1 = buffer[0];
+			const value = buffer[0];
 			buffer.shift();
-			yield value$1;
+			yield value;
 		}
 	}
 	yield* buffer;
@@ -2640,16 +2687,13 @@ function prefetch(fileToProcess, cfg) {
 		})
 	};
 	const reportIssueOptions = extractReporterIssueOptions(cfg.config);
-	async function fetch$1() {
+	async function fetch() {
 		const getElapsedTimeMs = getTimeMeasurer();
 		const cachedResult = await cfg.cache.getCachedLintResults(filename);
-		if (cachedResult) {
-			cfg.reporter.debug(`Filename: ${filename}, using cache`);
-			return { fileResult: {
-				...cachedResult,
-				elapsedTimeMs: getElapsedTimeMs()
-			} };
-		}
+		if (cachedResult) return { fileResult: {
+			...cachedResult,
+			elapsedTimeMs: getElapsedTimeMs()
+		} };
 		const uri = filenameToUri(filename, cfg.root).href;
 		const checkResult = await shouldCheckDocument({ uri }, {}, cfg.config);
 		if (!checkResult.shouldCheck) return {
@@ -2668,7 +2712,7 @@ function prefetch(fileToProcess, cfg) {
 			reportIssueOptions
 		};
 	}
-	const result = fetch$1().catch((e) => toApplicationError(e));
+	const result = fetch().catch((e) => toApplicationError(e));
 	return {
 		...fileToProcess,
 		result
@@ -2680,14 +2724,12 @@ async function processFiles(files, options) {
 	const failFast = options.cfg.options.failFast ?? options.configInfo.config.failFast ?? false;
 	const reporter = options.lintReporter;
 	const prefetchConfig = {
-		reporter,
 		root: options.cfg.root,
 		maxFileSize: options.cfg.maxFileSize,
 		config: options.configInfo.config,
 		cache
 	};
 	const processFileOptionsGeneral = {
-		reporter,
 		chalk: options.chalk,
 		configInfo: options.configInfo,
 		cfg: options.cfg,
@@ -2696,11 +2738,11 @@ async function processFiles(files, options) {
 		configErrors: options.configErrors,
 		userSettings: options.configInfo.config
 	};
-	function* prefetchFiles(files$1) {
-		yield* prefetchIterable(pipe(files$1, opMap$1((file) => prefetch(file, prefetchConfig))), BATCH_FETCH_SIZE);
+	function* prefetchFiles(files) {
+		yield* prefetchIterable(pipe(files, opMap$1((file) => prefetch(file, prefetchConfig))), BATCH_FETCH_SIZE);
 	}
-	async function* prefetchFilesAsync(files$1) {
-		for await (const file of files$1) yield prefetch(file, prefetchConfig);
+	async function* prefetchFilesAsync(files) {
+		for await (const file of files) yield prefetch(file, prefetchConfig);
 	}
 	const emptyResult = {
 		fileInfo: { filename: "" },
@@ -2709,7 +2751,8 @@ async function processFiles(files, options) {
 		errors: 0,
 		configErrors: 0,
 		elapsedTimeMs: 1,
-		reportIssueOptions: void 0
+		reportIssueOptions: void 0,
+		reportItems: void 0
 	};
 	async function processPrefetchFileResult(pf) {
 		const { filename, sequence, sequenceSize, result: pFetchResult } = pf;
@@ -2733,7 +2776,7 @@ async function processFiles(files, options) {
 			filename,
 			sequence,
 			sequenceSize,
-			result: await processFile(filename, cache, fetchResult, processFileOptionsGeneral)
+			result: await processFile(pf, cache, fetchResult, processFileOptionsGeneral)
 		};
 	}
 	async function* loadAndProcessFiles() {
@@ -2750,8 +2793,9 @@ async function processFiles(files, options) {
 		}
 		yield* pipe(prefetchIterable(pipe(prefetchFiles(files), opMap$1(async (pf) => processPrefetchFileResult(pf))), BATCH_PROCESS_SIZE));
 	}
-	for await (const fileP of loadAndProcessFiles()) {
-		const { filename, sequence, sequenceSize, result } = fileP;
+	for await (const processed of loadAndProcessFiles()) {
+		const { filename, sequence, sequenceSize, result } = processed;
+		replayReportItems(result, reporter);
 		status.files += 1;
 		status.cachedFiles = (status.cachedFiles || 0) + (result.cached ? 1 : 0);
 		status.skippedFiles = (status.skippedFiles || 0) + (result.processed ? 0 : 1);
@@ -2787,34 +2831,34 @@ function runResult(init = {}) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.107.0/helpers/usingCtx.js
+//#region \0@oxc-project+runtime@0.110.0/helpers/usingCtx.js
 function _usingCtx() {
-	var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
-		var n$1 = Error();
-		return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
 	}, e = {}, n = [];
-	function using(r$1, e$1) {
-		if (null != e$1) {
-			if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
-			if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
-			if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
 			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
-			t && (o = function o$1() {
+			t && (o = function o() {
 				try {
-					t.call(e$1);
-				} catch (r$2) {
-					return Promise.reject(r$2);
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
 				}
 			}), n.push({
-				v: e$1,
+				v: e,
 				d: o,
-				a: r$1
+				a: r
 			});
-		} else r$1 && n.push({
-			d: e$1,
-			a: r$1
+		} else r && n.push({
+			d: e,
+			a: r
 		});
-		return e$1;
+		return e;
 	}
 	return {
 		e,
@@ -2826,17 +2870,17 @@ function _usingCtx() {
 				for (; o = n.pop();) try {
 					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
 					if (o.d) {
-						var r$1 = o.d.call(o.v);
-						if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
 					} else s |= 1;
-				} catch (r$2) {
-					return err(r$2);
+				} catch (r) {
+					return err(r);
 				}
 				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
 				if (t !== e) throw t;
 			}
-			function err(n$1) {
-				return t = t !== e ? new r(n$1, t) : n$1, next();
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
 			}
 			return next();
 		}
@@ -2889,7 +2933,7 @@ async function runLint(cfg) {
 			header(fileGlobs, excludeGlobs);
 			checkGlobs(fileGlobs, reporter);
 			if (verboseLevel > 1) reporter.info(`Config Files Found:\n    ${relativeToCwd(configInfo.source)}\n`, MessageTypes$1.Info);
-			const configErrorCount = countConfigErrors(configInfo, processFileOptions);
+			const configErrorCount = countConfigErrors(reporter, configInfo, processFileOptions);
 			if (configErrorCount && cfg.options.exitCode !== false && !cfg.options.continueOnError) return runResult({ errors: configErrorCount });
 			const { root } = cfg;
 			try {
@@ -2938,7 +2982,6 @@ async function runLint(cfg) {
 	}
 	function getProcessFileOptions(configInfo) {
 		return {
-			reporter,
 			chalk,
 			configInfo,
 			cfg,
@@ -2950,7 +2993,7 @@ async function runLint(cfg) {
 	}
 }
 function checkGlobs(globs, reporter) {
-	globs.filter((g) => g.startsWith("'") || g.endsWith("'")).map((glob$2) => chalk.yellow(glob$2)).forEach((glob$2) => reporter.error("Linter", new CheckFailed(`Glob starting or ending with ' (single quote) is not likely to match any files: ${glob$2}.`)));
+	globs.filter((g) => g.startsWith("'") || g.endsWith("'")).map((glob) => chalk.yellow(glob)).forEach((glob) => reporter.error("Linter", new CheckFailed(`Glob starting or ending with ' (single quote) is not likely to match any files: ${glob}.`)));
 }
 async function determineGlobs(configInfo, cfg) {
 	const useGitignore = cfg.options.gitignore ?? configInfo.config.useGitignore ?? false;
@@ -3019,22 +3062,22 @@ async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
 		const absFilename = path$1.resolve(root, filename);
 		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$1.Info);
+			const { glob, source } = extractGlobSource(r.pattern);
+			if (calcVerboseLevel(cfg.options) > 1) reporter.info(`Excluded File: ${path$1.relative(root, absFilename)}; Excluded by ${glob} 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());
+		const excludeInfo = globMatcherExclude.patterns.map(extractGlobSource).map(({ glob, source }) => `Glob: ${glob} from ${source}`).filter(uniqueFn());
 		if (calcVerboseLevel(cfg.options) > 1) reporter.info(`Exclusion Globs: \n    ${excludeInfo.join("\n    ")}\n`, MessageTypes$1.Info);
 		return (filename) => !isExcluded(filename, globMatcherExclude);
 	}
 	return _determineFilesToCheck();
 }
 function extractGlobSource(g) {
-	const { glob: glob$2, rawGlob, source } = g;
+	const { glob, rawGlob, source } = g;
 	return {
-		glob: rawGlob || glob$2,
+		glob: rawGlob || glob,
 		source
 	};
 }
@@ -3149,7 +3192,7 @@ var LintRequest = class {
 function mergeFiles(a, b) {
 	const files = merge(a, b);
 	if (!files) return void 0;
-	return [...new Set(files.flatMap((a$1) => a$1.split("\n").map((a$2) => a$2.trim())).filter((a$1) => !!a$1))];
+	return [...new Set(files.flatMap((a) => a.split("\n").map((a) => a.trim())).filter((a) => !!a))];
 }
 function merge(a, b) {
 	if (!a) return b;
@@ -3223,8 +3266,8 @@ var SimpleRepl = class {
 		this.rl.on("history", (h) => (this._history = h, void 0));
 	}
 	question(query) {
-		return new Promise((resolve$1) => {
-			this.rl.question(query, resolve$1);
+		return new Promise((resolve) => {
+			this.rl.question(query, resolve);
 		});
 	}
 	_completer(line) {
@@ -3252,22 +3295,26 @@ const inlineDictionaries = {
 	"[words]": {
 		name: "[words]",
 		description: "List of words to be included in the spell check.",
-		enabled: true
+		enabled: true,
+		blocked: false
 	},
 	"[flagWords]": {
 		name: "[flagWords]",
 		description: "List of words to be flagged as incorrect.",
-		enabled: true
+		enabled: true,
+		blocked: false
 	},
 	"[ignoreWords]": {
 		name: "[ignoreWords]",
 		description: "List of words to be ignored in the spell check.",
-		enabled: true
+		enabled: true,
+		blocked: false
 	},
 	"[suggestWords]": {
 		name: "[suggestWords]",
 		description: "List of spelling suggestions for words.",
-		enabled: true
+		enabled: true,
+		blocked: false
 	}
 };
 function splitList(list) {
@@ -3277,14 +3324,14 @@ function splitList(list) {
 }
 function extractDictionaryLocalesAndFileTypes(config) {
 	const map = /* @__PURE__ */ new Map();
-	function getDict(name$1) {
-		const found = map.get(name$1);
+	function getDict(name) {
+		const found = map.get(name);
 		if (found) return found;
 		const dict = {
 			locales: /* @__PURE__ */ new Set(),
 			fileTypes: /* @__PURE__ */ new Set()
 		};
-		map.set(name$1, dict);
+		map.set(name, dict);
 		return dict;
 	}
 	const languageSettings = config.languageSettings || [];
@@ -3323,14 +3370,21 @@ async function listDictionaries(options) {
 	const useFileType = options.fileType === "text" ? "plaintext" : options.fileType;
 	if (options.locale) configBase.language = options.locale;
 	const config = combineTextAndLanguageSettings(configBase, "", useFileType || configBase.languageId || "plaintext");
-	const dictionaryLocalesAndFileTypes = extractDictionaryLocalesAndFileTypes(config);
-	const enabledDictionaries = new Set(config.dictionaries || []);
+	const dictRefs = createDictionaryReferenceCollection(config.dictionaries || []);
+	const allDictionaries = [...dictRefs.enabled(), ...dictRefs.blocked()];
+	const dictionaryLocalesAndFileTypes = extractDictionaryLocalesAndFileTypes({
+		...config,
+		dictionaries: allDictionaries
+	});
+	const enabledDictionaries = new Set(dictRefs.enabled());
+	const blockedDictionaries = new Set(dictRefs.blocked());
 	function toListDictionariesResult(dict) {
 		const inline = extractInlineDictionaries(dict);
 		return {
 			name: dict.name,
 			description: dict.description,
 			enabled: enabledDictionaries.has(dict.name),
+			blocked: blockedDictionaries.has(dict.name),
 			path: dict.path,
 			inline,
 			locales: [...dictionaryLocalesAndFileTypes.get(dict.name)?.locales || []].sort(),
@@ -3438,5 +3492,5 @@ function parseApplicationFeatureFlags(flags) {
 }
 
 //#endregion
-export { CheckFailed as C, ApplicationError as S, padLeft as _, parseApplicationFeatureFlags as a, pruneAnsiTextStart as b, listDictionaries as c, validateUnitSize as d, unindent as f, tableToLines as g, getReporter as h, lint as i, ReportChoicesAll as l, npmPackage as m, checkText as n, suggestions as o, DEFAULT_CACHE_LOCATION as p, createInit as r, trace as s, IncludeExcludeFlag as t, cvtLinterCliCommandOptionsToLinterCliOptions as u, padWidth as v, console as w, width as x, pruneAnsiTextEnd as y };
-//# sourceMappingURL=application-BBOBF62T.js.map
+export { ApplicationError as C, width as S, console as T, padLeft as _, parseApplicationFeatureFlags as a, pruneAnsiTextEnd 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, CheckFailed as w, pruneAnsiTextStart as x, ansiWidth as y };
+//# sourceMappingURL=application-DYABxs7R.js.map