@dev-pi2pie/word-counter 0.1.0-canary.5 → 0.1.0

package/dist/esm/bin.mjs

@@ -2,9 +2,10 @@
 
 import { Command, Option } from "commander";
 import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, statSync } from "node:fs";
-import { parseDocument } from "yaml";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { readFile, readdir, stat } from "node:fs/promises";
+import { parseDocument } from "yaml";
 
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -34,1393 +35,1820 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-//#region src/markdown/toml/arrays.ts
-function ensureArrayContainer(result, key) {
-	const existing = result[key];
-	if (Array.isArray(existing)) return existing;
-	const list = [];
-	result[key] = list;
-	return list;
+//#region src/cli/debug/channel.ts
+const NOOP_CLOSE = async () => {};
+function shouldEmitAtVerbosity(channelVerbosity, eventVerbosity) {
+	return channelVerbosity === "verbose" || eventVerbosity === "compact";
 }
-function flattenArrayTables(result) {
-	for (const [key, value] of Object.entries(result)) {
-		if (!Array.isArray(value)) continue;
-		result[key] = value.map((entry) => Object.entries(entry).map(([entryKey, entryValue]) => `${entryKey}=${entryValue}`).join(", ")).join(" | ");
+function formatTimestampPart(value) {
+	return String(value).padStart(2, "0");
+}
+function formatDebugReportTimestamp(now) {
+	return [`${now.getFullYear()}${formatTimestampPart(now.getMonth() + 1)}${formatTimestampPart(now.getDate())}`, `${formatTimestampPart(now.getHours())}${formatTimestampPart(now.getMinutes())}${formatTimestampPart(now.getSeconds())}`].join("-");
+}
+function withCollisionSuffix(pathValue, sequence) {
+	if (sequence <= 0) return pathValue;
+	const extension = extname(pathValue);
+	const baseName = basename(pathValue, extension);
+	return join(dirname(pathValue), `${baseName}-${sequence}${extension}`);
+}
+function resolveReportPath(report, now, pid) {
+	const cwd = report.cwd ?? process.cwd();
+	const defaultName = `wc-debug-${formatDebugReportTimestamp(now)}-${pid}.jsonl`;
+	const explicitPath = typeof report.path === "string";
+	const basePath = explicitPath ? resolve(cwd, report.path) : resolve(cwd, defaultName);
+	mkdirSync(dirname(basePath), { recursive: true });
+	if (explicitPath) {
+		if (existsSync(basePath) && statSync(basePath).isDirectory()) throw new Error(`debug report path must be a file: ${basePath}`);
+		return basePath;
+	}
+	let candidate = basePath;
+	let sequence = 0;
+	while (existsSync(candidate)) {
+		sequence += 1;
+		candidate = withCollisionSuffix(basePath, sequence);
 	}
+	return candidate;
 }
-
-//#endregion
-//#region src/markdown/toml/keys.ts
-function stripKeyQuotes(key) {
-	const trimmed = key.trim();
-	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
-	return trimmed;
+function createTerminalSink() {
+	return {
+		write(line) {
+			console.error(`[debug] ${line}`);
+		},
+		close: NOOP_CLOSE
+	};
 }
-function normalizeKeyPath(key) {
-	const trimmed = key.trim();
-	if (!trimmed) return null;
-	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-		const unquoted = stripKeyQuotes(trimmed);
-		return unquoted ? unquoted : null;
+function createFileSink(pathValue) {
+	try {
+		closeSync(openSync(pathValue, "a"));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`debug report path is not writable: ${pathValue} (${message})`);
 	}
-	const segments = trimmed.split(".").map((segment) => segment.trim());
-	if (segments.some((segment) => !segment)) return null;
-	return segments.join(".");
+	const stream = createWriteStream(pathValue, {
+		flags: "a",
+		encoding: "utf8"
+	});
+	let streamError;
+	stream.on("error", (error) => {
+		streamError = error;
+	});
+	return {
+		write(line) {
+			if (streamError || stream.destroyed) return;
+			stream.write(`${line}\n`);
+		},
+		close() {
+			if (streamError || stream.destroyed || stream.writableEnded) return Promise.resolve();
+			return new Promise((resolve) => {
+				stream.end(() => {
+					resolve();
+				});
+			});
+		}
+	};
+}
+function createDebugChannel(options) {
+	if (!options.enabled) return {
+		enabled: false,
+		verbosity: options.verbosity ?? "compact",
+		emit() {},
+		close: NOOP_CLOSE
+	};
+	const verbosity = options.verbosity ?? "compact";
+	const sinks = [];
+	let reportPath;
+	if (options.report) {
+		const now = options.now?.() ?? /* @__PURE__ */ new Date();
+		const pid = options.pid ?? process.pid;
+		reportPath = resolveReportPath(options.report, now, pid);
+		sinks.push(createFileSink(reportPath));
+		if (options.report.tee) sinks.push(createTerminalSink());
+	} else sinks.push(createTerminalSink());
+	return {
+		enabled: true,
+		verbosity,
+		reportPath,
+		emit(event, details = {}, eventOptions = {}) {
+			if (!shouldEmitAtVerbosity(verbosity, eventOptions.verbosity ?? "compact")) return;
+			const payload = JSON.stringify({
+				event,
+				...details
+			});
+			for (const sink of sinks) sink.write(payload);
+		},
+		async close() {
+			for (const sink of sinks) await sink.close();
+		}
+	};
 }
 
 //#endregion
-//#region src/markdown/toml/strings.ts
-function stripInlineComment(line) {
-	let inString = null;
-	let escaped = false;
-	for (let i = 0; i < line.length; i += 1) {
-		const char = line[i] ?? "";
-		if (inString) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\" && inString === "double") {
-				escaped = true;
-				continue;
-			}
-			if (inString === "double" && char === "\"") {
-				inString = null;
-				continue;
-			}
-			if (inString === "single" && char === "'") {
-				inString = null;
-				continue;
-			}
-			continue;
-		}
-		if (char === "\"") {
-			inString = "double";
-			continue;
-		}
-		if (char === "'") {
-			inString = "single";
-			continue;
-		}
-		if (char === "#") return line.slice(0, i).trimEnd();
+//#region src/cli/path/filter.ts
+const DEFAULT_INCLUDE_EXTENSIONS = new Set([
+	".md",
+	".markdown",
+	".mdx",
+	".mdc",
+	".txt"
+]);
+function collectExtensionOption(value, previous = []) {
+	return [...previous, value];
+}
+function normalizeExtensionToken(value) {
+	const trimmed = value.trim().toLowerCase();
+	if (!trimmed) return null;
+	const normalized = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+	if (normalized === ".") return null;
+	return normalized;
+}
+function parseExtensionValues(values) {
+	const parsed = /* @__PURE__ */ new Set();
+	if (!values || values.length === 0) return parsed;
+	for (const value of values) for (const token of value.split(",")) {
+		const normalized = normalizeExtensionToken(token);
+		if (!normalized) continue;
+		parsed.add(normalized);
 	}
-	return line;
+	return parsed;
 }
-function unescapeBasic(input) {
-	return input.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
+function buildDirectoryExtensionFilter(includeValues, excludeValues) {
+	const includeFromFlags = parseExtensionValues(includeValues);
+	const excludeExtensions = parseExtensionValues(excludeValues);
+	const includeExtensions = includeFromFlags.size > 0 ? includeFromFlags : new Set(DEFAULT_INCLUDE_EXTENSIONS);
+	const effectiveIncludeExtensions = /* @__PURE__ */ new Set();
+	for (const extension of includeExtensions) {
+		if (excludeExtensions.has(extension)) continue;
+		effectiveIncludeExtensions.add(extension);
+	}
+	return {
+		includeExtensions,
+		excludeExtensions,
+		effectiveIncludeExtensions
+	};
 }
-function parseStringLiteral(value) {
-	if (value.startsWith("\"\"\"") && value.endsWith("\"\"\"")) return unescapeBasic(value.slice(3, -3));
-	if (value.startsWith("'''") && value.endsWith("'''")) return value.slice(3, -3);
-	if (value.startsWith("\"") && value.endsWith("\"")) return unescapeBasic(value.slice(1, -1));
-	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
-	return null;
+function shouldIncludeFromDirectory(filePath, filter) {
+	const extension = extname(filePath).toLowerCase();
+	return filter.effectiveIncludeExtensions.has(extension);
 }
 
 //#endregion
-//#region src/markdown/toml/values.ts
-function parsePrimitive(raw) {
-	const value = raw.trim();
-	if (!value) return null;
-	const stringLiteral = parseStringLiteral(value);
-	if (stringLiteral !== null) return stringLiteral;
-	if (value === "true") return true;
-	if (value === "false") return false;
-	if (/^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)) return Number(value);
-	if (/^\d{4}-\d{2}-\d{2}/.test(value)) return value;
-	return value;
+//#region src/cli/total-of.ts
+const TOTAL_OF_PARTS = [
+	"words",
+	"emoji",
+	"symbols",
+	"punctuation",
+	"whitespace"
+];
+const TOTAL_OF_PART_ALIASES = {
+	word: "words",
+	words: "words",
+	emoji: "emoji",
+	emojis: "emoji",
+	symbol: "symbols",
+	symbols: "symbols",
+	punction: "punctuation",
+	punctuation: "punctuation",
+	whitespace: "whitespace"
+};
+function createTotalOfCounts() {
+	return {
+		words: 0,
+		emoji: 0,
+		symbols: 0,
+		punctuation: 0,
+		whitespace: 0
+	};
 }
-function parseArray(raw) {
-	const value = raw.trim();
-	if (!value.startsWith("[") || !value.endsWith("]")) return null;
-	const inner = value.slice(1, -1).trim();
-	if (!inner) return [];
-	const items = [];
-	let current = "";
-	let inString = null;
-	let escaped = false;
-	for (let i = 0; i < inner.length; i += 1) {
-		const char = inner[i] ?? "";
-		if (inString) {
-			current += char;
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\" && inString === "double") {
-				escaped = true;
-				continue;
-			}
-			if (inString === "double" && char === "\"") inString = null;
-			else if (inString === "single" && char === "'") inString = null;
-			continue;
-		}
-		if (char === "\"") {
-			inString = "double";
-			current += char;
-			continue;
-		}
-		if (char === "'") {
-			inString = "single";
-			current += char;
+function collectNonWordCounts(target, nonWords) {
+	if (!nonWords) return;
+	target.emoji += nonWords.counts.emoji;
+	target.symbols += nonWords.counts.symbols;
+	target.punctuation += nonWords.counts.punctuation;
+	target.whitespace += nonWords.counts.whitespace ?? 0;
+}
+function collectFromWordCounterResult(result) {
+	const counts = createTotalOfCounts();
+	counts.words += result.counts?.words ?? result.total;
+	if (result.breakdown.mode === "collector") {
+		collectNonWordCounts(counts, result.breakdown.nonWords);
+		return counts;
+	}
+	for (const item of result.breakdown.items) collectNonWordCounts(counts, item.nonWords);
+	return counts;
+}
+function collectTotalOfCounts(result) {
+	if (!("section" in result)) return collectFromWordCounterResult(result);
+	const counts = createTotalOfCounts();
+	for (const item of result.items) {
+		const itemCounts = collectFromWordCounterResult(item.result);
+		for (const part of TOTAL_OF_PARTS) counts[part] += itemCounts[part];
+	}
+	return counts;
+}
+function parseTotalOfToken(token) {
+	const canonical = TOTAL_OF_PART_ALIASES[token.trim().toLowerCase()];
+	if (canonical) return canonical;
+	throw new Error(`Invalid --total-of part: ${token}. Allowed: ${TOTAL_OF_PARTS.join(", ")}.`);
+}
+function parseTotalOfOption(value) {
+	const rawTokens = value.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+	if (rawTokens.length === 0) throw new Error(`Invalid --total-of value: "${value}". Use comma-separated parts from: ${TOTAL_OF_PARTS.join(", ")}.`);
+	const parts = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const token of rawTokens) {
+		const parsed = parseTotalOfToken(token);
+		if (seen.has(parsed)) continue;
+		seen.add(parsed);
+		parts.push(parsed);
+	}
+	return parts;
+}
+function requiresNonWordCollection(parts) {
+	if (!parts || parts.length === 0) return false;
+	return parts.some((part) => part !== "words");
+}
+function requiresWhitespaceCollection(parts) {
+	if (!parts || parts.length === 0) return false;
+	return parts.includes("whitespace");
+}
+function resolveTotalOfOverride(result, parts) {
+	if (!parts || parts.length === 0) return;
+	const counts = collectTotalOfCounts(result);
+	let total = 0;
+	for (const part of parts) total += counts[part];
+	return {
+		parts: [...parts],
+		total
+	};
+}
+function formatTotalOfParts(parts) {
+	return parts.join(", ");
+}
+
+//#endregion
+//#region src/cli/program/options.ts
+const MODE_CHOICES = [
+	"chunk",
+	"segments",
+	"collector",
+	"char",
+	"char-collector"
+];
+const FORMAT_CHOICES = [
+	"standard",
+	"raw",
+	"json"
+];
+const SECTION_CHOICES = [
+	"all",
+	"split",
+	"frontmatter",
+	"content",
+	"per-key",
+	"split-per-key"
+];
+const PATH_MODE_CHOICES = ["auto", "manual"];
+function collectPathValue(value, previous = []) {
+	return [...previous, value];
+}
+function configureProgramOptions(program, parseMode) {
+	program.addOption(new Option("-m, --mode <mode>", "breakdown mode").choices(MODE_CHOICES).argParser(parseMode).default("chunk")).addOption(new Option("-f, --format <format>", "output format").choices(FORMAT_CHOICES).default("standard")).addOption(new Option("--section <section>", "document section mode").choices(SECTION_CHOICES).default("all")).addOption(new Option("--path-mode <mode>", "path resolution mode").choices(PATH_MODE_CHOICES).default("auto")).option("--latin-language <language>", "hint a language tag for Latin script text").option("--latin-tag <tag>", "hint a BCP 47 tag for Latin script text").option("--latin-locale <locale>", "legacy alias of --latin-language").option("--han-language <language>", "hint a language tag for Han script text").option("--han-tag <tag>", "hint a BCP 47 tag for Han script text").option("--non-words", "collect emoji, symbols, and punctuation (excludes whitespace)").option("--include-whitespace", "include whitespace counts (implies with --non-words; same as --misc)").option("--misc", "collect non-words plus whitespace (alias for --include-whitespace)").option("--total-of <parts>", "override total composition (comma-separated): words,emoji,symbols,punctuation,whitespace", parseTotalOfOption).option("--pretty", "pretty print JSON output", false).option("--debug", "enable debug diagnostics on stderr").option("--verbose", "emit verbose per-file debug diagnostics (requires --debug)").option("--debug-report [path]", "write debug diagnostics to a report file").option("--debug-report-tee", "mirror debug diagnostics to both report file and stderr").option("--debug-tee", "alias of --debug-report-tee").option("--merged", "show merged aggregate output (default)").option("--per-file", "show per-file output plus merged summary").option("--no-progress", "disable batch progress indicator").option("--keep-progress", "keep final batch progress line visible in standard mode").option("--no-recursive", "disable recursive directory traversal").option("--quiet-skips", "hide skip diagnostics (applies when --debug is enabled)").option("--include-ext <exts>", "comma-separated extensions to include during directory scanning", collectExtensionOption, []).option("--exclude-ext <exts>", "comma-separated extensions to exclude during directory scanning", collectExtensionOption, []).option("-p, --path <path>", "read input from file or directory", collectPathValue, []).argument("[text...]", "text to count").showHelpAfterError();
+}
+
+//#endregion
+//#region node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+
+//#endregion
+//#region src/cli/program/version.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+function* candidateSearchRoots() {
+	yield dirname(fileURLToPath(import.meta.url));
+	const argvPath = process.argv[1];
+	if (typeof argvPath === "string" && argvPath.length > 0) yield dirname(resolve(argvPath));
+	yield process.cwd();
+}
+function* walkUpDirectories(start, maxLevels) {
+	let current = start;
+	for (let depth = 0; depth < maxLevels; depth += 1) {
+		yield current;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+}
+function resolveVersionFromPath(start, maxLevels) {
+	for (const directory of walkUpDirectories(start, maxLevels)) try {
+		const raw = readFileSync(join(directory, "package.json"), "utf8");
+		const data = JSON.parse(raw);
+		if (data.version) return data.version;
+	} catch {}
+	return null;
+}
+function resolvePackageVersion() {
+	const maxLevels = 8;
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of candidateSearchRoots()) {
+		if (seen.has(root)) continue;
+		seen.add(root);
+		const version = resolveVersionFromPath(root, maxLevels);
+		if (version) return version;
+	}
+	return "0.0.0";
+}
+function getFormattedVersionLabel() {
+	const version = resolvePackageVersion();
+	return import_picocolors.default.bgBlack(import_picocolors.default.bold(import_picocolors.default.italic(` word-counter ${import_picocolors.default.cyanBright(`ver.${version}`)} `)));
+}
+
+//#endregion
+//#region src/utils/append-all.ts
+function appendAll(target, source) {
+	for (const item of source) target.push(item);
+}
+
+//#endregion
+//#region src/cli/path/load.ts
+function isProbablyBinary(buffer) {
+	if (buffer.length === 0) return false;
+	const sampleSize = Math.min(buffer.length, 1024);
+	let suspicious = 0;
+	for (let index = 0; index < sampleSize; index += 1) {
+		const byte = buffer[index] ?? 0;
+		if (byte === 0) return true;
+		if (byte === 9 || byte === 10 || byte === 13) continue;
+		if (byte >= 32 && byte <= 126) continue;
+		if (byte >= 128) continue;
+		suspicious += 1;
+	}
+	return suspicious / sampleSize > .3;
+}
+async function loadBatchInputs(filePaths) {
+	const files = [];
+	const skipped = [];
+	for (const filePath of filePaths) {
+		let buffer;
+		try {
+			buffer = await readFile(filePath);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			skipped.push({
+				path: filePath,
+				reason: `not readable: ${message}`
+			});
 			continue;
 		}
-		if (char === ",") {
-			const item = parsePrimitive(current);
-			if (item === null) return null;
-			items.push(item);
-			current = "";
+		if (isProbablyBinary(buffer)) {
+			skipped.push({
+				path: filePath,
+				reason: "binary file"
+			});
 			continue;
 		}
-		current += char;
+		files.push({
+			path: filePath,
+			content: buffer.toString("utf8")
+		});
 	}
-	const finalItem = parsePrimitive(current);
-	if (finalItem === null) return null;
-	items.push(finalItem);
-	return items;
+	return {
+		files,
+		skipped
+	};
 }
-function parseInlineTable(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
-	const inner = trimmed.slice(1, -1).trim();
-	if (!inner) return {};
-	const pairs = [];
-	let current = "";
-	let inString = null;
-	let escaped = false;
-	let bracketDepth = 0;
-	let braceDepth = 0;
-	for (let i = 0; i < inner.length; i += 1) {
-		const char = inner[i] ?? "";
-		if (inString) {
-			current += char;
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\" && inString === "double") {
-				escaped = true;
+
+//#endregion
+//#region src/cli/path/resolve.ts
+async function expandDirectory(directoryPath, recursive, filter, skipped, debug, stats) {
+	let entries;
+	try {
+		entries = await readdir(directoryPath, {
+			withFileTypes: true,
+			encoding: "utf8"
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		skipped.push({
+			path: directoryPath,
+			reason: `directory read failed: ${message}`
+		});
+		debug.emit("path.resolve.expand.read_failed", {
+			directory: directoryPath,
+			reason: `directory read failed: ${message}`
+		});
+		return [];
+	}
+	const sortedEntries = entries.slice().sort((left, right) => left.name.localeCompare(right.name));
+	const files = [];
+	debug.emit("path.resolve.expand.start", {
+		directory: directoryPath,
+		entries: sortedEntries.length,
+		recursive
+	});
+	for (const entry of sortedEntries) {
+		const entryPath = resolve(directoryPath, entry.name);
+		if (entry.isFile()) {
+			if (!shouldIncludeFromDirectory(entryPath, filter)) {
+				skipped.push({
+					path: entryPath,
+					reason: "extension excluded"
+				});
+				debug.emit("path.resolve.filter.excluded", {
+					path: entryPath,
+					reason: "extension excluded"
+				}, { verbosity: "verbose" });
+				stats.filterExcluded += 1;
 				continue;
 			}
-			if (inString === "double" && char === "\"") inString = null;
-			else if (inString === "single" && char === "'") inString = null;
-			continue;
-		}
-		if (char === "\"") {
-			inString = "double";
-			current += char;
-			continue;
-		}
-		if (char === "'") {
-			inString = "single";
-			current += char;
-			continue;
-		}
-		if (char === "[") {
-			bracketDepth += 1;
-			current += char;
-			continue;
-		}
-		if (char === "]") {
-			if (bracketDepth > 0) bracketDepth -= 1;
-			current += char;
-			continue;
-		}
-		if (char === "{") {
-			braceDepth += 1;
-			current += char;
-			continue;
-		}
-		if (char === "}") {
-			if (braceDepth > 0) braceDepth -= 1;
-			current += char;
-			continue;
-		}
-		if (char === "," && bracketDepth === 0 && braceDepth === 0) {
-			pairs.push(current);
-			current = "";
+			files.push(entryPath);
+			stats.directoryIncluded += 1;
+			debug.emit("path.resolve.expand.include", {
+				path: entryPath,
+				source: "directory"
+			}, { verbosity: "verbose" });
 			continue;
 		}
-		current += char;
-	}
-	if (current.trim()) pairs.push(current);
-	const output = {};
-	for (const pair of pairs) {
-		const separatorIndex = pair.indexOf("=");
-		if (separatorIndex === -1) return null;
-		const key = normalizeKeyPath(pair.slice(0, separatorIndex));
-		if (!key) return null;
-		const valueRaw = pair.slice(separatorIndex + 1).trim();
-		if (!valueRaw) return null;
-		if (valueRaw.startsWith("{")) return null;
-		const normalized = normalizeValue(valueRaw);
-		if (normalized === null) return null;
-		if (typeof normalized === "object" && !Array.isArray(normalized)) return null;
-		output[key] = normalized;
+		if (!entry.isDirectory() || !recursive) continue;
+		appendAll(files, await expandDirectory(entryPath, recursive, filter, skipped, debug, stats));
 	}
-	return output;
-}
-function normalizeValue(value) {
-	if (!value) return null;
-	const trimmed = value.trim();
-	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return parseInlineTable(trimmed);
-	const array = parseArray(trimmed);
-	if (array) return array;
-	if (trimmed.startsWith("[") && trimmed.endsWith("]")) return null;
-	return parsePrimitive(trimmed);
-}
-function toPlainText(value) {
-	if (value == null) return "";
-	if (Array.isArray(value)) return value.map((item) => String(item)).join(", ");
-	return String(value);
+	debug.emit("path.resolve.expand.complete", {
+		directory: directoryPath,
+		files: files.length
+	});
+	return files;
 }
-
-//#endregion
-//#region src/markdown/toml/parse-frontmatter.ts
-function parseTomlFrontmatter(frontmatter) {
-	const result = {};
-	const lines = frontmatter.split("\n");
-	let tablePrefix = "";
-	let tableTarget = null;
-	let tablePrefixInList = false;
-	for (let index = 0; index < lines.length; index += 1) {
-		const rawLine = lines[index] ?? "";
-		const trimmedLine = rawLine.trim();
-		if (!trimmedLine || trimmedLine.startsWith("#")) continue;
-		if (trimmedLine.startsWith("[[")) {
-			const match = trimmedLine.match(/^\[\[([^\]]+)]]$/);
-			if (!match) return null;
-			const normalizedTable = normalizeKeyPath(match[1] ?? "");
-			if (!normalizedTable) return null;
-			const list = ensureArrayContainer(result, normalizedTable);
-			const newEntry = {};
-			list.push(newEntry);
-			tableTarget = newEntry;
-			tablePrefix = normalizedTable;
-			tablePrefixInList = true;
-			continue;
+async function resolveBatchFilePaths(pathInputs, options) {
+	const skipped = [];
+	const resolvedFiles = /* @__PURE__ */ new Set();
+	const stats = {
+		dedupeAccepted: 0,
+		dedupeDuplicates: 0,
+		filterExcluded: 0,
+		directoryIncluded: 0
+	};
+	const extensionFilter = options.extensionFilter ?? buildDirectoryExtensionFilter(void 0, void 0);
+	const debug = options.debug ?? {
+		enabled: false,
+		verbosity: "compact",
+		emit() {},
+		close: async () => {}
+	};
+	debug.emit("path.resolve.inputs", {
+		inputs: pathInputs.length,
+		pathMode: options.pathMode,
+		recursive: options.recursive
+	});
+	const addResolvedFile = (filePath, details) => {
+		if (resolvedFiles.has(filePath)) {
+			stats.dedupeDuplicates += 1;
+			debug.emit("path.resolve.dedupe.duplicate", {
+				path: filePath,
+				source: details.source,
+				input: details.input
+			}, { verbosity: "verbose" });
+			return;
 		}
-		const tableMatch = trimmedLine.match(/^\[([^\]]+)]$/);
-		if (tableMatch) {
-			const normalizedTable = normalizeKeyPath(tableMatch[1] ?? "");
-			if (!normalizedTable) return null;
-			tablePrefix = normalizedTable;
-			tablePrefixInList = false;
-			tableTarget = null;
+		resolvedFiles.add(filePath);
+		stats.dedupeAccepted += 1;
+		debug.emit("path.resolve.dedupe.accept", {
+			path: filePath,
+			source: details.source,
+			input: details.input
+		}, { verbosity: "verbose" });
+	};
+	for (const rawPath of pathInputs) {
+		const targetPath = resolve(rawPath);
+		debug.emit("path.resolve.input", {
+			rawPath,
+			resolvedPath: targetPath
+		});
+		let metadata;
+		try {
+			metadata = await stat(targetPath);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			skipped.push({
+				path: targetPath,
+				reason: `not readable: ${message}`
+			});
+			debug.emit("path.resolve.skip", {
+				path: targetPath,
+				reason: `not readable: ${message}`
+			});
 			continue;
 		}
-		const lineForParsing = /("""|''')/.test(rawLine) ? rawLine : stripInlineComment(rawLine);
-		const separatorIndex = lineForParsing.indexOf("=");
-		if (separatorIndex === -1) return null;
-		const key = normalizeKeyPath(lineForParsing.slice(0, separatorIndex));
-		let valueRaw = lineForParsing.slice(separatorIndex + 1).trim();
-		if (!key) return null;
-		const tripleDelimiter = valueRaw.startsWith("\"\"\"") ? "\"\"\"" : valueRaw.startsWith("'''") ? "'''" : null;
-		if (tripleDelimiter) {
-			const closingIndex = valueRaw.indexOf(tripleDelimiter, tripleDelimiter.length);
-			if (closingIndex !== -1) {
-				const strippedAfter = stripInlineComment(valueRaw.slice(closingIndex + tripleDelimiter.length));
-				valueRaw = `${valueRaw.slice(0, closingIndex + tripleDelimiter.length)}${strippedAfter}`;
-			} else {
-				const delimiter = tripleDelimiter;
-				let combined = valueRaw;
-				let closed = false;
-				while (index + 1 < lines.length) {
-					index += 1;
-					const nextLine = lines[index] ?? "";
-					combined += `\n${nextLine}`;
-					if (new RegExp(`${delimiter}\\s*$`).test(nextLine)) {
-						closed = true;
-						break;
-					}
-				}
-				if (!closed) return null;
-				valueRaw = combined;
-			}
-		}
-		const normalized = normalizeValue(valueRaw);
-		if (normalized === null) return null;
-		const fullKey = tablePrefix ? `${tablePrefix}.${key}` : key;
-		if (typeof normalized === "object" && !Array.isArray(normalized)) {
-			for (const [inlineKey, inlineValue] of Object.entries(normalized)) {
-				const entryKey = tablePrefixInList ? `${key}.${inlineKey}` : `${fullKey}.${inlineKey}`;
-				if (tablePrefixInList && tableTarget) tableTarget[entryKey] = toPlainText(inlineValue);
-				else result[entryKey] = toPlainText(inlineValue);
-			}
+		if (metadata.isDirectory() && options.pathMode === "auto") {
+			debug.emit("path.resolve.root.expand", {
+				root: targetPath,
+				recursive: options.recursive
+			});
+			const files = await expandDirectory(targetPath, options.recursive, extensionFilter, skipped, debug, stats);
+			for (const file of files) addResolvedFile(file, {
+				source: "directory",
+				input: targetPath
+			});
 			continue;
 		}
-		if (tablePrefixInList && tableTarget) {
-			tableTarget[key] = toPlainText(normalized);
+		if (!metadata.isFile()) {
+			skipped.push({
+				path: targetPath,
+				reason: "not a regular file"
+			});
+			debug.emit("path.resolve.skip", {
+				path: targetPath,
+				reason: "not a regular file"
+			});
 			continue;
 		}
-		result[fullKey] = toPlainText(normalized);
+		addResolvedFile(targetPath, {
+			source: "direct",
+			input: targetPath
+		});
 	}
-	flattenArrayTables(result);
-	return result;
+	const files = [...resolvedFiles].sort((left, right) => left.localeCompare(right));
+	debug.emit("path.resolve.filter.summary", {
+		excluded: stats.filterExcluded,
+		included: stats.directoryIncluded
+	});
+	debug.emit("path.resolve.dedupe.summary", {
+		accepted: stats.dedupeAccepted,
+		duplicates: stats.dedupeDuplicates
+	});
+	debug.emit("path.resolve.complete", {
+		files: files.length,
+		skipped: skipped.length,
+		ordering: "absolute-path-ascending"
+	});
+	return {
+		files,
+		skipped
+	};
 }
 
 //#endregion
-//#region src/markdown/parse-markdown.ts
-const FENCE_TO_TYPE = {
-	"---": "yaml",
-	"+++": "toml",
-	";;;": "json"
-};
-function normalizeNewlines(input) {
-	return input.replace(/\r\n/g, "\n");
+//#region src/cli/progress/reporter.ts
+const PROGRESS_BAR_WIDTH = 20;
+const FILLED_BAR_CHAR = "█";
+const EMPTY_BAR_CHAR = "░";
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
 }
-function stripBom(line) {
-	return line.startsWith("") ? line.slice(1) : line;
+function buildProgressBar(completed, total) {
+	const safeTotal = Math.max(total, 1);
+	const ratio = clamp(completed / safeTotal, 0, 1);
+	const filled = completed >= safeTotal ? PROGRESS_BAR_WIDTH : Math.floor(ratio * PROGRESS_BAR_WIDTH);
+	const empty = PROGRESS_BAR_WIDTH - filled;
+	return `${FILLED_BAR_CHAR.repeat(filled)}${EMPTY_BAR_CHAR.repeat(empty)}`;
 }
-function getFenceType(line) {
-	const match = line.match(/^[\t ]*(---|\+\+\+|;;;)[\t ]*$/);
-	if (!match) return null;
-	return FENCE_TO_TYPE[match[1] ?? ""] ?? null;
+function formatElapsed(startedAtMs) {
+	const elapsedMs = Date.now() - startedAtMs;
+	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	const tenths = Math.floor(Math.max(0, elapsedMs) % 1e3 / 100);
+	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${tenths}`;
+}
+function buildProgressLine(completed, total, startedAtMs) {
+	const safeTotal = Math.max(total, 1);
+	const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
+	return `Counting files [${buildProgressBar(completed, safeTotal)}] ${`${String(percent).padStart(3, " ")}%`} ${String(completed).padStart(String(safeTotal).length, " ")}/${safeTotal} elapsed ${formatElapsed(startedAtMs)}`;
+}
+function buildFinalizingLine(startedAtMs) {
+	return `Finalizing aggregate... elapsed ${formatElapsed(startedAtMs)}`;
+}
+function createBatchProgressReporter(options) {
+	const enabled = options.enabled;
+	const isTTY = Boolean(options.stream.isTTY);
+	const clearOnFinish = options.clearOnFinish ?? true;
+	let active = false;
+	let total = 0;
+	let lastLineLength = 0;
+	let startedAtMs = 0;
+	let lastRenderedPercent = -1;
+	let finalizingStarted = false;
+	const writeTTYLine = (line) => {
+		const trailingPadding = lastLineLength > line.length ? " ".repeat(lastLineLength - line.length) : "";
+		options.stream.write(`\r${line}${trailingPadding}`);
+		lastLineLength = line.length;
+	};
+	const render = (completed) => {
+		const line = buildProgressLine(completed, total, startedAtMs);
+		const safeTotal = Math.max(total, 1);
+		const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
+		if (!isTTY && percent === lastRenderedPercent && completed < safeTotal) return;
+		lastRenderedPercent = percent;
+		if (isTTY) {
+			writeTTYLine(line);
+			return;
+		}
+		lastLineLength = line.length;
+		options.stream.write(`${line}\n`);
+	};
+	const clearLine = () => {
+		if (lastLineLength === 0) return;
+		options.stream.write(`\r${" ".repeat(lastLineLength)}\r`);
+		lastLineLength = 0;
+	};
+	return {
+		enabled,
+		start(nextTotal, nextStartedAtMs) {
+			if (!enabled || nextTotal <= 1) return;
+			total = nextTotal;
+			active = true;
+			startedAtMs = nextStartedAtMs ?? Date.now();
+			lastRenderedPercent = -1;
+			finalizingStarted = false;
+			render(0);
+		},
+		advance(snapshot) {
+			if (!active) return;
+			render(snapshot.completed);
+		},
+		startFinalizing() {
+			if (!active || finalizingStarted) return;
+			finalizingStarted = true;
+			const line = buildFinalizingLine(startedAtMs);
+			if (isTTY) {
+				if (!clearOnFinish) {
+					options.stream.write(`\n${line}`);
+					lastLineLength = line.length;
+					return;
+				}
+				writeTTYLine(line);
+				return;
+			}
+			lastLineLength = line.length;
+			options.stream.write(`${line}\n`);
+		},
+		finish() {
+			if (!active) return;
+			if (isTTY) if (clearOnFinish) clearLine();
+			else options.stream.write("\n");
+			active = false;
+		}
+	};
+}
+
+//#endregion
+//#region src/markdown/toml/arrays.ts
+function ensureArrayContainer(result, key) {
+	const existing = result[key];
+	if (Array.isArray(existing)) return existing;
+	const list = [];
+	result[key] = list;
+	return list;
 }
-function parseFrontmatter(frontmatter, type) {
-	if (!type) return null;
-	if (type === "json") try {
-		return JSON.parse(frontmatter);
-	} catch {
-		return null;
+function flattenArrayTables(result) {
+	for (const [key, value] of Object.entries(result)) {
+		if (!Array.isArray(value)) continue;
+		result[key] = value.map((entry) => Object.entries(entry).map(([entryKey, entryValue]) => `${entryKey}=${entryValue}`).join(", ")).join(" | ");
 	}
-	if (type === "yaml") {
-		const doc = parseDocument(frontmatter, { prettyErrors: false });
-		if (doc.errors.length > 0) return null;
-		const data = doc.toJSON();
-		if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-		return data;
+}
+
+//#endregion
+//#region src/markdown/toml/keys.ts
+function stripKeyQuotes(key) {
+	const trimmed = key.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function normalizeKeyPath(key) {
+	const trimmed = key.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+		const unquoted = stripKeyQuotes(trimmed);
+		return unquoted ? unquoted : null;
 	}
-	if (type === "toml") return parseTomlFrontmatter(frontmatter);
-	return null;
+	const segments = trimmed.split(".").map((segment) => segment.trim());
+	if (segments.some((segment) => !segment)) return null;
+	return segments.join(".");
 }
-function extractJsonBlock(text, startIndex) {
-	let depth = 0;
-	let inString = false;
+
+//#endregion
+//#region src/markdown/toml/strings.ts
+function stripInlineComment(line) {
+	let inString = null;
 	let escaped = false;
-	for (let i = startIndex; i < text.length; i += 1) {
-		const char = text[i] ?? "";
+	for (let i = 0; i < line.length; i += 1) {
+		const char = line[i] ?? "";
 		if (inString) {
 			if (escaped) {
 				escaped = false;
 				continue;
 			}
-			if (char === "\\") {
+			if (char === "\\" && inString === "double") {
 				escaped = true;
 				continue;
 			}
-			if (char === "\"") inString = false;
+			if (inString === "double" && char === "\"") {
+				inString = null;
+				continue;
+			}
+			if (inString === "single" && char === "'") {
+				inString = null;
+				continue;
+			}
 			continue;
 		}
 		if (char === "\"") {
-			inString = true;
+			inString = "double";
 			continue;
 		}
-		if (char === "{") {
-			depth += 1;
+		if (char === "'") {
+			inString = "single";
 			continue;
 		}
-		if (char === "}") {
-			depth -= 1;
-			if (depth === 0) return {
-				jsonText: text.slice(startIndex, i + 1),
-				endIndex: i
-			};
-		}
-	}
-	return null;
-}
-function parseMarkdown(input) {
-	const normalized = normalizeNewlines(input);
-	const lines = normalized.split("\n");
-	if (lines.length === 0) return {
-		frontmatter: null,
-		content: normalized,
-		data: null,
-		frontmatterType: null
-	};
-	lines[0] = stripBom(lines[0] ?? "");
-	const normalizedWithoutBom = lines.join("\n");
-	const openingType = getFenceType(lines[0] ?? "");
-	if (!openingType) {
-		const jsonStart = (normalizedWithoutBom.match(/^[\t \n]*/)?.[0] ?? "").length;
-		if (normalizedWithoutBom[jsonStart] !== "{") return {
-			frontmatter: null,
-			content: normalizedWithoutBom,
-			data: null,
-			frontmatterType: null
-		};
-		const jsonBlock = extractJsonBlock(normalizedWithoutBom, jsonStart);
-		if (!jsonBlock) return {
-			frontmatter: null,
-			content: normalizedWithoutBom,
-			data: null,
-			frontmatterType: null
-		};
-		const frontmatter = jsonBlock.jsonText;
-		let content = normalizedWithoutBom.slice(jsonBlock.endIndex + 1);
-		if (content.startsWith("\n")) content = content.slice(1);
-		const data = parseFrontmatter(frontmatter, "json");
-		if (!data) return {
-			frontmatter: null,
-			content: normalizedWithoutBom,
-			data: null,
-			frontmatterType: null
-		};
-		return {
-			frontmatter,
-			content,
-			data,
-			frontmatterType: "json"
-		};
-	}
-	let closingIndex = -1;
-	for (let i = 1; i < lines.length; i += 1) if (getFenceType(lines[i] ?? "") === openingType) {
-		closingIndex = i;
-		break;
+		if (char === "#") return line.slice(0, i).trimEnd();
 	}
-	if (closingIndex === -1) return {
-		frontmatter: null,
-		content: normalizedWithoutBom,
-		data: null,
-		frontmatterType: null
-	};
-	const frontmatter = lines.slice(1, closingIndex).join("\n");
-	return {
-		frontmatter,
-		content: lines.slice(closingIndex + 1).join("\n"),
-		data: parseFrontmatter(frontmatter, openingType),
-		frontmatterType: openingType
-	};
-}
-
-//#endregion
-//#region src/wc/segmenter.ts
-const segmenterCache = /* @__PURE__ */ new Map();
-const graphemeSegmenterCache = /* @__PURE__ */ new Map();
-function getSegmenter(locale) {
-	const cached = segmenterCache.get(locale);
-	if (cached) return cached;
-	const segmenter = new Intl.Segmenter(locale, { granularity: "word" });
-	segmenterCache.set(locale, segmenter);
-	return segmenter;
-}
-function getGraphemeSegmenter(locale) {
-	const cached = graphemeSegmenterCache.get(locale);
-	if (cached) return cached;
-	const segmenter = new Intl.Segmenter(locale, { granularity: "grapheme" });
-	graphemeSegmenterCache.set(locale, segmenter);
-	return segmenter;
+	return line;
 }
-function supportsSegmenter() {
-	return typeof Intl !== "undefined" && typeof Intl.Segmenter === "function";
+function unescapeBasic(input) {
+	return input.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
 }
-function countCharsForLocale(text, locale) {
-	if (!supportsSegmenter()) return Array.from(text).length;
-	const segmenter = getGraphemeSegmenter(locale);
-	let count = 0;
-	for (const _segment of segmenter.segment(text)) count++;
-	return count;
+function parseStringLiteral(value) {
+	if (value.startsWith("\"\"\"") && value.endsWith("\"\"\"")) return unescapeBasic(value.slice(3, -3));
+	if (value.startsWith("'''") && value.endsWith("'''")) return value.slice(3, -3);
+	if (value.startsWith("\"") && value.endsWith("\"")) return unescapeBasic(value.slice(1, -1));
+	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	return null;
 }
 
 //#endregion
-//#region src/utils/append-all.ts
-function appendAll(target, source) {
-	for (const item of source) target.push(item);
+//#region src/markdown/toml/values.ts
+function parsePrimitive(raw) {
+	const value = raw.trim();
+	if (!value) return null;
+	const stringLiteral = parseStringLiteral(value);
+	if (stringLiteral !== null) return stringLiteral;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (/^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)) return Number(value);
+	if (/^\d{4}-\d{2}-\d{2}/.test(value)) return value;
+	return value;
 }
-
-//#endregion
-//#region src/wc/non-words.ts
-const emojiRegex = /(?:\p{Extended_Pictographic}|\p{Emoji_Presentation})/u;
-const emojiPresentationRegex = /\p{Emoji_Presentation}/u;
-const keycapEmojiRegex = /[0-9#*]\uFE0F?\u20E3/u;
-const symbolRegex = /\p{S}/u;
-const punctuationRegex = /\p{P}/u;
-const whitespaceRegex = /\s/u;
-const newlineChars = new Set([
-	"\n",
-	"\r",
-	"\u2028",
-	"\u2029"
-]);
-function createNonWordCollection() {
-	return {
-		emoji: [],
-		symbols: [],
-		punctuation: [],
-		counts: {
-			emoji: 0,
-			symbols: 0,
-			punctuation: 0
+function parseArray(raw) {
+	const value = raw.trim();
+	if (!value.startsWith("[") || !value.endsWith("]")) return null;
+	const inner = value.slice(1, -1).trim();
+	if (!inner) return [];
+	const items = [];
+	let current = "";
+	let inString = null;
+	let escaped = false;
+	for (let i = 0; i < inner.length; i += 1) {
+		const char = inner[i] ?? "";
+		if (inString) {
+			current += char;
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\" && inString === "double") {
+				escaped = true;
+				continue;
+			}
+			if (inString === "double" && char === "\"") inString = null;
+			else if (inString === "single" && char === "'") inString = null;
+			continue;
 		}
-	};
-}
-function addNonWord(collection, category, segment) {
-	if (category === "emoji") {
-		collection.emoji.push(segment);
-		collection.counts.emoji += 1;
-		return;
-	}
-	if (category === "symbol") {
-		collection.symbols.push(segment);
-		collection.counts.symbols += 1;
-		return;
+		if (char === "\"") {
+			inString = "double";
+			current += char;
+			continue;
+		}
+		if (char === "'") {
+			inString = "single";
+			current += char;
+			continue;
+		}
+		if (char === ",") {
+			const item = parsePrimitive(current);
+			if (item === null) return null;
+			items.push(item);
+			current = "";
+			continue;
+		}
+		current += char;
 	}
-	collection.punctuation.push(segment);
-	collection.counts.punctuation += 1;
+	const finalItem = parsePrimitive(current);
+	if (finalItem === null) return null;
+	items.push(finalItem);
+	return items;
 }
-function addWhitespace(collection, segment) {
-	let whitespace = collection.whitespace;
-	let count = 0;
-	for (const char of segment) {
-		if (char === " ") {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.spaces += 1;
-			count += 1;
+function parseInlineTable(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+	const inner = trimmed.slice(1, -1).trim();
+	if (!inner) return {};
+	const pairs = [];
+	let current = "";
+	let inString = null;
+	let escaped = false;
+	let bracketDepth = 0;
+	let braceDepth = 0;
+	for (let i = 0; i < inner.length; i += 1) {
+		const char = inner[i] ?? "";
+		if (inString) {
+			current += char;
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\" && inString === "double") {
+				escaped = true;
+				continue;
+			}
+			if (inString === "double" && char === "\"") inString = null;
+			else if (inString === "single" && char === "'") inString = null;
 			continue;
 		}
-		if (char === "	") {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.tabs += 1;
-			count += 1;
+		if (char === "\"") {
+			inString = "double";
+			current += char;
 			continue;
 		}
-		if (newlineChars.has(char)) {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.newlines += 1;
-			count += 1;
+		if (char === "'") {
+			inString = "single";
+			current += char;
 			continue;
 		}
-		if (whitespaceRegex.test(char)) {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.other += 1;
-			count += 1;
+		if (char === "[") {
+			bracketDepth += 1;
+			current += char;
+			continue;
+		}
+		if (char === "]") {
+			if (bracketDepth > 0) bracketDepth -= 1;
+			current += char;
+			continue;
+		}
+		if (char === "{") {
+			braceDepth += 1;
+			current += char;
+			continue;
+		}
+		if (char === "}") {
+			if (braceDepth > 0) braceDepth -= 1;
+			current += char;
+			continue;
+		}
+		if (char === "," && bracketDepth === 0 && braceDepth === 0) {
+			pairs.push(current);
+			current = "";
+			continue;
 		}
+		current += char;
 	}
-	if (count > 0) {
-		collection.whitespace = whitespace ?? createWhitespaceCounts();
-		collection.counts.whitespace = (collection.counts.whitespace ?? 0) + count;
+	if (current.trim()) pairs.push(current);
+	const output = {};
+	for (const pair of pairs) {
+		const separatorIndex = pair.indexOf("=");
+		if (separatorIndex === -1) return null;
+		const key = normalizeKeyPath(pair.slice(0, separatorIndex));
+		if (!key) return null;
+		const valueRaw = pair.slice(separatorIndex + 1).trim();
+		if (!valueRaw) return null;
+		if (valueRaw.startsWith("{")) return null;
+		const normalized = normalizeValue(valueRaw);
+		if (normalized === null) return null;
+		if (typeof normalized === "object" && !Array.isArray(normalized)) return null;
+		output[key] = normalized;
 	}
-	return count;
-}
-function classifyNonWordSegment(segment) {
-	const hasEmojiVariationSelector = segment.includes("️");
-	if (keycapEmojiRegex.test(segment) || emojiPresentationRegex.test(segment) || hasEmojiVariationSelector && emojiRegex.test(segment)) return "emoji";
-	if (symbolRegex.test(segment)) return "symbol";
-	if (punctuationRegex.test(segment)) return "punctuation";
-	return null;
+	return output;
 }
-function mergeNonWordCollections(target, source) {
-	if (source.counts.emoji > 0) {
-		appendAll(target.emoji, source.emoji);
-		target.counts.emoji += source.counts.emoji;
-	}
-	if (source.counts.symbols > 0) {
-		appendAll(target.symbols, source.symbols);
-		target.counts.symbols += source.counts.symbols;
-	}
-	if (source.counts.punctuation > 0) {
-		appendAll(target.punctuation, source.punctuation);
-		target.counts.punctuation += source.counts.punctuation;
-	}
-	if (source.counts.whitespace && source.counts.whitespace > 0 && source.whitespace) {
-		const whitespace = target.whitespace ?? createWhitespaceCounts();
-		whitespace.spaces += source.whitespace.spaces;
-		whitespace.tabs += source.whitespace.tabs;
-		whitespace.newlines += source.whitespace.newlines;
-		whitespace.other += source.whitespace.other;
-		target.whitespace = whitespace;
-		target.counts.whitespace = (target.counts.whitespace ?? 0) + source.counts.whitespace;
-	}
-	return target;
+function normalizeValue(value) {
+	if (!value) return null;
+	const trimmed = value.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return parseInlineTable(trimmed);
+	const array = parseArray(trimmed);
+	if (array) return array;
+	if (trimmed.startsWith("[") && trimmed.endsWith("]")) return null;
+	return parsePrimitive(trimmed);
 }
-function createWhitespaceCounts() {
-	return {
-		spaces: 0,
-		tabs: 0,
-		newlines: 0,
-		other: 0
-	};
+function toPlainText(value) {
+	if (value == null) return "";
+	if (Array.isArray(value)) return value.map((item) => String(item)).join(", ");
+	return String(value);
 }
 
 //#endregion
-//#region src/wc/analyze.ts
-function analyzeChunk(chunk, collectNonWords, includeWhitespace) {
-	const segmenter = getSegmenter(chunk.locale);
-	const segments = [];
-	const nonWords = collectNonWords ? createNonWordCollection() : null;
-	for (const part of segmenter.segment(chunk.text)) if (part.isWordLike) segments.push(part.segment);
-	else if (collectNonWords && nonWords) {
-		if (includeWhitespace) addWhitespace(nonWords, part.segment);
-		const category = classifyNonWordSegment(part.segment);
-		if (category) addNonWord(nonWords, category, part.segment);
-	}
-	return {
-		locale: chunk.locale,
-		text: chunk.text,
-		segments,
-		words: segments.length,
-		nonWords: nonWords ?? void 0
-	};
-}
-function analyzeCharChunk(chunk, collectNonWords, includeWhitespace) {
-	const segmenter = getSegmenter(chunk.locale);
-	const nonWords = collectNonWords ? createNonWordCollection() : null;
-	let chars = 0;
-	let wordChars = 0;
-	let nonWordChars = 0;
-	for (const part of segmenter.segment(chunk.text)) {
-		if (part.isWordLike) {
-			const count = countCharsForLocale(part.segment, chunk.locale);
-			chars += count;
-			wordChars += count;
+//#region src/markdown/toml/parse-frontmatter.ts
+function parseTomlFrontmatter(frontmatter) {
+	const result = {};
+	const lines = frontmatter.split("\n");
+	let tablePrefix = "";
+	let tableTarget = null;
+	let tablePrefixInList = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const rawLine = lines[index] ?? "";
+		const trimmedLine = rawLine.trim();
+		if (!trimmedLine || trimmedLine.startsWith("#")) continue;
+		if (trimmedLine.startsWith("[[")) {
+			const match = trimmedLine.match(/^\[\[([^\]]+)]]$/);
+			if (!match) return null;
+			const normalizedTable = normalizeKeyPath(match[1] ?? "");
+			if (!normalizedTable) return null;
+			const list = ensureArrayContainer(result, normalizedTable);
+			const newEntry = {};
+			list.push(newEntry);
+			tableTarget = newEntry;
+			tablePrefix = normalizedTable;
+			tablePrefixInList = true;
 			continue;
 		}
-		if (collectNonWords && nonWords) {
-			let whitespaceCount = 0;
-			if (includeWhitespace) whitespaceCount = addWhitespace(nonWords, part.segment);
-			const category = classifyNonWordSegment(part.segment);
-			if (category) addNonWord(nonWords, category, part.segment);
-			if (category || whitespaceCount > 0) {
-				const count = countCharsForLocale(part.segment, chunk.locale);
-				chars += count;
-				nonWordChars += count;
+		const tableMatch = trimmedLine.match(/^\[([^\]]+)]$/);
+		if (tableMatch) {
+			const normalizedTable = normalizeKeyPath(tableMatch[1] ?? "");
+			if (!normalizedTable) return null;
+			tablePrefix = normalizedTable;
+			tablePrefixInList = false;
+			tableTarget = null;
+			continue;
+		}
+		const lineForParsing = /("""|''')/.test(rawLine) ? rawLine : stripInlineComment(rawLine);
+		const separatorIndex = lineForParsing.indexOf("=");
+		if (separatorIndex === -1) return null;
+		const key = normalizeKeyPath(lineForParsing.slice(0, separatorIndex));
+		let valueRaw = lineForParsing.slice(separatorIndex + 1).trim();
+		if (!key) return null;
+		const tripleDelimiter = valueRaw.startsWith("\"\"\"") ? "\"\"\"" : valueRaw.startsWith("'''") ? "'''" : null;
+		if (tripleDelimiter) {
+			const closingIndex = valueRaw.indexOf(tripleDelimiter, tripleDelimiter.length);
+			if (closingIndex !== -1) {
+				const strippedAfter = stripInlineComment(valueRaw.slice(closingIndex + tripleDelimiter.length));
+				valueRaw = `${valueRaw.slice(0, closingIndex + tripleDelimiter.length)}${strippedAfter}`;
+			} else {
+				const delimiter = tripleDelimiter;
+				let combined = valueRaw;
+				let closed = false;
+				while (index + 1 < lines.length) {
+					index += 1;
+					const nextLine = lines[index] ?? "";
+					combined += `\n${nextLine}`;
+					if (new RegExp(`${delimiter}\\s*$`).test(nextLine)) {
+						closed = true;
+						break;
+					}
+				}
+				if (!closed) return null;
+				valueRaw = combined;
 			}
 		}
-	}
-	return {
-		locale: chunk.locale,
-		text: chunk.text,
-		chars,
-		wordChars,
-		nonWordChars,
-		nonWords: nonWords ?? void 0
-	};
-}
-function aggregateByLocale(chunks) {
-	const order = [];
-	const map = /* @__PURE__ */ new Map();
-	for (const chunk of chunks) {
-		const existing = map.get(chunk.locale);
-		if (existing) {
-			existing.words += chunk.words;
-			appendAll(existing.segments, chunk.segments);
+		const normalized = normalizeValue(valueRaw);
+		if (normalized === null) return null;
+		const fullKey = tablePrefix ? `${tablePrefix}.${key}` : key;
+		if (typeof normalized === "object" && !Array.isArray(normalized)) {
+			for (const [inlineKey, inlineValue] of Object.entries(normalized)) {
+				const entryKey = tablePrefixInList ? `${key}.${inlineKey}` : `${fullKey}.${inlineKey}`;
+				if (tablePrefixInList && tableTarget) tableTarget[entryKey] = toPlainText(inlineValue);
+				else result[entryKey] = toPlainText(inlineValue);
+			}
 			continue;
 		}
-		order.push(chunk.locale);
-		map.set(chunk.locale, {
-			locale: chunk.locale,
-			words: chunk.words,
-			segments: [...chunk.segments]
-		});
+		if (tablePrefixInList && tableTarget) {
+			tableTarget[key] = toPlainText(normalized);
+			continue;
+		}
+		result[fullKey] = toPlainText(normalized);
 	}
-	return order.map((locale) => map.get(locale));
+	flattenArrayTables(result);
+	return result;
 }
 
 //#endregion
-//#region src/wc/mode.ts
-const MODE_ALIASES = {
-	chunk: "chunk",
-	chunks: "chunk",
-	segments: "segments",
-	segment: "segments",
-	seg: "segments",
-	collector: "collector",
-	collect: "collector",
-	colle: "collector",
-	char: "char",
-	chars: "char",
-	character: "char",
-	characters: "char"
+//#region src/markdown/parse-markdown.ts
+const FENCE_TO_TYPE = {
+	"---": "yaml",
+	"+++": "toml",
+	";;;": "json"
 };
-function normalizeMode(input) {
-	if (!input) return null;
-	return MODE_ALIASES[input.trim().toLowerCase()] ?? null;
+function normalizeNewlines(input) {
+	return input.replace(/\r\n/g, "\n");
 }
-function resolveMode(input, fallback = "chunk") {
-	return normalizeMode(input) ?? fallback;
+function stripBom(line) {
+	return line.startsWith("") ? line.slice(1) : line;
+}
+function getFenceType(line) {
+	const match = line.match(/^[\t ]*(---|\+\+\+|;;;)[\t ]*$/);
+	if (!match) return null;
+	return FENCE_TO_TYPE[match[1] ?? ""] ?? null;
+}
+function parseFrontmatter(frontmatter, type) {
+	if (!type) return null;
+	if (type === "json") try {
+		return JSON.parse(frontmatter);
+	} catch {
+		return null;
+	}
+	if (type === "yaml") {
+		const doc = parseDocument(frontmatter, { prettyErrors: false });
+		if (doc.errors.length > 0) return null;
+		const data = doc.toJSON();
+		if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+		return data;
+	}
+	if (type === "toml") return parseTomlFrontmatter(frontmatter);
+	return null;
+}
+function extractJsonBlock(text, startIndex) {
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = startIndex; i < text.length; i += 1) {
+		const char = text[i] ?? "";
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			continue;
+		}
+		if (char === "{") {
+			depth += 1;
+			continue;
+		}
+		if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return {
+				jsonText: text.slice(startIndex, i + 1),
+				endIndex: i
+			};
+		}
+	}
+	return null;
+}
+function parseMarkdown(input) {
+	const normalized = normalizeNewlines(input);
+	const lines = normalized.split("\n");
+	if (lines.length === 0) return {
+		frontmatter: null,
+		content: normalized,
+		data: null,
+		frontmatterType: null
+	};
+	lines[0] = stripBom(lines[0] ?? "");
+	const normalizedWithoutBom = lines.join("\n");
+	const openingType = getFenceType(lines[0] ?? "");
+	if (!openingType) {
+		const jsonStart = (normalizedWithoutBom.match(/^[\t \n]*/)?.[0] ?? "").length;
+		if (normalizedWithoutBom[jsonStart] !== "{") return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		const jsonBlock = extractJsonBlock(normalizedWithoutBom, jsonStart);
+		if (!jsonBlock) return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		const frontmatter = jsonBlock.jsonText;
+		let content = normalizedWithoutBom.slice(jsonBlock.endIndex + 1);
+		if (content.startsWith("\n")) content = content.slice(1);
+		const data = parseFrontmatter(frontmatter, "json");
+		if (!data) return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		return {
+			frontmatter,
+			content,
+			data,
+			frontmatterType: "json"
+		};
+	}
+	let closingIndex = -1;
+	for (let i = 1; i < lines.length; i += 1) if (getFenceType(lines[i] ?? "") === openingType) {
+		closingIndex = i;
+		break;
+	}
+	if (closingIndex === -1) return {
+		frontmatter: null,
+		content: normalizedWithoutBom,
+		data: null,
+		frontmatterType: null
+	};
+	const frontmatter = lines.slice(1, closingIndex).join("\n");
+	return {
+		frontmatter,
+		content: lines.slice(closingIndex + 1).join("\n"),
+		data: parseFrontmatter(frontmatter, openingType),
+		frontmatterType: openingType
+	};
 }
 
 //#endregion
-//#region src/wc/locale-detect.ts
-const DEFAULT_LOCALE = "und-Latn";
-const DEFAULT_HAN_TAG = "zh-Hani";
-const regex = {
-	hiragana: /\p{Script=Hiragana}/u,
-	katakana: /\p{Script=Katakana}/u,
-	hangul: /\p{Script=Hangul}/u,
-	han: /\p{Script=Han}/u,
-	latin: /\p{Script=Latin}/u,
-	arabic: /\p{Script=Arabic}/u,
-	cyrillic: /\p{Script=Cyrillic}/u,
-	devanagari: /\p{Script=Devanagari}/u,
-	thai: /\p{Script=Thai}/u
-};
-const latinLocaleHints = [
-	{
-		locale: "de",
-		regex: /[äöüÄÖÜß]/
-	},
-	{
-		locale: "es",
-		regex: /[ñÑ¿¡]/
-	},
-	{
-		locale: "pt",
-		regex: /[ãõÃÕ]/
-	},
-	{
-		locale: "fr",
-		regex: /[œŒæÆ]/
-	}
-];
-const latinLocales = new Set([DEFAULT_LOCALE, ...latinLocaleHints.map((hint) => hint.locale)]);
-function isLatinLocale(locale) {
-	return latinLocales.has(locale);
+//#region src/wc/segmenter.ts
+const segmenterCache = /* @__PURE__ */ new Map();
+const graphemeSegmenterCache = /* @__PURE__ */ new Map();
+function getSegmenter(locale) {
+	const cached = segmenterCache.get(locale);
+	if (cached) return cached;
+	const segmenter = new Intl.Segmenter(locale, { granularity: "word" });
+	segmenterCache.set(locale, segmenter);
+	return segmenter;
 }
-function detectLatinLocale(char) {
-	for (const hint of latinLocaleHints) if (hint.regex.test(char)) return hint.locale;
-	return DEFAULT_LOCALE;
+function getGraphemeSegmenter(locale) {
+	const cached = graphemeSegmenterCache.get(locale);
+	if (cached) return cached;
+	const segmenter = new Intl.Segmenter(locale, { granularity: "grapheme" });
+	graphemeSegmenterCache.set(locale, segmenter);
+	return segmenter;
 }
-function resolveLatinHint(options) {
-	const latinTagHint = options.latinTagHint?.trim();
-	if (latinTagHint) return latinTagHint;
-	const latinLanguageHint = options.latinLanguageHint?.trim();
-	if (latinLanguageHint) return latinLanguageHint;
-	const latinLocaleHint = options.latinLocaleHint?.trim();
-	if (latinLocaleHint) return latinLocaleHint;
+function supportsSegmenter() {
+	return typeof Intl !== "undefined" && typeof Intl.Segmenter === "function";
+}
+function countCharsForLocale(text, locale) {
+	if (!supportsSegmenter()) return Array.from(text).length;
+	const segmenter = getGraphemeSegmenter(locale);
+	let count = 0;
+	for (const _segment of segmenter.segment(text)) count++;
+	return count;
 }
-function resolveHanHint(options) {
-	const hanTagHint = options.hanTagHint?.trim();
-	if (hanTagHint) return hanTagHint;
-	const hanLanguageHint = options.hanLanguageHint?.trim();
-	if (hanLanguageHint) return hanLanguageHint;
+
+//#endregion
+//#region src/wc/non-words.ts
+const emojiRegex = /(?:\p{Extended_Pictographic}|\p{Emoji_Presentation})/u;
+const emojiPresentationRegex = /\p{Emoji_Presentation}/u;
+const keycapEmojiRegex = /[0-9#*]\uFE0F?\u20E3/u;
+const symbolRegex = /\p{S}/u;
+const punctuationRegex = /\p{P}/u;
+const whitespaceRegex = /\s/u;
+const newlineChars = new Set([
+	"\n",
+	"\r",
+	"\u2028",
+	"\u2029"
+]);
+function createNonWordCollection() {
+	return {
+		emoji: [],
+		symbols: [],
+		punctuation: [],
+		counts: {
+			emoji: 0,
+			symbols: 0,
+			punctuation: 0
+		}
+	};
 }
-function detectLocaleForChar(char, previousLocale, options = {}) {
-	if (regex.hiragana.test(char) || regex.katakana.test(char)) return "ja";
-	if (regex.hangul.test(char)) return "ko";
-	if (regex.arabic.test(char)) return "ar";
-	if (regex.cyrillic.test(char)) return "ru";
-	if (regex.devanagari.test(char)) return "hi";
-	if (regex.thai.test(char)) return "th";
-	if (regex.han.test(char)) {
-		if (previousLocale && previousLocale.startsWith("ja")) return previousLocale;
-		return resolveHanHint(options) ?? DEFAULT_HAN_TAG;
+function addNonWord(collection, category, segment) {
+	if (category === "emoji") {
+		collection.emoji.push(segment);
+		collection.counts.emoji += 1;
+		return;
 	}
-	if (regex.latin.test(char)) {
-		const hintedLocale = detectLatinLocale(char);
-		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
-		if (previousLocale && isLatinLocale(previousLocale) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
-		const latinHint = resolveLatinHint(options);
-		if (latinHint) return latinHint;
-		return DEFAULT_LOCALE;
+	if (category === "symbol") {
+		collection.symbols.push(segment);
+		collection.counts.symbols += 1;
+		return;
 	}
-	return null;
+	collection.punctuation.push(segment);
+	collection.counts.punctuation += 1;
 }
-
-//#endregion
-//#region src/wc/segment.ts
-function segmentTextByLocale(text, options = {}) {
-	const chunks = [];
-	let currentLocale = DEFAULT_LOCALE;
-	let buffer = "";
-	let bufferHasScript = false;
-	for (const char of text) {
-		const detected = detectLocaleForChar(char, currentLocale, options);
-		const targetLocale = detected ?? currentLocale;
-		if (buffer === "") {
-			currentLocale = targetLocale;
-			buffer = char;
-			bufferHasScript = detected !== null;
+function addWhitespace(collection, segment) {
+	let whitespace = collection.whitespace;
+	let count = 0;
+	for (const char of segment) {
+		if (char === " ") {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.spaces += 1;
+			count += 1;
 			continue;
 		}
-		if (detected !== null && !bufferHasScript) {
-			currentLocale = targetLocale;
-			buffer += char;
-			bufferHasScript = true;
+		if (char === "	") {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.tabs += 1;
+			count += 1;
 			continue;
 		}
-		if (targetLocale !== currentLocale && detected !== null) {
-			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale)) {
-				currentLocale = targetLocale;
-				buffer += char;
-				bufferHasScript = true;
-				continue;
-			}
-			chunks.push({
-				locale: currentLocale,
-				text: buffer
-			});
-			currentLocale = targetLocale;
-			buffer = char;
-			bufferHasScript = true;
+		if (newlineChars.has(char)) {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.newlines += 1;
+			count += 1;
 			continue;
 		}
-		buffer += char;
-		if (detected !== null) bufferHasScript = true;
+		if (whitespaceRegex.test(char)) {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.other += 1;
+			count += 1;
+		}
 	}
-	if (buffer.length > 0) chunks.push({
-		locale: currentLocale,
-		text: buffer
-	});
-	return mergeAdjacentChunks(chunks);
+	if (count > 0) {
+		collection.whitespace = whitespace ?? createWhitespaceCounts();
+		collection.counts.whitespace = (collection.counts.whitespace ?? 0) + count;
+	}
+	return count;
 }
-function mergeAdjacentChunks(chunks) {
-	if (chunks.length === 0) return chunks;
-	const merged = [];
-	let last = chunks[0];
-	for (let i = 1; i < chunks.length; i++) {
-		const chunk = chunks[i];
-		if (chunk.locale === last.locale) last = {
-			locale: last.locale,
-			text: last.text + chunk.text
-		};
-		else {
-			merged.push(last);
-			last = chunk;
-		}
+function classifyNonWordSegment(segment) {
+	const hasEmojiVariationSelector = segment.includes("️");
+	if (keycapEmojiRegex.test(segment) || emojiPresentationRegex.test(segment) || hasEmojiVariationSelector && emojiRegex.test(segment)) return "emoji";
+	if (symbolRegex.test(segment)) return "symbol";
+	if (punctuationRegex.test(segment)) return "punctuation";
+	return null;
+}
+function mergeNonWordCollections(target, source) {
+	if (source.counts.emoji > 0) {
+		appendAll(target.emoji, source.emoji);
+		target.counts.emoji += source.counts.emoji;
 	}
-	merged.push(last);
-	return merged;
+	if (source.counts.symbols > 0) {
+		appendAll(target.symbols, source.symbols);
+		target.counts.symbols += source.counts.symbols;
+	}
+	if (source.counts.punctuation > 0) {
+		appendAll(target.punctuation, source.punctuation);
+		target.counts.punctuation += source.counts.punctuation;
+	}
+	if (source.counts.whitespace && source.counts.whitespace > 0 && source.whitespace) {
+		const whitespace = target.whitespace ?? createWhitespaceCounts();
+		whitespace.spaces += source.whitespace.spaces;
+		whitespace.tabs += source.whitespace.tabs;
+		whitespace.newlines += source.whitespace.newlines;
+		whitespace.other += source.whitespace.other;
+		target.whitespace = whitespace;
+		target.counts.whitespace = (target.counts.whitespace ?? 0) + source.counts.whitespace;
+	}
+	return target;
+}
+function createWhitespaceCounts() {
+	return {
+		spaces: 0,
+		tabs: 0,
+		newlines: 0,
+		other: 0
+	};
 }
 
 //#endregion
-//#region src/wc/wc.ts
-function wordCounter(text, options = {}) {
-	const mode = resolveMode(options.mode, "chunk");
-	const collectNonWords = Boolean(options.nonWords);
-	const includeWhitespace = Boolean(options.includeWhitespace);
-	const chunks = segmentTextByLocale(text, {
-		latinLanguageHint: options.latinLanguageHint,
-		latinTagHint: options.latinTagHint,
-		latinLocaleHint: options.latinLocaleHint,
-		hanLanguageHint: options.hanLanguageHint,
-		hanTagHint: options.hanTagHint
-	});
-	if (mode === "char") {
-		const analyzed = chunks.map((chunk) => analyzeCharChunk(chunk, collectNonWords, includeWhitespace));
-		const total = analyzed.reduce((sum, chunk) => sum + chunk.chars, 0);
-		const items = analyzed.map((chunk) => ({
-			locale: chunk.locale,
-			text: chunk.text,
-			chars: chunk.chars,
-			nonWords: chunk.nonWords
-		}));
-		return {
-			total,
-			counts: collectNonWords ? {
-				words: analyzed.reduce((sum, chunk) => sum + chunk.wordChars, 0),
-				nonWords: analyzed.reduce((sum, chunk) => sum + chunk.nonWordChars, 0),
-				total
-			} : void 0,
-			breakdown: {
-				mode,
-				items
-			}
-		};
+//#region src/wc/analyze.ts
+function analyzeChunk(chunk, collectNonWords, includeWhitespace) {
+	const segmenter = getSegmenter(chunk.locale);
+	const segments = [];
+	const nonWords = collectNonWords ? createNonWordCollection() : null;
+	for (const part of segmenter.segment(chunk.text)) if (part.isWordLike) segments.push(part.segment);
+	else if (collectNonWords && nonWords) {
+		if (includeWhitespace) addWhitespace(nonWords, part.segment);
+		const category = classifyNonWordSegment(part.segment);
+		if (category) addNonWord(nonWords, category, part.segment);
 	}
-	const analyzed = chunks.map((chunk) => analyzeChunk(chunk, collectNonWords, includeWhitespace));
-	const wordsTotal = analyzed.reduce((sum, chunk) => sum + chunk.words, 0);
-	const nonWordsTotal = collectNonWords ? analyzed.reduce((sum, chunk) => {
-		if (!chunk.nonWords) return sum;
-		return sum + getNonWordTotal(chunk.nonWords);
-	}, 0) : 0;
-	const total = analyzed.reduce((sum, chunk) => {
-		let chunkTotal = chunk.words;
-		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal(chunk.nonWords);
-		return sum + chunkTotal;
-	}, 0);
-	const counts = collectNonWords ? {
-		words: wordsTotal,
-		nonWords: nonWordsTotal,
-		total
-	} : void 0;
-	if (mode === "segments") return {
-		total,
-		counts,
-		breakdown: {
-			mode,
-			items: analyzed.map((chunk) => ({
-				locale: chunk.locale,
-				text: chunk.text,
-				words: chunk.words,
-				segments: chunk.segments,
-				nonWords: chunk.nonWords
-			}))
+	return {
+		locale: chunk.locale,
+		text: chunk.text,
+		segments,
+		words: segments.length,
+		nonWords: nonWords ?? void 0
+	};
+}
+function analyzeCharChunk(chunk, collectNonWords, includeWhitespace) {
+	const segmenter = getSegmenter(chunk.locale);
+	const nonWords = collectNonWords ? createNonWordCollection() : null;
+	let chars = 0;
+	let wordChars = 0;
+	let nonWordChars = 0;
+	for (const part of segmenter.segment(chunk.text)) {
+		if (part.isWordLike) {
+			const count = countCharsForLocale(part.segment, chunk.locale);
+			chars += count;
+			wordChars += count;
+			continue;
 		}
-	};
-	if (mode === "collector") return {
-		total,
-		counts,
-		breakdown: {
-			mode,
-			items: aggregateByLocale(analyzed),
-			nonWords: collectNonWordsAggregate(analyzed, collectNonWords)
+		if (collectNonWords && nonWords) {
+			let whitespaceCount = 0;
+			if (includeWhitespace) whitespaceCount = addWhitespace(nonWords, part.segment);
+			const category = classifyNonWordSegment(part.segment);
+			if (category) addNonWord(nonWords, category, part.segment);
+			if (category || whitespaceCount > 0) {
+				const count = countCharsForLocale(part.segment, chunk.locale);
+				chars += count;
+				nonWordChars += count;
+			}
 		}
-	};
+	}
 	return {
-		total,
-		counts,
-		breakdown: {
-			mode,
-			items: analyzed.map((chunk) => ({
-				locale: chunk.locale,
-				text: chunk.text,
-				words: chunk.words,
-				nonWords: chunk.nonWords
-			}))
-		}
+		locale: chunk.locale,
+		text: chunk.text,
+		chars,
+		wordChars,
+		nonWordChars,
+		nonWords: nonWords ?? void 0
 	};
 }
-function getNonWordTotal(nonWords) {
-	return nonWords.counts.emoji + nonWords.counts.symbols + nonWords.counts.punctuation + (nonWords.counts.whitespace ?? 0);
+function aggregateCharsByLocale(chunks) {
+	const order = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const existing = map.get(chunk.locale);
+		if (existing) {
+			existing.chars += chunk.chars;
+			existing.wordChars += chunk.wordChars;
+			existing.nonWordChars += chunk.nonWordChars;
+			if (chunk.nonWords) {
+				if (!existing.nonWords) existing.nonWords = createNonWordCollection();
+				mergeNonWordCollections(existing.nonWords, chunk.nonWords);
+			}
+			continue;
+		}
+		order.push(chunk.locale);
+		map.set(chunk.locale, {
+			locale: chunk.locale,
+			chars: chunk.chars,
+			wordChars: chunk.wordChars,
+			nonWordChars: chunk.nonWordChars,
+			nonWords: chunk.nonWords ? mergeNonWordCollections(createNonWordCollection(), chunk.nonWords) : void 0
+		});
+	}
+	return order.map((locale) => map.get(locale));
 }
-function collectNonWordsAggregate(analyzed, enabled) {
-	if (!enabled) return;
-	const collection = createNonWordCollection();
-	for (const chunk of analyzed) {
-		if (!chunk.nonWords) continue;
-		mergeNonWordCollections(collection, chunk.nonWords);
+function aggregateByLocale(chunks) {
+	const order = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const existing = map.get(chunk.locale);
+		if (existing) {
+			existing.words += chunk.words;
+			appendAll(existing.segments, chunk.segments);
+			continue;
+		}
+		order.push(chunk.locale);
+		map.set(chunk.locale, {
+			locale: chunk.locale,
+			words: chunk.words,
+			segments: [...chunk.segments]
+		});
 	}
-	return collection;
+	return order.map((locale) => map.get(locale));
 }
 
 //#endregion
-//#region src/wc/index.ts
-var wc_default = wordCounter;
-
-//#endregion
-//#region src/markdown/section-count.ts
-function normalizeText(value) {
-	if (value == null) return "";
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
+//#region src/wc/mode.ts
+const MODE_ALIASES = {
+	chunk: "chunk",
+	chunks: "chunk",
+	segments: "segments",
+	segment: "segments",
+	seg: "segments",
+	collector: "collector",
+	collect: "collector",
+	colle: "collector",
+	char: "char",
+	chars: "char",
+	character: "char",
+	characters: "char",
+	"char-collector": "char-collector"
+};
+const CHAR_MODE_ALIASES = new Set([
+	"char",
+	"chars",
+	"character",
+	"characters"
+]);
+const COLLECTOR_MODE_ALIASES = new Set([
+	"collector",
+	"collect",
+	"colle",
+	"col"
+]);
+function collapseSeparators(value) {
+	return value.replace(/[-_\s]+/g, "");
+}
+function isComposedCharCollectorFromTokens(value) {
+	const tokens = value.split(/[-_\s]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+	if (tokens.length < 2) return false;
+	let hasCharAlias = false;
+	let hasCollectorAlias = false;
+	for (const token of tokens) {
+		if (CHAR_MODE_ALIASES.has(token)) {
+			hasCharAlias = true;
+			continue;
+		}
+		if (COLLECTOR_MODE_ALIASES.has(token)) {
+			hasCollectorAlias = true;
+			continue;
+		}
+		return false;
 	}
+	return hasCharAlias && hasCollectorAlias;
 }
-function buildPerKeyItems(data, mode, options) {
-	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
-	return Object.entries(data).map(([key, value]) => {
-		const valueText = normalizeText(value);
-		return {
-			name: key,
-			source: "frontmatter",
-			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
-		};
-	});
-}
-function buildSingleItem(name, text, mode, options, source) {
-	return [{
-		name,
-		source,
-		result: wc_default(text, options)
-	}];
+function isComposedCharCollectorCompact(value) {
+	for (const charAlias of CHAR_MODE_ALIASES) for (const collectorAlias of COLLECTOR_MODE_ALIASES) if (value === `${charAlias}${collectorAlias}` || value === `${collectorAlias}${charAlias}`) return true;
+	return false;
 }
-function sumTotals(items) {
-	return items.reduce((sum, item) => sum + item.result.total, 0);
+function normalizeMode(input) {
+	if (!input) return null;
+	const normalized = input.trim().toLowerCase();
+	const direct = MODE_ALIASES[normalized];
+	if (direct) return direct;
+	if (isComposedCharCollectorFromTokens(normalized)) return "char-collector";
+	const compact = collapseSeparators(normalized);
+	if (isComposedCharCollectorCompact(compact)) return "char-collector";
+	return MODE_ALIASES[compact] ?? null;
 }
-function countSections(input, section, options = {}) {
-	const mode = options.mode ?? "chunk";
-	if (section === "all") {
-		const result = wc_default(input, options);
-		return {
-			section,
-			total: result.total,
-			frontmatterType: null,
-			items: [{
-				name: "all",
-				source: "content",
-				result
-			}]
-		};
-	}
-	const parsed = parseMarkdown(input);
-	const frontmatterText = parsed.frontmatter ?? "";
-	const contentText = parsed.content ?? "";
-	let items = [];
-	if (section === "frontmatter") items = buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter");
-	else if (section === "content") items = buildSingleItem("content", contentText, mode, options, "content");
-	else if (section === "split") items = [...buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter"), ...buildSingleItem("content", contentText, mode, options, "content")];
-	else if (section === "per-key") items = buildPerKeyItems(parsed.data, mode, options);
-	else if (section === "split-per-key") items = [...buildPerKeyItems(parsed.data, mode, options), ...buildSingleItem("content", contentText, mode, options, "content")];
-	return {
-		section,
-		total: sumTotals(items),
-		frontmatterType: parsed.frontmatterType,
-		items
-	};
+function resolveMode(input, fallback = "chunk") {
+	return normalizeMode(input) ?? fallback;
 }
 
 //#endregion
-//#region src/cli/path/filter.ts
-const DEFAULT_INCLUDE_EXTENSIONS = new Set([
-	".md",
-	".markdown",
-	".mdx",
-	".mdc",
-	".txt"
-]);
-function collectExtensionOption(value, previous = []) {
-	return [...previous, value];
+//#region src/wc/locale-detect.ts
+const DEFAULT_LOCALE = "und-Latn";
+const DEFAULT_HAN_TAG = "zh-Hani";
+const regex = {
+	hiragana: /\p{Script=Hiragana}/u,
+	katakana: /\p{Script=Katakana}/u,
+	hangul: /\p{Script=Hangul}/u,
+	han: /\p{Script=Han}/u,
+	latin: /\p{Script=Latin}/u,
+	arabic: /\p{Script=Arabic}/u,
+	cyrillic: /\p{Script=Cyrillic}/u,
+	devanagari: /\p{Script=Devanagari}/u,
+	thai: /\p{Script=Thai}/u
+};
+const latinLocaleHints = [
+	{
+		locale: "de",
+		regex: /[äöüÄÖÜß]/
+	},
+	{
+		locale: "es",
+		regex: /[ñÑ¿¡]/
+	},
+	{
+		locale: "pt",
+		regex: /[ãõÃÕ]/
+	},
+	{
+		locale: "fr",
+		regex: /[œŒæÆ]/
+	}
+];
+const latinLocales = new Set([DEFAULT_LOCALE, ...latinLocaleHints.map((hint) => hint.locale)]);
+function isLatinLocale(locale) {
+	return latinLocales.has(locale);
 }
-function normalizeExtensionToken(value) {
-	const trimmed = value.trim().toLowerCase();
-	if (!trimmed) return null;
-	const normalized = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
-	if (normalized === ".") return null;
-	return normalized;
+function detectLatinLocale(char) {
+	for (const hint of latinLocaleHints) if (hint.regex.test(char)) return hint.locale;
+	return DEFAULT_LOCALE;
 }
-function parseExtensionValues(values) {
-	const parsed = /* @__PURE__ */ new Set();
-	if (!values || values.length === 0) return parsed;
-	for (const value of values) for (const token of value.split(",")) {
-		const normalized = normalizeExtensionToken(token);
-		if (!normalized) continue;
-		parsed.add(normalized);
+function resolveLatinHint(options) {
+	const latinTagHint = options.latinTagHint?.trim();
+	if (latinTagHint) return latinTagHint;
+	const latinLanguageHint = options.latinLanguageHint?.trim();
+	if (latinLanguageHint) return latinLanguageHint;
+	const latinLocaleHint = options.latinLocaleHint?.trim();
+	if (latinLocaleHint) return latinLocaleHint;
+}
+function resolveHanHint(options) {
+	const hanTagHint = options.hanTagHint?.trim();
+	if (hanTagHint) return hanTagHint;
+	const hanLanguageHint = options.hanLanguageHint?.trim();
+	if (hanLanguageHint) return hanLanguageHint;
+}
+function detectLocaleForChar(char, previousLocale, options = {}) {
+	if (regex.hiragana.test(char) || regex.katakana.test(char)) return "ja";
+	if (regex.hangul.test(char)) return "ko";
+	if (regex.arabic.test(char)) return "ar";
+	if (regex.cyrillic.test(char)) return "ru";
+	if (regex.devanagari.test(char)) return "hi";
+	if (regex.thai.test(char)) return "th";
+	if (regex.han.test(char)) {
+		if (previousLocale && previousLocale.startsWith("ja")) return previousLocale;
+		return resolveHanHint(options) ?? DEFAULT_HAN_TAG;
 	}
-	return parsed;
-}
-function buildDirectoryExtensionFilter(includeValues, excludeValues) {
-	const includeFromFlags = parseExtensionValues(includeValues);
-	const excludeExtensions = parseExtensionValues(excludeValues);
-	const includeExtensions = includeFromFlags.size > 0 ? includeFromFlags : new Set(DEFAULT_INCLUDE_EXTENSIONS);
-	const effectiveIncludeExtensions = /* @__PURE__ */ new Set();
-	for (const extension of includeExtensions) {
-		if (excludeExtensions.has(extension)) continue;
-		effectiveIncludeExtensions.add(extension);
+	if (regex.latin.test(char)) {
+		const hintedLocale = detectLatinLocale(char);
+		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
+		if (previousLocale && isLatinLocale(previousLocale) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
+		const latinHint = resolveLatinHint(options);
+		if (latinHint) return latinHint;
+		return DEFAULT_LOCALE;
 	}
-	return {
-		includeExtensions,
-		excludeExtensions,
-		effectiveIncludeExtensions
-	};
-}
-function shouldIncludeFromDirectory(filePath, filter) {
-	const extension = extname(filePath).toLowerCase();
-	return filter.effectiveIncludeExtensions.has(extension);
+	return null;
 }
 
 //#endregion
-//#region src/cli/path/load.ts
-function isProbablyBinary(buffer) {
-	if (buffer.length === 0) return false;
-	const sampleSize = Math.min(buffer.length, 1024);
-	let suspicious = 0;
-	for (let index = 0; index < sampleSize; index += 1) {
-		const byte = buffer[index] ?? 0;
-		if (byte === 0) return true;
-		if (byte === 9 || byte === 10 || byte === 13) continue;
-		if (byte >= 32 && byte <= 126) continue;
-		if (byte >= 128) continue;
-		suspicious += 1;
-	}
-	return suspicious / sampleSize > .3;
-}
-async function loadBatchInputs(filePaths) {
-	const files = [];
-	const skipped = [];
-	for (const filePath of filePaths) {
-		let buffer;
-		try {
-			buffer = await readFile(filePath);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			skipped.push({
-				path: filePath,
-				reason: `not readable: ${message}`
-			});
+//#region src/wc/segment.ts
+function segmentTextByLocale(text, options = {}) {
+	const chunks = [];
+	let currentLocale = DEFAULT_LOCALE;
+	let buffer = "";
+	let bufferHasScript = false;
+	for (const char of text) {
+		const detected = detectLocaleForChar(char, currentLocale, options);
+		const targetLocale = detected ?? currentLocale;
+		if (buffer === "") {
+			currentLocale = targetLocale;
+			buffer = char;
+			bufferHasScript = detected !== null;
 			continue;
 		}
-		if (isProbablyBinary(buffer)) {
-			skipped.push({
-				path: filePath,
-				reason: "binary file"
-			});
+		if (detected !== null && !bufferHasScript) {
+			currentLocale = targetLocale;
+			buffer += char;
+			bufferHasScript = true;
 			continue;
 		}
-		files.push({
-			path: filePath,
-			content: buffer.toString("utf8")
-		});
-	}
-	return {
-		files,
-		skipped
-	};
-}
-
-//#endregion
-//#region src/cli/path/resolve.ts
-async function expandDirectory(directoryPath, recursive, filter, skipped, debug, stats) {
-	let entries;
-	try {
-		entries = await readdir(directoryPath, {
-			withFileTypes: true,
-			encoding: "utf8"
-		});
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		skipped.push({
-			path: directoryPath,
-			reason: `directory read failed: ${message}`
-		});
-		debug.emit("path.resolve.expand.read_failed", {
-			directory: directoryPath,
-			reason: `directory read failed: ${message}`
-		});
-		return [];
-	}
-	const sortedEntries = entries.slice().sort((left, right) => left.name.localeCompare(right.name));
-	const files = [];
-	debug.emit("path.resolve.expand.start", {
-		directory: directoryPath,
-		entries: sortedEntries.length,
-		recursive
-	});
-	for (const entry of sortedEntries) {
-		const entryPath = resolve(directoryPath, entry.name);
-		if (entry.isFile()) {
-			if (!shouldIncludeFromDirectory(entryPath, filter)) {
-				skipped.push({
-					path: entryPath,
-					reason: "extension excluded"
-				});
-				debug.emit("path.resolve.filter.excluded", {
-					path: entryPath,
-					reason: "extension excluded"
-				}, { verbosity: "verbose" });
-				stats.filterExcluded += 1;
+		if (targetLocale !== currentLocale && detected !== null) {
+			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale)) {
+				currentLocale = targetLocale;
+				buffer += char;
+				bufferHasScript = true;
 				continue;
 			}
-			files.push(entryPath);
-			stats.directoryIncluded += 1;
-			debug.emit("path.resolve.expand.include", {
-				path: entryPath,
-				source: "directory"
-			}, { verbosity: "verbose" });
+			chunks.push({
+				locale: currentLocale,
+				text: buffer
+			});
+			currentLocale = targetLocale;
+			buffer = char;
+			bufferHasScript = true;
 			continue;
 		}
-		if (!entry.isDirectory() || !recursive) continue;
-		appendAll(files, await expandDirectory(entryPath, recursive, filter, skipped, debug, stats));
+		buffer += char;
+		if (detected !== null) bufferHasScript = true;
 	}
-	debug.emit("path.resolve.expand.complete", {
-		directory: directoryPath,
-		files: files.length
+	if (buffer.length > 0) chunks.push({
+		locale: currentLocale,
+		text: buffer
 	});
-	return files;
+	return mergeAdjacentChunks(chunks);
 }
-async function resolveBatchFilePaths(pathInputs, options) {
-	const skipped = [];
-	const resolvedFiles = /* @__PURE__ */ new Set();
-	const stats = {
-		dedupeAccepted: 0,
-		dedupeDuplicates: 0,
-		filterExcluded: 0,
-		directoryIncluded: 0
-	};
-	const extensionFilter = options.extensionFilter ?? buildDirectoryExtensionFilter(void 0, void 0);
-	const debug = options.debug ?? {
-		enabled: false,
-		verbosity: "compact",
-		emit() {},
-		close: async () => {}
-	};
-	debug.emit("path.resolve.inputs", {
-		inputs: pathInputs.length,
-		pathMode: options.pathMode,
-		recursive: options.recursive
+function mergeAdjacentChunks(chunks) {
+	if (chunks.length === 0) return chunks;
+	const merged = [];
+	let last = chunks[0];
+	for (let i = 1; i < chunks.length; i++) {
+		const chunk = chunks[i];
+		if (chunk.locale === last.locale) last = {
+			locale: last.locale,
+			text: last.text + chunk.text
+		};
+		else {
+			merged.push(last);
+			last = chunk;
+		}
+	}
+	merged.push(last);
+	return merged;
+}
+
+//#endregion
+//#region src/wc/wc.ts
+function wordCounter(text, options = {}) {
+	const mode = resolveMode(options.mode, "chunk");
+	const collectNonWords = Boolean(options.nonWords);
+	const includeWhitespace = Boolean(options.includeWhitespace);
+	const chunks = segmentTextByLocale(text, {
+		latinLanguageHint: options.latinLanguageHint,
+		latinTagHint: options.latinTagHint,
+		latinLocaleHint: options.latinLocaleHint,
+		hanLanguageHint: options.hanLanguageHint,
+		hanTagHint: options.hanTagHint
 	});
-	const addResolvedFile = (filePath, details) => {
-		if (resolvedFiles.has(filePath)) {
-			stats.dedupeDuplicates += 1;
-			debug.emit("path.resolve.dedupe.duplicate", {
-				path: filePath,
-				source: details.source,
-				input: details.input
-			}, { verbosity: "verbose" });
-			return;
+	if (mode === "char" || mode === "char-collector") {
+		const analyzed = chunks.map((chunk) => analyzeCharChunk(chunk, collectNonWords, includeWhitespace));
+		const total = analyzed.reduce((sum, chunk) => sum + chunk.chars, 0);
+		const counts = collectNonWords ? {
+			words: analyzed.reduce((sum, chunk) => sum + chunk.wordChars, 0),
+			nonWords: analyzed.reduce((sum, chunk) => sum + chunk.nonWordChars, 0),
+			total
+		} : void 0;
+		if (mode === "char") return {
+			total,
+			counts,
+			breakdown: {
+				mode,
+				items: analyzed.map((chunk) => ({
+					locale: chunk.locale,
+					text: chunk.text,
+					chars: chunk.chars,
+					nonWords: chunk.nonWords
+				}))
+			}
+		};
+		return {
+			total,
+			counts,
+			breakdown: {
+				mode,
+				items: aggregateCharsByLocale(analyzed).map((chunk) => ({
+					locale: chunk.locale,
+					chars: chunk.chars,
+					nonWords: chunk.nonWords
+				}))
+			}
+		};
+	}
+	const analyzed = chunks.map((chunk) => analyzeChunk(chunk, collectNonWords, includeWhitespace));
+	const wordsTotal = analyzed.reduce((sum, chunk) => sum + chunk.words, 0);
+	const nonWordsTotal = collectNonWords ? analyzed.reduce((sum, chunk) => {
+		if (!chunk.nonWords) return sum;
+		return sum + getNonWordTotal(chunk.nonWords);
+	}, 0) : 0;
+	const total = analyzed.reduce((sum, chunk) => {
+		let chunkTotal = chunk.words;
+		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal(chunk.nonWords);
+		return sum + chunkTotal;
+	}, 0);
+	const counts = collectNonWords ? {
+		words: wordsTotal,
+		nonWords: nonWordsTotal,
+		total
+	} : void 0;
+	if (mode === "segments") return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words,
+				segments: chunk.segments,
+				nonWords: chunk.nonWords
+			}))
 		}
-		resolvedFiles.add(filePath);
-		stats.dedupeAccepted += 1;
-		debug.emit("path.resolve.dedupe.accept", {
-			path: filePath,
-			source: details.source,
-			input: details.input
-		}, { verbosity: "verbose" });
 	};
-	for (const rawPath of pathInputs) {
-		const targetPath = resolve(rawPath);
-		debug.emit("path.resolve.input", {
-			rawPath,
-			resolvedPath: targetPath
-		});
-		let metadata;
-		try {
-			metadata = await stat(targetPath);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			skipped.push({
-				path: targetPath,
-				reason: `not readable: ${message}`
-			});
-			debug.emit("path.resolve.skip", {
-				path: targetPath,
-				reason: `not readable: ${message}`
-			});
-			continue;
-		}
-		if (metadata.isDirectory() && options.pathMode === "auto") {
-			debug.emit("path.resolve.root.expand", {
-				root: targetPath,
-				recursive: options.recursive
-			});
-			const files = await expandDirectory(targetPath, options.recursive, extensionFilter, skipped, debug, stats);
-			for (const file of files) addResolvedFile(file, {
-				source: "directory",
-				input: targetPath
-			});
-			continue;
-		}
-		if (!metadata.isFile()) {
-			skipped.push({
-				path: targetPath,
-				reason: "not a regular file"
-			});
-			debug.emit("path.resolve.skip", {
-				path: targetPath,
-				reason: "not a regular file"
-			});
-			continue;
+	if (mode === "collector") return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: aggregateByLocale(analyzed),
+			nonWords: collectNonWordsAggregate(analyzed, collectNonWords)
 		}
-		addResolvedFile(targetPath, {
-			source: "direct",
-			input: targetPath
-		});
-	}
-	const files = [...resolvedFiles].sort((left, right) => left.localeCompare(right));
-	debug.emit("path.resolve.filter.summary", {
-		excluded: stats.filterExcluded,
-		included: stats.directoryIncluded
-	});
-	debug.emit("path.resolve.dedupe.summary", {
-		accepted: stats.dedupeAccepted,
-		duplicates: stats.dedupeDuplicates
-	});
-	debug.emit("path.resolve.complete", {
-		files: files.length,
-		skipped: skipped.length,
-		ordering: "absolute-path-ascending"
-	});
+	};
 	return {
-		files,
-		skipped
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words,
+				nonWords: chunk.nonWords
+			}))
+		}
 	};
 }
+function getNonWordTotal(nonWords) {
+	return nonWords.counts.emoji + nonWords.counts.symbols + nonWords.counts.punctuation + (nonWords.counts.whitespace ?? 0);
+}
+function collectNonWordsAggregate(analyzed, enabled) {
+	if (!enabled) return;
+	const collection = createNonWordCollection();
+	for (const chunk of analyzed) {
+		if (!chunk.nonWords) continue;
+		mergeNonWordCollections(collection, chunk.nonWords);
+	}
+	return collection;
+}
 
 //#endregion
-//#region src/cli/progress/reporter.ts
-const PROGRESS_BAR_WIDTH = 20;
-const FILLED_BAR_CHAR = "█";
-const EMPTY_BAR_CHAR = "░";
-function clamp(value, min, max) {
-	return Math.max(min, Math.min(max, value));
-}
-function buildProgressBar(completed, total) {
-	const safeTotal = Math.max(total, 1);
-	const ratio = clamp(completed / safeTotal, 0, 1);
-	const filled = completed >= safeTotal ? PROGRESS_BAR_WIDTH : Math.floor(ratio * PROGRESS_BAR_WIDTH);
-	const empty = PROGRESS_BAR_WIDTH - filled;
-	return `${FILLED_BAR_CHAR.repeat(filled)}${EMPTY_BAR_CHAR.repeat(empty)}`;
+//#region src/wc/index.ts
+var wc_default = wordCounter;
+
+//#endregion
+//#region src/markdown/section-count.ts
+function normalizeText(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
 }
-function formatElapsed(startedAtMs) {
-	const elapsedMs = Date.now() - startedAtMs;
-	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
-	const minutes = Math.floor(totalSeconds / 60);
-	const seconds = totalSeconds % 60;
-	const tenths = Math.floor(Math.max(0, elapsedMs) % 1e3 / 100);
-	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${tenths}`;
+function buildPerKeyItems(data, mode, options) {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+	return Object.entries(data).map(([key, value]) => {
+		const valueText = normalizeText(value);
+		return {
+			name: key,
+			source: "frontmatter",
+			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
+		};
+	});
 }
-function buildProgressLine(completed, total, startedAtMs) {
-	const safeTotal = Math.max(total, 1);
-	const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
-	return `Counting files [${buildProgressBar(completed, safeTotal)}] ${`${String(percent).padStart(3, " ")}%`} ${String(completed).padStart(String(safeTotal).length, " ")}/${safeTotal} elapsed ${formatElapsed(startedAtMs)}`;
+function buildSingleItem(name, text, mode, options, source) {
+	return [{
+		name,
+		source,
+		result: wc_default(text, options)
+	}];
 }
-function buildFinalizingLine(startedAtMs) {
-	return `Finalizing aggregate... elapsed ${formatElapsed(startedAtMs)}`;
+function sumTotals(items) {
+	return items.reduce((sum, item) => sum + item.result.total, 0);
 }
-function createBatchProgressReporter(options) {
-	const enabled = options.enabled;
-	const isTTY = Boolean(options.stream.isTTY);
-	const clearOnFinish = options.clearOnFinish ?? true;
-	let active = false;
-	let total = 0;
-	let lastLineLength = 0;
-	let startedAtMs = 0;
-	let lastRenderedPercent = -1;
-	let finalizingStarted = false;
-	const writeTTYLine = (line) => {
-		const trailingPadding = lastLineLength > line.length ? " ".repeat(lastLineLength - line.length) : "";
-		options.stream.write(`\r${line}${trailingPadding}`);
-		lastLineLength = line.length;
-	};
-	const render = (completed) => {
-		const line = buildProgressLine(completed, total, startedAtMs);
-		const safeTotal = Math.max(total, 1);
-		const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
-		if (!isTTY && percent === lastRenderedPercent && completed < safeTotal) return;
-		lastRenderedPercent = percent;
-		if (isTTY) {
-			writeTTYLine(line);
-			return;
-		}
-		lastLineLength = line.length;
-		options.stream.write(`${line}\n`);
-	};
-	const clearLine = () => {
-		if (lastLineLength === 0) return;
-		options.stream.write(`\r${" ".repeat(lastLineLength)}\r`);
-		lastLineLength = 0;
-	};
-	return {
-		enabled,
-		start(nextTotal, nextStartedAtMs) {
-			if (!enabled || nextTotal <= 1) return;
-			total = nextTotal;
-			active = true;
-			startedAtMs = nextStartedAtMs ?? Date.now();
-			lastRenderedPercent = -1;
-			finalizingStarted = false;
-			render(0);
-		},
-		advance(snapshot) {
-			if (!active) return;
-			render(snapshot.completed);
-		},
-		startFinalizing() {
-			if (!active || finalizingStarted) return;
-			finalizingStarted = true;
-			const line = buildFinalizingLine(startedAtMs);
-			if (isTTY) {
-				if (!clearOnFinish) {
-					options.stream.write(`\n${line}`);
-					lastLineLength = line.length;
-					return;
-				}
-				writeTTYLine(line);
-				return;
-			}
-			lastLineLength = line.length;
-			options.stream.write(`${line}\n`);
-		},
-		finish() {
-			if (!active) return;
-			if (isTTY) if (clearOnFinish) clearLine();
-			else options.stream.write("\n");
-			active = false;
-		}
+function countSections(input, section, options = {}) {
+	const mode = options.mode ?? "chunk";
+	if (section === "all") {
+		const result = wc_default(input, options);
+		return {
+			section,
+			total: result.total,
+			frontmatterType: null,
+			items: [{
+				name: "all",
+				source: "content",
+				result
+			}]
+		};
+	}
+	const parsed = parseMarkdown(input);
+	const frontmatterText = parsed.frontmatter ?? "";
+	const contentText = parsed.content ?? "";
+	let items = [];
+	if (section === "frontmatter") items = buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter");
+	else if (section === "content") items = buildSingleItem("content", contentText, mode, options, "content");
+	else if (section === "split") items = [...buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter"), ...buildSingleItem("content", contentText, mode, options, "content")];
+	else if (section === "per-key") items = buildPerKeyItems(parsed.data, mode, options);
+	else if (section === "split-per-key") items = [...buildPerKeyItems(parsed.data, mode, options), ...buildSingleItem("content", contentText, mode, options, "content")];
+	return {
+		section,
+		total: sumTotals(items),
+		frontmatterType: parsed.frontmatterType,
+		items
 	};
 }
 
@@ -1458,6 +1886,43 @@ function mergeWordCounterResult(left, right, preserveCollectorSegments) {
 			items: [...left.breakdown.items, ...right.breakdown.items]
 		}
 	};
+	if (left.breakdown.mode === "char-collector" && right.breakdown.mode === "char-collector") {
+		const localeOrder = [];
+		const mergedByLocale = /* @__PURE__ */ new Map();
+		const addItems = (items) => {
+			for (const item of items) {
+				const existing = mergedByLocale.get(item.locale);
+				if (existing) {
+					existing.chars += item.chars;
+					if (item.nonWords) {
+						if (!existing.nonWords) existing.nonWords = createNonWordCollection();
+						mergeNonWordCollections(existing.nonWords, item.nonWords);
+					}
+					continue;
+				}
+				localeOrder.push(item.locale);
+				mergedByLocale.set(item.locale, {
+					locale: item.locale,
+					chars: item.chars,
+					nonWords: item.nonWords ? mergeNonWordCollections(createNonWordCollection(), item.nonWords) : void 0
+				});
+			}
+		};
+		addItems(left.breakdown.items);
+		addItems(right.breakdown.items);
+		return {
+			total,
+			counts,
+			breakdown: {
+				mode: "char-collector",
+				items: localeOrder.map((locale) => {
+					const value = mergedByLocale.get(locale);
+					if (!value) throw new Error(`Missing char-collector entry for locale: ${locale}`);
+					return value;
+				})
+			}
+		};
+	}
 	if (left.breakdown.mode === "collector" && right.breakdown.mode === "collector") {
 		const localeOrder = [];
 		const mergedByLocale = /* @__PURE__ */ new Map();
@@ -1693,302 +2158,28 @@ async function runBatchCount(options) {
 		elapsedMs: finalizeElapsedMs
 	});
 	appendAll(summary.skipped, resolved.skipped);
-	appendAll(summary.skipped, loaded.skipped);
-	options.debug.emit("batch.aggregate.complete", {
-		files: summary.files.length,
-		skipped: summary.skipped.length,
-		total: summary.aggregate.total
-	});
-	return summary;
-}
-
-//#endregion
-//#region src/cli/debug/channel.ts
-const NOOP_CLOSE = async () => {};
-function shouldEmitAtVerbosity(channelVerbosity, eventVerbosity) {
-	return channelVerbosity === "verbose" || eventVerbosity === "compact";
-}
-function formatTimestampPart(value) {
-	return String(value).padStart(2, "0");
-}
-function formatDebugReportTimestamp(now) {
-	return [`${now.getFullYear()}${formatTimestampPart(now.getMonth() + 1)}${formatTimestampPart(now.getDate())}`, `${formatTimestampPart(now.getHours())}${formatTimestampPart(now.getMinutes())}${formatTimestampPart(now.getSeconds())}`].join("-");
-}
-function withCollisionSuffix(pathValue, sequence) {
-	if (sequence <= 0) return pathValue;
-	const extension = extname(pathValue);
-	const baseName = basename(pathValue, extension);
-	return join(dirname(pathValue), `${baseName}-${sequence}${extension}`);
-}
-function resolveReportPath(report, now, pid) {
-	const cwd = report.cwd ?? process.cwd();
-	const defaultName = `wc-debug-${formatDebugReportTimestamp(now)}-${pid}.jsonl`;
-	const explicitPath = typeof report.path === "string";
-	const basePath = explicitPath ? resolve(cwd, report.path) : resolve(cwd, defaultName);
-	mkdirSync(dirname(basePath), { recursive: true });
-	if (explicitPath) {
-		if (existsSync(basePath) && statSync(basePath).isDirectory()) throw new Error(`debug report path must be a file: ${basePath}`);
-		return basePath;
-	}
-	let candidate = basePath;
-	let sequence = 0;
-	while (existsSync(candidate)) {
-		sequence += 1;
-		candidate = withCollisionSuffix(basePath, sequence);
-	}
-	return candidate;
-}
-function createTerminalSink() {
-	return {
-		write(line) {
-			console.error(`[debug] ${line}`);
-		},
-		close: NOOP_CLOSE
-	};
-}
-function createFileSink(pathValue) {
-	try {
-		closeSync(openSync(pathValue, "a"));
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`debug report path is not writable: ${pathValue} (${message})`);
-	}
-	const stream = createWriteStream(pathValue, {
-		flags: "a",
-		encoding: "utf8"
-	});
-	let streamError;
-	stream.on("error", (error) => {
-		streamError = error;
-	});
-	return {
-		write(line) {
-			if (streamError || stream.destroyed) return;
-			stream.write(`${line}\n`);
-		},
-		close() {
-			if (streamError || stream.destroyed || stream.writableEnded) return Promise.resolve();
-			return new Promise((resolve) => {
-				stream.end(() => {
-					resolve();
-				});
-			});
-		}
-	};
-}
-function createDebugChannel(options) {
-	if (!options.enabled) return {
-		enabled: false,
-		verbosity: options.verbosity ?? "compact",
-		emit() {},
-		close: NOOP_CLOSE
-	};
-	const verbosity = options.verbosity ?? "compact";
-	const sinks = [];
-	let reportPath;
-	if (options.report) {
-		const now = options.now?.() ?? /* @__PURE__ */ new Date();
-		const pid = options.pid ?? process.pid;
-		reportPath = resolveReportPath(options.report, now, pid);
-		sinks.push(createFileSink(reportPath));
-		if (options.report.tee) sinks.push(createTerminalSink());
-	} else sinks.push(createTerminalSink());
-	return {
-		enabled: true,
-		verbosity,
-		reportPath,
-		emit(event, details = {}, eventOptions = {}) {
-			if (!shouldEmitAtVerbosity(verbosity, eventOptions.verbosity ?? "compact")) return;
-			const payload = JSON.stringify({
-				event,
-				...details
-			});
-			for (const sink of sinks) sink.write(payload);
-		},
-		async close() {
-			for (const sink of sinks) await sink.close();
-		}
-	};
-}
-
-//#endregion
-//#region src/utils/show-singular-or-plural-word.ts
-function showSingularOrPluralWord(count, word) {
-	return `${count} ${word}${count === 1 ? "" : "s"}`;
-}
-
-//#endregion
-//#region src/cli/total-of.ts
-const TOTAL_OF_PARTS = [
-	"words",
-	"emoji",
-	"symbols",
-	"punctuation",
-	"whitespace"
-];
-const TOTAL_OF_PART_ALIASES = {
-	word: "words",
-	words: "words",
-	emoji: "emoji",
-	emojis: "emoji",
-	symbol: "symbols",
-	symbols: "symbols",
-	punction: "punctuation",
-	punctuation: "punctuation",
-	whitespace: "whitespace"
-};
-function createTotalOfCounts() {
-	return {
-		words: 0,
-		emoji: 0,
-		symbols: 0,
-		punctuation: 0,
-		whitespace: 0
-	};
-}
-function collectNonWordCounts(target, nonWords) {
-	if (!nonWords) return;
-	target.emoji += nonWords.counts.emoji;
-	target.symbols += nonWords.counts.symbols;
-	target.punctuation += nonWords.counts.punctuation;
-	target.whitespace += nonWords.counts.whitespace ?? 0;
-}
-function collectFromWordCounterResult(result) {
-	const counts = createTotalOfCounts();
-	counts.words += result.counts?.words ?? result.total;
-	if (result.breakdown.mode === "collector") {
-		collectNonWordCounts(counts, result.breakdown.nonWords);
-		return counts;
-	}
-	for (const item of result.breakdown.items) collectNonWordCounts(counts, item.nonWords);
-	return counts;
-}
-function collectTotalOfCounts(result) {
-	if (!("section" in result)) return collectFromWordCounterResult(result);
-	const counts = createTotalOfCounts();
-	for (const item of result.items) {
-		const itemCounts = collectFromWordCounterResult(item.result);
-		for (const part of TOTAL_OF_PARTS) counts[part] += itemCounts[part];
-	}
-	return counts;
-}
-function parseTotalOfToken(token) {
-	const canonical = TOTAL_OF_PART_ALIASES[token.trim().toLowerCase()];
-	if (canonical) return canonical;
-	throw new Error(`Invalid --total-of part: ${token}. Allowed: ${TOTAL_OF_PARTS.join(", ")}.`);
-}
-function parseTotalOfOption(value) {
-	const rawTokens = value.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
-	if (rawTokens.length === 0) throw new Error(`Invalid --total-of value: "${value}". Use comma-separated parts from: ${TOTAL_OF_PARTS.join(", ")}.`);
-	const parts = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const token of rawTokens) {
-		const parsed = parseTotalOfToken(token);
-		if (seen.has(parsed)) continue;
-		seen.add(parsed);
-		parts.push(parsed);
-	}
-	return parts;
-}
-function requiresNonWordCollection(parts) {
-	if (!parts || parts.length === 0) return false;
-	return parts.some((part) => part !== "words");
-}
-function requiresWhitespaceCollection(parts) {
-	if (!parts || parts.length === 0) return false;
-	return parts.includes("whitespace");
-}
-function resolveTotalOfOverride(result, parts) {
-	if (!parts || parts.length === 0) return;
-	const counts = collectTotalOfCounts(result);
-	let total = 0;
-	for (const part of parts) total += counts[part];
-	return {
-		parts: [...parts],
-		total
-	};
-}
-function formatTotalOfParts(parts) {
-	return parts.join(", ");
+	appendAll(summary.skipped, loaded.skipped);
+	options.debug.emit("batch.aggregate.complete", {
+		files: summary.files.length,
+		skipped: summary.skipped.length,
+		total: summary.aggregate.total
+	});
+	return summary;
 }
 
 //#endregion
-//#region node_modules/picocolors/picocolors.js
-var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	let p = process || {}, argv = p.argv || [], env = p.env || {};
-	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-	let formatter = (open, close, replace = open) => (input) => {
-		let string = "" + input, index = string.indexOf(close, open.length);
-		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-	};
-	let replaceClose = (string, close, replace, index) => {
-		let result = "", cursor = 0;
-		do {
-			result += string.substring(cursor, index) + replace;
-			cursor = index + close.length;
-			index = string.indexOf(close, cursor);
-		} while (~index);
-		return result + string.substring(cursor);
-	};
-	let createColors = (enabled = isColorSupported) => {
-		let f = enabled ? formatter : () => String;
-		return {
-			isColorSupported: enabled,
-			reset: f("\x1B[0m", "\x1B[0m"),
-			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-			italic: f("\x1B[3m", "\x1B[23m"),
-			underline: f("\x1B[4m", "\x1B[24m"),
-			inverse: f("\x1B[7m", "\x1B[27m"),
-			hidden: f("\x1B[8m", "\x1B[28m"),
-			strikethrough: f("\x1B[9m", "\x1B[29m"),
-			black: f("\x1B[30m", "\x1B[39m"),
-			red: f("\x1B[31m", "\x1B[39m"),
-			green: f("\x1B[32m", "\x1B[39m"),
-			yellow: f("\x1B[33m", "\x1B[39m"),
-			blue: f("\x1B[34m", "\x1B[39m"),
-			magenta: f("\x1B[35m", "\x1B[39m"),
-			cyan: f("\x1B[36m", "\x1B[39m"),
-			white: f("\x1B[37m", "\x1B[39m"),
-			gray: f("\x1B[90m", "\x1B[39m"),
-			bgBlack: f("\x1B[40m", "\x1B[49m"),
-			bgRed: f("\x1B[41m", "\x1B[49m"),
-			bgGreen: f("\x1B[42m", "\x1B[49m"),
-			bgYellow: f("\x1B[43m", "\x1B[49m"),
-			bgBlue: f("\x1B[44m", "\x1B[49m"),
-			bgMagenta: f("\x1B[45m", "\x1B[49m"),
-			bgCyan: f("\x1B[46m", "\x1B[49m"),
-			bgWhite: f("\x1B[47m", "\x1B[49m"),
-			blackBright: f("\x1B[90m", "\x1B[39m"),
-			redBright: f("\x1B[91m", "\x1B[39m"),
-			greenBright: f("\x1B[92m", "\x1B[39m"),
-			yellowBright: f("\x1B[93m", "\x1B[39m"),
-			blueBright: f("\x1B[94m", "\x1B[39m"),
-			magentaBright: f("\x1B[95m", "\x1B[39m"),
-			cyanBright: f("\x1B[96m", "\x1B[39m"),
-			whiteBright: f("\x1B[97m", "\x1B[39m"),
-			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-			bgRedBright: f("\x1B[101m", "\x1B[49m"),
-			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-		};
-	};
-	module.exports = createColors();
-	module.exports.createColors = createColors;
-}));
+//#region src/utils/show-singular-or-plural-word.ts
+function showSingularOrPluralWord(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
 
 //#endregion
 //#region src/cli/output/render.ts
-var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 function getCountUnit(mode) {
-	return mode === "char" ? "character" : "word";
+	return mode === "char" || mode === "char-collector" ? "character" : "word";
 }
 function getTotalLabels(mode, includeNonWords) {
-	const unit = mode === "char" ? "characters" : "words";
+	const unit = mode === "char" || mode === "char-collector" ? "characters" : "words";
 	if (includeNonWords) return {
 		overall: "Total count",
 		section: "total count"
@@ -2044,7 +2235,7 @@ function renderStandardResult(result, totalLabel, totalOfOverride) {
 		renderNonWords(result.breakdown.nonWords, false);
 		return;
 	}
-	if (result.breakdown.mode === "char") {
+	if (result.breakdown.mode === "char" || result.breakdown.mode === "char-collector") {
 		renderCountBreakdown(result.breakdown.items.map((item) => ({
 			locale: item.locale,
 			count: item.chars,
@@ -2082,7 +2273,7 @@ function renderStandardSectionedResult(result, labels, totalOfOverride) {
 			renderNonWords(item.result.breakdown.nonWords, false);
 			continue;
 		}
-		if (item.result.breakdown.mode === "char") {
+		if (item.result.breakdown.mode === "char" || item.result.breakdown.mode === "char-collector") {
 			renderCountBreakdown(item.result.breakdown.items.map((chunk) => ({
 				locale: chunk.locale,
 				count: chunk.chars,
@@ -2128,78 +2319,7 @@ function renderPerFileStandard(summary, labels, resolveTotalOfOverride) {
 }
 
 //#endregion
-//#region src/command.ts
-const MODE_CHOICES = [
-	"chunk",
-	"segments",
-	"collector",
-	"char"
-];
-const FORMAT_CHOICES = [
-	"standard",
-	"raw",
-	"json"
-];
-const SECTION_CHOICES = [
-	"all",
-	"split",
-	"frontmatter",
-	"content",
-	"per-key",
-	"split-per-key"
-];
-const PATH_MODE_CHOICES = ["auto", "manual"];
-function getPackageVersion() {
-	const packageCandidates = [new URL("../package.json", import.meta.url), new URL("../../package.json", import.meta.url)];
-	let version = "0.0.0";
-	for (const packageUrl of packageCandidates) try {
-		const raw = readFileSync(packageUrl, "utf8");
-		const data = JSON.parse(raw);
-		if (data.version) {
-			version = data.version;
-			break;
-		}
-	} catch {
-		continue;
-	}
-	return import_picocolors.default.bgBlack(import_picocolors.default.bold(import_picocolors.default.italic(` word-counter ${import_picocolors.default.cyanBright(`ver.${version}`)} `)));
-}
-async function readStdin() {
-	if (process.stdin.isTTY) return "";
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
-		process.stdin.on("end", () => resolve(chunks.join("")));
-		process.stdin.on("error", (error) => reject(error));
-		process.stdin.resume();
-	});
-}
-async function resolveInput(textTokens) {
-	if (textTokens.length > 0) return textTokens.join(" ");
-	return readStdin();
-}
-function collectPathValue(value, previous = []) {
-	return [...previous, value];
-}
-function resolveBatchScope(argv) {
-	let scope = "merged";
-	for (const token of argv) {
-		if (token === "--merged") {
-			scope = "merged";
-			continue;
-		}
-		if (token === "--per-file") scope = "per-file";
-	}
-	return scope;
-}
-function hasPathInput(pathValues) {
-	return Array.isArray(pathValues) && pathValues.length > 0;
-}
-function resolveDebugReportPathOption(rawValue) {
-	if (rawValue === void 0 || rawValue === false) return;
-	if (typeof rawValue === "string") return rawValue;
-}
+//#region src/cli/output/normalize-base.ts
 function normalizeWordCounterResultBase(result) {
 	result.total = result.counts?.words ?? result.total;
 	delete result.counts;
@@ -2207,7 +2327,7 @@ function normalizeWordCounterResultBase(result) {
 		delete result.breakdown.nonWords;
 		return result;
 	}
-	if (result.breakdown.mode === "char") {
+	if (result.breakdown.mode === "char" || result.breakdown.mode === "char-collector") {
 		for (const item of result.breakdown.items) {
 			const nonWordCount = (item.nonWords?.counts.emoji ?? 0) + (item.nonWords?.counts.symbols ?? 0) + (item.nonWords?.counts.punctuation ?? 0) + (item.nonWords?.counts.whitespace ?? 0);
 			item.chars = Math.max(0, item.chars - nonWordCount);
@@ -2236,6 +2356,225 @@ function normalizeBatchSummaryBase(summary) {
 	normalizeResultBase(summary.aggregate);
 	return summary;
 }
+
+//#endregion
+//#region src/cli/runtime/options.ts
+function hasPathInput(pathValues) {
+	return Array.isArray(pathValues) && pathValues.length > 0;
+}
+function resolveBatchScope(argv) {
+	let scope = "merged";
+	for (const token of argv) {
+		if (token === "--merged") {
+			scope = "merged";
+			continue;
+		}
+		if (token === "--per-file") scope = "per-file";
+	}
+	return scope;
+}
+function resolveDebugReportPathOption(rawValue) {
+	if (rawValue === void 0 || rawValue === false) return;
+	if (typeof rawValue === "string") return rawValue;
+}
+function resolveCountRunOptions(options) {
+	const useSection = options.section !== "all";
+	const totalOfParts = options.totalOf;
+	const requestedNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc);
+	const collectNonWordsForOverride = requiresNonWordCollection(totalOfParts);
+	const collectWhitespaceForOverride = requiresWhitespaceCollection(totalOfParts);
+	const enableNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc || collectNonWordsForOverride);
+	const enableWhitespace = Boolean(options.includeWhitespace || options.misc || collectWhitespaceForOverride);
+	return {
+		useSection,
+		totalOfParts,
+		requestedNonWords,
+		shouldNormalizeBaseOutput: !requestedNonWords && enableNonWords,
+		wcOptions: {
+			mode: options.mode,
+			latinLanguageHint: options.latinLanguage,
+			latinTagHint: options.latinTag,
+			latinLocaleHint: options.latinLocale,
+			hanLanguageHint: options.hanLanguage,
+			hanTagHint: options.hanTag,
+			nonWords: enableNonWords,
+			includeWhitespace: enableWhitespace
+		}
+	};
+}
+function formatInputReadError(error) {
+	return `Failed to read input: ${error instanceof Error ? error.message : String(error)}`;
+}
+
+//#endregion
+//#region src/cli/runtime/batch.ts
+async function executeBatchCount({ argv, options, runtime, resolved, debug, teeEnabled }) {
+	const batchOptions = {
+		scope: resolveBatchScope(argv),
+		pathMode: options.pathMode,
+		recursive: options.recursive,
+		quietSkips: Boolean(options.quietSkips)
+	};
+	const extensionFilter = buildDirectoryExtensionFilter(options.includeExt, options.excludeExt);
+	const debugEnabled = Boolean(options.debug);
+	const mirrorDebugToTerminal = debugEnabled && (!debug.reportPath || teeEnabled);
+	const summary = await runBatchCount({
+		pathInputs: options.path ?? [],
+		batchOptions,
+		extensionFilter,
+		section: options.section,
+		wcOptions: resolved.wcOptions,
+		preserveCollectorSegments: options.format === "json",
+		debug,
+		progressReporter: createBatchProgressReporter({
+			enabled: options.format === "standard" && options.progress,
+			stream: runtime.stderr ?? process.stderr,
+			clearOnFinish: !(mirrorDebugToTerminal || options.keepProgress)
+		})
+	});
+	const showSkipDiagnostics = debugEnabled && !batchOptions.quietSkips;
+	debug.emit("batch.skips.policy", {
+		enabled: showSkipDiagnostics,
+		quietSkips: batchOptions.quietSkips
+	});
+	if (showSkipDiagnostics) {
+		debug.emit("batch.skips.report", { count: summary.skipped.length });
+		if (options.verbose) for (const skip of summary.skipped) debug.emit("batch.skips.item", {
+			path: skip.path,
+			reason: skip.reason
+		}, { verbosity: "verbose" });
+		if (mirrorDebugToTerminal) reportSkipped(summary.skipped);
+	}
+	if (summary.files.length === 0) throw new Error("No readable text-like inputs were found from --path.");
+	let aggregateTotalOfOverride;
+	let totalOfOverridesByResult;
+	if (resolved.totalOfParts && resolved.totalOfParts.length > 0) {
+		totalOfOverridesByResult = /* @__PURE__ */ new WeakMap();
+		const aggregateOverride = resolveTotalOfOverride(summary.aggregate, resolved.totalOfParts);
+		if (aggregateOverride) {
+			totalOfOverridesByResult.set(summary.aggregate, aggregateOverride);
+			aggregateTotalOfOverride = aggregateOverride;
+		}
+		for (const file of summary.files) {
+			const fileOverride = resolveTotalOfOverride(file.result, resolved.totalOfParts);
+			if (!fileOverride) continue;
+			totalOfOverridesByResult.set(file.result, fileOverride);
+		}
+	} else aggregateTotalOfOverride = resolveTotalOfOverride(summary.aggregate, resolved.totalOfParts);
+	if (resolved.shouldNormalizeBaseOutput) normalizeBatchSummaryBase(summary);
+	if (!aggregateTotalOfOverride && totalOfOverridesByResult) aggregateTotalOfOverride = totalOfOverridesByResult.get(summary.aggregate);
+	if (options.format === "raw") {
+		console.log(aggregateTotalOfOverride?.total ?? summary.aggregate.total);
+		return;
+	}
+	if (options.format === "json") {
+		const spacing = options.pretty ? 2 : 0;
+		if (batchOptions.scope === "per-file") {
+			const skipped = showSkipDiagnostics ? summary.skipped : void 0;
+			const meta = resolved.totalOfParts && resolved.totalOfParts.length > 0 ? {
+				totalOf: resolved.totalOfParts,
+				aggregateTotalOfOverride: aggregateTotalOfOverride?.total ?? summary.aggregate.total
+			} : void 0;
+			const payload = {
+				scope: "per-file",
+				files: summary.files.map((file) => ({
+					path: file.path,
+					result: file.result
+				})),
+				...skipped ? { skipped } : {},
+				aggregate: summary.aggregate,
+				...meta ? { meta } : {}
+			};
+			console.log(JSON.stringify(payload, null, spacing));
+			return;
+		}
+		if (!aggregateTotalOfOverride) {
+			console.log(JSON.stringify(summary.aggregate, null, spacing));
+			return;
+		}
+		console.log(JSON.stringify({
+			...summary.aggregate,
+			meta: {
+				totalOf: aggregateTotalOfOverride.parts,
+				totalOfOverride: aggregateTotalOfOverride.total
+			}
+		}, null, spacing));
+		return;
+	}
+	const labels = getTotalLabels(options.mode, resolved.requestedNonWords);
+	const totalOfResolver = resolved.totalOfParts && resolved.totalOfParts.length > 0 ? (result) => totalOfOverridesByResult?.get(result) ?? resolveTotalOfOverride(result, resolved.totalOfParts) : void 0;
+	if (batchOptions.scope === "per-file") {
+		renderPerFileStandard(summary, labels, totalOfResolver);
+		return;
+	}
+	if (isSectionedResult(summary.aggregate)) {
+		renderStandardSectionedResult(summary.aggregate, labels, aggregateTotalOfOverride);
+		return;
+	}
+	renderStandardResult(summary.aggregate, labels.overall, aggregateTotalOfOverride);
+}
+
+//#endregion
+//#region src/cli/runtime/input.ts
+async function readStdin() {
+	if (process.stdin.isTTY) return "";
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.setEncoding("utf8");
+		process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
+		process.stdin.on("end", () => resolve(chunks.join("")));
+		process.stdin.on("error", (error) => reject(error));
+		process.stdin.resume();
+	});
+}
+async function resolveInput(textTokens) {
+	if (textTokens.length > 0) return textTokens.join(" ");
+	return readStdin();
+}
+
+//#endregion
+//#region src/cli/runtime/single.ts
+async function executeSingleCount({ textTokens, options, resolved }) {
+	let input;
+	try {
+		input = await resolveInput(textTokens);
+	} catch (error) {
+		throw new Error(formatInputReadError(error));
+	}
+	const trimmed = input.trim();
+	if (!trimmed) throw new Error("No input provided. Pass text, pipe stdin, or use --path.");
+	const result = resolved.useSection ? countSections(trimmed, options.section, resolved.wcOptions) : wc_default(trimmed, resolved.wcOptions);
+	const totalOfOverride = resolveTotalOfOverride(result, resolved.totalOfParts);
+	const displayResult = resolved.shouldNormalizeBaseOutput ? normalizeResultBase(result) : result;
+	if (options.format === "raw") {
+		console.log(totalOfOverride?.total ?? displayResult.total);
+		return;
+	}
+	if (options.format === "json") {
+		const spacing = options.pretty ? 2 : 0;
+		if (!totalOfOverride) {
+			console.log(JSON.stringify(displayResult, null, spacing));
+			return;
+		}
+		console.log(JSON.stringify({
+			...displayResult,
+			meta: {
+				totalOf: totalOfOverride.parts,
+				totalOfOverride: totalOfOverride.total
+			}
+		}, null, spacing));
+		return;
+	}
+	const labels = getTotalLabels(options.mode, resolved.requestedNonWords);
+	if (isSectionedResult(displayResult)) {
+		renderStandardSectionedResult(displayResult, labels, totalOfOverride);
+		return;
+	}
+	renderStandardResult(displayResult, labels.overall, totalOfOverride);
+}
+
+//#endregion
+//#region src/command.ts
 async function runCli(argv = process.argv, runtime = {}) {
 	const program = new Command();
 	const parseMode = (value) => {
@@ -2243,7 +2582,8 @@ async function runCli(argv = process.argv, runtime = {}) {
 		if (!normalized) throw new Error(`Invalid mode: ${value}`);
 		return normalized;
 	};
-	program.name("word-counter").description("Locale-aware word counting powered by Intl.Segmenter.").version(getPackageVersion(), "-v, --version", "output the version number").addOption(new Option("-m, --mode <mode>", "breakdown mode").choices(MODE_CHOICES).argParser(parseMode).default("chunk")).addOption(new Option("-f, --format <format>", "output format").choices(FORMAT_CHOICES).default("standard")).addOption(new Option("--section <section>", "document section mode").choices(SECTION_CHOICES).default("all")).addOption(new Option("--path-mode <mode>", "path resolution mode").choices(PATH_MODE_CHOICES).default("auto")).option("--latin-language <language>", "hint a language tag for Latin script text").option("--latin-tag <tag>", "hint a BCP 47 tag for Latin script text").option("--latin-locale <locale>", "legacy alias of --latin-language").option("--han-language <language>", "hint a language tag for Han script text").option("--han-tag <tag>", "hint a BCP 47 tag for Han script text").option("--non-words", "collect emoji, symbols, and punctuation (excludes whitespace)").option("--include-whitespace", "include whitespace counts (implies with --non-words; same as --misc)").option("--misc", "collect non-words plus whitespace (alias for --include-whitespace)").option("--total-of <parts>", "override total composition (comma-separated): words,emoji,symbols,punctuation,whitespace", parseTotalOfOption).option("--pretty", "pretty print JSON output", false).option("--debug", "enable debug diagnostics on stderr").option("--verbose", "emit verbose per-file debug diagnostics (requires --debug)").option("--debug-report [path]", "write debug diagnostics to a report file").option("--debug-report-tee", "mirror debug diagnostics to both report file and stderr").option("--debug-tee", "alias of --debug-report-tee").option("--merged", "show merged aggregate output (default)").option("--per-file", "show per-file output plus merged summary").option("--no-progress", "disable batch progress indicator").option("--keep-progress", "keep final batch progress line visible in standard mode").option("--no-recursive", "disable recursive directory traversal").option("--quiet-skips", "hide skip diagnostics (applies when --debug is enabled)").option("--include-ext <exts>", "comma-separated extensions to include during directory scanning", collectExtensionOption, []).option("--exclude-ext <exts>", "comma-separated extensions to exclude during directory scanning", collectExtensionOption, []).option("-p, --path <path>", "read input from file or directory", collectPathValue, []).argument("[text...]", "text to count").showHelpAfterError();
+	program.name("word-counter").description("Locale-aware word counting powered by Intl.Segmenter.").version(getFormattedVersionLabel(), "-v, --version", "output the version number");
+	configureProgramOptions(program, parseMode);
 	program.action(async (textTokens, options) => {
 		const debugEnabled = Boolean(options.debug);
 		const debugReportPath = resolveDebugReportPathOption(options.debugReport);
@@ -2277,173 +2617,34 @@ async function runCli(argv = process.argv, runtime = {}) {
 			return;
 		}
 		try {
-			const useSection = options.section !== "all";
-			const totalOfParts = options.totalOf;
-			const requestedNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc);
-			const collectNonWordsForOverride = requiresNonWordCollection(totalOfParts);
-			const collectWhitespaceForOverride = requiresWhitespaceCollection(totalOfParts);
-			const enableNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc || collectNonWordsForOverride);
-			const enableWhitespace = Boolean(options.includeWhitespace || options.misc || collectWhitespaceForOverride);
-			const shouldNormalizeBaseOutput = !requestedNonWords && enableNonWords;
-			const wcOptions = {
-				mode: options.mode,
-				latinLanguageHint: options.latinLanguage,
-				latinTagHint: options.latinTag,
-				latinLocaleHint: options.latinLocale,
-				hanLanguageHint: options.hanLanguage,
-				hanTagHint: options.hanTag,
-				nonWords: enableNonWords,
-				includeWhitespace: enableWhitespace
-			};
-			if (!hasPathInput(options.path)) {
-				let input;
-				try {
-					input = await resolveInput(textTokens);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : String(error);
-					program.error(`Failed to read input: ${message}`);
-					return;
-				}
-				const trimmed = input.trim();
-				if (!trimmed) {
-					program.error(import_picocolors.default.red("No input provided. Pass text, pipe stdin, or use --path."));
-					return;
-				}
-				const result = useSection ? countSections(trimmed, options.section, wcOptions) : wc_default(trimmed, wcOptions);
-				const totalOfOverride = resolveTotalOfOverride(result, totalOfParts);
-				const displayResult = shouldNormalizeBaseOutput ? normalizeResultBase(result) : result;
-				if (options.format === "raw") {
-					console.log(totalOfOverride?.total ?? displayResult.total);
-					return;
-				}
-				if (options.format === "json") {
-					const spacing = options.pretty ? 2 : 0;
-					if (!totalOfOverride) {
-						console.log(JSON.stringify(displayResult, null, spacing));
-						return;
-					}
-					console.log(JSON.stringify({
-						...displayResult,
-						meta: {
-							totalOf: totalOfOverride.parts,
-							totalOfOverride: totalOfOverride.total
-						}
-					}, null, spacing));
-					return;
-				}
-				const labels = getTotalLabels(options.mode, requestedNonWords);
-				if (isSectionedResult(displayResult)) {
-					renderStandardSectionedResult(displayResult, labels, totalOfOverride);
-					return;
-				}
-				renderStandardResult(displayResult, labels.overall, totalOfOverride);
+			const resolved = resolveCountRunOptions(options);
+			if (hasPathInput(options.path)) {
+				await executeBatchCount({
+					argv,
+					options,
+					runtime,
+					resolved,
+					debug,
+					teeEnabled
+				});
 				return;
 			}
-			const batchOptions = {
-				scope: resolveBatchScope(argv),
-				pathMode: options.pathMode,
-				recursive: options.recursive,
-				quietSkips: Boolean(options.quietSkips)
-			};
-			const extensionFilter = buildDirectoryExtensionFilter(options.includeExt, options.excludeExt);
-			const mirrorDebugToTerminal = debugEnabled && (!debug.reportPath || teeEnabled);
-			const summary = await runBatchCount({
-				pathInputs: options.path,
-				batchOptions,
-				extensionFilter,
-				section: options.section,
-				wcOptions,
-				preserveCollectorSegments: options.format === "json",
-				debug,
-				progressReporter: createBatchProgressReporter({
-					enabled: options.format === "standard" && options.progress,
-					stream: runtime.stderr ?? process.stderr,
-					clearOnFinish: !(mirrorDebugToTerminal || options.keepProgress)
-				})
+			await executeSingleCount({
+				textTokens,
+				options,
+				resolved
 			});
-			const showSkipDiagnostics = debugEnabled && !batchOptions.quietSkips;
-			debug.emit("batch.skips.policy", {
-				enabled: showSkipDiagnostics,
-				quietSkips: batchOptions.quietSkips
-			});
-			if (showSkipDiagnostics) {
-				debug.emit("batch.skips.report", { count: summary.skipped.length });
-				if (options.verbose) for (const skip of summary.skipped) debug.emit("batch.skips.item", {
-					path: skip.path,
-					reason: skip.reason
-				}, { verbosity: "verbose" });
-				if (mirrorDebugToTerminal) reportSkipped(summary.skipped);
-			}
-			if (summary.files.length === 0) {
-				program.error(import_picocolors.default.red("No readable text-like inputs were found from --path."));
-				return;
-			}
-			let aggregateTotalOfOverride;
-			let totalOfOverridesByResult;
-			if (totalOfParts && totalOfParts.length > 0) {
-				totalOfOverridesByResult = /* @__PURE__ */ new WeakMap();
-				const aggregateOverride = resolveTotalOfOverride(summary.aggregate, totalOfParts);
-				if (aggregateOverride) {
-					totalOfOverridesByResult.set(summary.aggregate, aggregateOverride);
-					aggregateTotalOfOverride = aggregateOverride;
-				}
-				for (const file of summary.files) {
-					const fileOverride = resolveTotalOfOverride(file.result, totalOfParts);
-					if (!fileOverride) continue;
-					totalOfOverridesByResult.set(file.result, fileOverride);
-				}
-			} else aggregateTotalOfOverride = resolveTotalOfOverride(summary.aggregate, totalOfParts);
-			if (shouldNormalizeBaseOutput) normalizeBatchSummaryBase(summary);
-			if (!aggregateTotalOfOverride && totalOfOverridesByResult) aggregateTotalOfOverride = totalOfOverridesByResult.get(summary.aggregate);
-			if (options.format === "raw") {
-				console.log(aggregateTotalOfOverride?.total ?? summary.aggregate.total);
-				return;
-			}
-			if (options.format === "json") {
-				const spacing = options.pretty ? 2 : 0;
-				if (batchOptions.scope === "per-file") {
-					const skipped = showSkipDiagnostics ? summary.skipped : void 0;
-					const meta = totalOfParts && totalOfParts.length > 0 ? {
-						totalOf: totalOfParts,
-						aggregateTotalOfOverride: aggregateTotalOfOverride?.total ?? summary.aggregate.total
-					} : void 0;
-					const payload = {
-						scope: "per-file",
-						files: summary.files.map((file) => ({
-							path: file.path,
-							result: file.result
-						})),
-						...skipped ? { skipped } : {},
-						aggregate: summary.aggregate,
-						...meta ? { meta } : {}
-					};
-					console.log(JSON.stringify(payload, null, spacing));
-					return;
-				}
-				if (!aggregateTotalOfOverride) {
-					console.log(JSON.stringify(summary.aggregate, null, spacing));
-					return;
-				}
-				console.log(JSON.stringify({
-					...summary.aggregate,
-					meta: {
-						totalOf: aggregateTotalOfOverride.parts,
-						totalOfOverride: aggregateTotalOfOverride.total
-					}
-				}, null, spacing));
-				return;
-			}
-			const labels = getTotalLabels(options.mode, requestedNonWords);
-			const totalOfResolver = totalOfParts && totalOfParts.length > 0 ? (result) => totalOfOverridesByResult?.get(result) ?? resolveTotalOfOverride(result, totalOfParts) : void 0;
-			if (batchOptions.scope === "per-file") {
-				renderPerFileStandard(summary, labels, totalOfResolver);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message === "No input provided. Pass text, pipe stdin, or use --path.") {
+				program.error(import_picocolors.default.red(message));
 				return;
 			}
-			if (isSectionedResult(summary.aggregate)) {
-				renderStandardSectionedResult(summary.aggregate, labels, aggregateTotalOfOverride);
+			if (message === "No readable text-like inputs were found from --path.") {
+				program.error(import_picocolors.default.red(message));
 				return;
 			}
-			renderStandardResult(summary.aggregate, labels.overall, aggregateTotalOfOverride);
+			program.error(message);
 		} finally {
 			await debug.close();
 		}