@dev-pi2pie/word-counter 0.0.6

package/dist/esm/bin.mjs

@@ -0,0 +1,979 @@
+#!/usr/bin/env node
+
+import { Command, Option } from "commander";
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parseDocument } from "yaml";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/utils/show-singular-or-plural-word.ts
+function showSingularOrPluralWord(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+
+//#endregion
+//#region src/wc/segmenter.ts
+const segmenterCache = /* @__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;
+}
+
+//#endregion
+//#region src/wc/analyze.ts
+function analyzeChunk(chunk) {
+	const segmenter = getSegmenter(chunk.locale);
+	const segments = [];
+	for (const part of segmenter.segment(chunk.text)) if (part.isWordLike) segments.push(part.segment);
+	return {
+		locale: chunk.locale,
+		text: chunk.text,
+		segments,
+		words: segments.length
+	};
+}
+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;
+			existing.segments.push(...chunk.segments);
+			continue;
+		}
+		order.push(chunk.locale);
+		map.set(chunk.locale, {
+			locale: chunk.locale,
+			words: chunk.words,
+			segments: [...chunk.segments]
+		});
+	}
+	return order.map((locale) => map.get(locale));
+}
+
+//#endregion
+//#region src/wc/locale-detect.ts
+const DEFAULT_LOCALE = "und-Latn";
+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 detectLatinLocale(char) {
+	for (const hint of latinLocaleHints) if (hint.regex.test(char)) return hint.locale;
+	return DEFAULT_LOCALE;
+}
+function detectLocaleForChar(char, previousLocale) {
+	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 "zh-Hans";
+	}
+	if (regex.latin.test(char)) {
+		const hintedLocale = detectLatinLocale(char);
+		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
+		if (previousLocale && isLatinLocale(previousLocale)) return previousLocale;
+		return DEFAULT_LOCALE;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/wc/segment.ts
+function segmentTextByLocale(text) {
+	const chunks = [];
+	let currentLocale = DEFAULT_LOCALE;
+	let buffer = "";
+	for (const char of text) {
+		const detected = detectLocaleForChar(char, currentLocale);
+		const targetLocale = detected ?? currentLocale;
+		if (buffer === "") {
+			currentLocale = targetLocale;
+			buffer = char;
+			continue;
+		}
+		if (targetLocale !== currentLocale && detected !== null) {
+			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale)) {
+				currentLocale = targetLocale;
+				buffer += char;
+				continue;
+			}
+			chunks.push({
+				locale: currentLocale,
+				text: buffer
+			});
+			currentLocale = targetLocale;
+			buffer = char;
+			continue;
+		}
+		buffer += char;
+	}
+	if (buffer.length > 0) chunks.push({
+		locale: currentLocale,
+		text: buffer
+	});
+	return mergeAdjacentChunks(chunks);
+}
+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 = options.mode ?? "chunk";
+	const analyzed = segmentTextByLocale(text).map(analyzeChunk);
+	const total = analyzed.reduce((sum, chunk) => sum + chunk.words, 0);
+	if (mode === "segments") return {
+		total,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words,
+				segments: chunk.segments
+			}))
+		}
+	};
+	if (mode === "collector") return {
+		total,
+		breakdown: {
+			mode,
+			items: aggregateByLocale(analyzed)
+		}
+	};
+	return {
+		total,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words
+			}))
+		}
+	};
+}
+
+//#endregion
+//#region src/wc/index.ts
+var wc_default = wordCounter;
+
+//#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 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(" | ");
+	}
+}
+
+//#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;
+	}
+	const segments = trimmed.split(".").map((segment) => segment.trim());
+	if (segments.some((segment) => !segment)) return null;
+	return segments.join(".");
+}
+
+//#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();
+	}
+	return line;
+}
+function unescapeBasic(input) {
+	return input.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
+}
+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/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;
+}
+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;
+			continue;
+		}
+		if (char === ",") {
+			const item = parsePrimitive(current);
+			if (item === null) return null;
+			items.push(item);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	const finalItem = parsePrimitive(current);
+	if (finalItem === null) return null;
+	items.push(finalItem);
+	return items;
+}
+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 === "\"") {
+			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 = "";
+			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;
+	}
+	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);
+}
+
+//#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;
+		}
+		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 ((/* @__PURE__ */ 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);
+			}
+			continue;
+		}
+		if (tablePrefixInList && tableTarget) {
+			tableTarget[key] = toPlainText(normalized);
+			continue;
+		}
+		result[fullKey] = toPlainText(normalized);
+	}
+	flattenArrayTables(result);
+	return result;
+}
+
+//#endregion
+//#region src/markdown/parse-markdown.ts
+const FENCE_TO_TYPE = {
+	"---": "yaml",
+	"+++": "toml",
+	";;;": "json"
+};
+function normalizeNewlines(input) {
+	return input.replace(/\r\n/g, "\n");
+}
+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$1 = jsonBlock.jsonText;
+		let content = normalizedWithoutBom.slice(jsonBlock.endIndex + 1);
+		if (content.startsWith("\n")) content = content.slice(1);
+		const data = parseFrontmatter(frontmatter$1, "json");
+		if (!data) return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		return {
+			frontmatter: frontmatter$1,
+			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/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 buildPerKeyItems(data, mode) {
+	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, { mode })
+		};
+	});
+}
+function buildSingleItem(name, text, mode, source) {
+	return [{
+		name,
+		source,
+		result: wc_default(text, { mode })
+	}];
+}
+function sumTotals(items) {
+	return items.reduce((sum, item) => sum + item.result.total, 0);
+}
+function countSections(input, section, mode) {
+	if (section === "all") {
+		const result = wc_default(input, { mode });
+		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, "frontmatter");
+	else if (section === "content") items = buildSingleItem("content", contentText, mode, "content");
+	else if (section === "split") items = [...buildSingleItem("frontmatter", frontmatterText, mode, "frontmatter"), ...buildSingleItem("content", contentText, mode, "content")];
+	else if (section === "per-key") items = buildPerKeyItems(parsed.data, mode);
+	else if (section === "split-per-key") items = [...buildPerKeyItems(parsed.data, mode), ...buildSingleItem("content", contentText, mode, "content")];
+	return {
+		section,
+		total: sumTotals(items),
+		frontmatterType: parsed.frontmatterType,
+		items
+	};
+}
+
+//#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/command.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const MODE_CHOICES = [
+	"chunk",
+	"segments",
+	"collector"
+];
+const FORMAT_CHOICES = [
+	"standard",
+	"raw",
+	"json"
+];
+const SECTION_CHOICES = [
+	"all",
+	"split",
+	"frontmatter",
+	"content",
+	"per-key",
+	"split-per-key"
+];
+function getPackageVersion() {
+	const raw = readFileSync(new URL("../../package.json", import.meta.url), "utf8");
+	const version = JSON.parse(raw).version ?? "0.0.0";
+	return import_picocolors.default.bgBlack(import_picocolors.default.bold(import_picocolors.default.italic(` word-counter ${import_picocolors.default.cyanBright(`ver.${version}`)} `)));
+}
+function renderChunkBreakdown(items) {
+	for (const item of items) console.log(`Locale ${item.locale}: ${showSingularOrPluralWord(item.words, "word")}`);
+}
+function renderSegmentBreakdown(items) {
+	for (const item of items) console.log(`Locale ${item.locale}: ${JSON.stringify(item.segments)} (${showSingularOrPluralWord(item.words, "word")})`);
+}
+function renderCollectorBreakdown(items) {
+	for (const item of items) console.log(`Locale ${item.locale}: ${showSingularOrPluralWord(item.words, "word")}`);
+}
+function renderStandardResult(result) {
+	console.log(`Total words: ${result.total}`);
+	if (result.breakdown.mode === "segments") {
+		renderSegmentBreakdown(result.breakdown.items);
+		return;
+	}
+	if (result.breakdown.mode === "collector") {
+		renderCollectorBreakdown(result.breakdown.items);
+		return;
+	}
+	renderChunkBreakdown(result.breakdown.items);
+}
+function buildSectionLabel(sectionName, sectionMode, source) {
+	if (sectionMode === "frontmatter") return `[Frontmatter] (total)`;
+	if (sectionMode === "content") return `[Content] (total)`;
+	if (sectionMode === "split") {
+		if (source === "frontmatter") return `[Frontmatter] (total)`;
+		return `[Content] (total)`;
+	}
+	if (sectionMode === "per-key") return `[Frontmatter] ${sectionName} (total)`;
+	if (sectionMode === "split-per-key") {
+		if (source === "content") return `[Content] (total)`;
+		return `[Frontmatter] ${sectionName} (total)`;
+	}
+	return `[Section] ${sectionName} (total)`;
+}
+function renderStandardSectionedResult(result) {
+	console.log(`Total words: ${result.total}`);
+	for (const item of result.items) {
+		const label = buildSectionLabel(item.name, result.section, item.source);
+		console.log(import_picocolors.default.cyan(import_picocolors.default.bold(`${label}: ${showSingularOrPluralWord(item.result.total, "word")}`)));
+		if (item.result.breakdown.mode === "segments") {
+			renderSegmentBreakdown(item.result.breakdown.items);
+			continue;
+		}
+		if (item.result.breakdown.mode === "collector") {
+			renderCollectorBreakdown(item.result.breakdown.items);
+			continue;
+		}
+		renderChunkBreakdown(item.result.breakdown.items);
+	}
+}
+function isSectionedResult(result) {
+	return "section" in result;
+}
+async function readStdin() {
+	if (process.stdin.isTTY) return "";
+	return new Promise((resolve$1, reject) => {
+		const chunks = [];
+		process.stdin.setEncoding("utf8");
+		process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
+		process.stdin.on("end", () => resolve$1(chunks.join("")));
+		process.stdin.on("error", (error) => reject(error));
+		process.stdin.resume();
+	});
+}
+async function resolveInput(textTokens, pathInput) {
+	if (pathInput) return readFile(resolve(pathInput), "utf8");
+	if (textTokens.length > 0) return textTokens.join(" ");
+	return readStdin();
+}
+async function runCli(argv = process.argv) {
+	const program = new Command();
+	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).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")).option("--pretty", "pretty print JSON output", false).option("-p, --path <file>", "read input from a text file").argument("[text...]", "text to count").showHelpAfterError();
+	program.action(async (textTokens, options) => {
+		let input;
+		try {
+			input = await resolveInput(textTokens, options.path);
+		} 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 = options.section !== "all" ? countSections(trimmed, options.section, options.mode) : wc_default(trimmed, { mode: options.mode });
+		if (options.format === "raw") {
+			console.log(result.total);
+			return;
+		}
+		if (options.format === "json") {
+			const spacing = options.pretty ? 2 : 0;
+			console.log(JSON.stringify(result, null, spacing));
+			return;
+		}
+		if (isSectionedResult(result)) {
+			renderStandardSectionedResult(result);
+			return;
+		}
+		renderStandardResult(result);
+	});
+	await program.parseAsync(argv);
+}
+
+//#endregion
+//#region src/bin.ts
+runCli().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error("Failed to run CLI:", message);
+	process.exitCode = 1;
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=bin.mjs.map