@dev-pi2pie/word-counter 0.1.4 → 0.1.5-canary.2

package/dist/cjs/markdown.cjs

@@ -0,0 +1,1318 @@
+let yaml = require("yaml");
+//#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;
+}
+function supportsSegmenter() {
+	return typeof Intl !== "undefined" && typeof Intl.Segmenter === "function";
+}
+function countWordsForLocale(text, locale) {
+	const segmenter = getSegmenter(locale);
+	let count = 0;
+	for (const segment of segmenter.segment(text)) if (segment.isWordLike) count++;
+	return count;
+}
+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;
+}
+//#endregion
+//#region src/utils/append-all.ts
+function appendAll(target, source) {
+	for (const item of source) target.push(item);
+}
+//#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 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;
+	}
+	collection.punctuation.push(segment);
+	collection.counts.punctuation += 1;
+}
+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 (char === "	") {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.tabs += 1;
+			count += 1;
+			continue;
+		}
+		if (newlineChars.has(char)) {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.newlines += 1;
+			count += 1;
+			continue;
+		}
+		if (whitespaceRegex.test(char)) {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.other += 1;
+			count += 1;
+		}
+	}
+	if (count > 0) {
+		collection.whitespace = whitespace ?? createWhitespaceCounts();
+		collection.counts.whitespace = (collection.counts.whitespace ?? 0) + count;
+	}
+	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;
+}
+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 createWhitespaceCounts() {
+	return {
+		spaces: 0,
+		tabs: 0,
+		newlines: 0,
+		other: 0
+	};
+}
+//#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;
+			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;
+			}
+		}
+	}
+	return {
+		locale: chunk.locale,
+		text: chunk.text,
+		chars,
+		wordChars,
+		nonWordChars,
+		nonWords: nonWords ?? void 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 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 order.map((locale) => map.get(locale));
+}
+//#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",
+	"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 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 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 resolveMode(input, fallback = "chunk") {
+	return normalizeMode(input) ?? fallback;
+}
+const DEFAULT_LATIN_HINT_RULES = Object.freeze([
+	{
+		tag: "de",
+		pattern: "[äöüÄÖÜß]"
+	},
+	{
+		tag: "es",
+		pattern: "[ñÑ¿¡]"
+	},
+	{
+		tag: "pt",
+		pattern: "[ãõÃÕ]"
+	},
+	{
+		tag: "fr",
+		pattern: "[œŒæÆ]"
+	},
+	{
+		tag: "pl",
+		pattern: "[ąćęłńśźżĄĆĘŁŃŚŹŻ]"
+	},
+	{
+		tag: "tr",
+		pattern: "[ıİğĞşŞ]"
+	},
+	{
+		tag: "ro",
+		pattern: "[ăĂâÂîÎșȘțȚ]"
+	},
+	{
+		tag: "hu",
+		pattern: "[őŐűŰ]"
+	},
+	{
+		tag: "is",
+		pattern: "[ðÐþÞ]"
+	}
+].map((rule) => Object.freeze({ ...rule })));
+//#endregion
+//#region src/wc/locale-detect.ts
+const DEFAULT_LOCALE = "und-Latn";
+const DEFAULT_HAN_TAG = "und-Hani";
+const MAX_LATIN_HINT_PATTERN_LENGTH = 256;
+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 defaultLatinLocales = new Set([DEFAULT_LOCALE, ...DEFAULT_LATIN_HINT_RULES.map((hint) => hint.tag)]);
+function isLatinLocale(locale, context) {
+	if (context) return context.latinLocales.has(locale);
+	return defaultLatinLocales.has(locale);
+}
+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 compileLatinHintPattern(pattern, label) {
+	const source = typeof pattern === "string" ? pattern : pattern.source;
+	const hasUnicodeMode = typeof pattern !== "string" && (pattern.flags.includes("u") || pattern.flags.includes("v"));
+	const flags = typeof pattern === "string" ? "u" : hasUnicodeMode ? pattern.flags : `${pattern.flags}u`;
+	if (source.length === 0) throw new Error(`${label}: pattern must not be empty.`);
+	if (source.length > MAX_LATIN_HINT_PATTERN_LENGTH) throw new Error(`${label}: pattern must be at most ${MAX_LATIN_HINT_PATTERN_LENGTH} characters.`);
+	try {
+		return new RegExp(source, flags);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`${label}: invalid Unicode regex pattern (${message}).`);
+	}
+}
+function normalizeLatinHintPriority(priority, label) {
+	if (priority === void 0) return 0;
+	if (typeof priority !== "number" || !Number.isFinite(priority)) throw new Error(`${label}: priority must be a finite number when provided.`);
+	return priority;
+}
+function compileLatinHintRule(rule, order, label) {
+	const tag = typeof rule.tag === "string" ? rule.tag.trim() : "";
+	if (!tag) throw new Error(`${label}: tag must be a non-empty string.`);
+	return {
+		tag,
+		pattern: compileLatinHintPattern(rule.pattern, label),
+		priority: normalizeLatinHintPriority(rule.priority, label),
+		order
+	};
+}
+function resolveLatinHintRules(options) {
+	const useDefaultLatinHints = options.useDefaultLatinHints !== false;
+	const customRules = options.latinHintRules ?? [];
+	const combinedRules = [];
+	for (let index = 0; index < customRules.length; index += 1) {
+		const rule = customRules[index];
+		if (!rule) continue;
+		combinedRules.push({
+			rule,
+			label: `Invalid custom Latin hint rule at index ${index}`
+		});
+	}
+	if (useDefaultLatinHints) for (let index = 0; index < DEFAULT_LATIN_HINT_RULES.length; index += 1) {
+		const rule = DEFAULT_LATIN_HINT_RULES[index];
+		if (!rule) continue;
+		combinedRules.push({
+			rule,
+			label: `Invalid default Latin hint rule at index ${index}`
+		});
+	}
+	const resolvedRules = combinedRules.map((entry, index) => compileLatinHintRule(entry.rule, index, entry.label));
+	resolvedRules.sort((left, right) => {
+		if (left.priority !== right.priority) return right.priority - left.priority;
+		return left.order - right.order;
+	});
+	return resolvedRules;
+}
+function resolveLocaleDetectContext(options = {}) {
+	const latinHint = resolveLatinHint(options);
+	const latinHintRules = resolveLatinHintRules(options);
+	const latinLocales = new Set([DEFAULT_LOCALE]);
+	for (const rule of latinHintRules) latinLocales.add(rule.tag);
+	if (latinHint) latinLocales.add(latinHint);
+	return {
+		latinHint,
+		hanHint: resolveHanHint(options),
+		latinHintRules,
+		latinLocales
+	};
+}
+function detectLatinLocale(char, context) {
+	for (const hint of context.latinHintRules) {
+		hint.pattern.lastIndex = 0;
+		if (hint.pattern.test(char)) return hint.tag;
+	}
+	return DEFAULT_LOCALE;
+}
+function detectLocaleForChar(char, previousLocale, options = {}, context = resolveLocaleDetectContext(options), allowLatinLocaleCarry = true, allowJapaneseHanCarry = true) {
+	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 (allowJapaneseHanCarry && previousLocale && previousLocale.startsWith("ja")) return previousLocale;
+		return context.hanHint ?? "und-Hani";
+	}
+	if (regex.latin.test(char)) {
+		const hintedLocale = detectLatinLocale(char, context);
+		if (hintedLocale !== "und-Latn") return hintedLocale;
+		if (allowLatinLocaleCarry && previousLocale && isLatinLocale(previousLocale, context) && previousLocale !== "und-Latn") return previousLocale;
+		if (context.latinHint) return context.latinHint;
+		return DEFAULT_LOCALE;
+	}
+	return null;
+}
+//#endregion
+//#region src/wc/segment.ts
+const HARD_BOUNDARY_REGEX = /[\r\n,.!?;:，、。！？；：．｡､]/u;
+const LATIN_PROMOTION_BREAK_REGEX = /[\s,.!?;:，、。！？；：．｡､]/u;
+function segmentTextByLocale(text, options = {}) {
+	const context = resolveLocaleDetectContext(options);
+	const chunks = [];
+	let currentLocale = DEFAULT_LOCALE;
+	let buffer = "";
+	let bufferHasScript = false;
+	let sawCarryBoundary = false;
+	const updateCarryBoundaryState = (detected, char) => {
+		if (detected !== null) {
+			sawCarryBoundary = false;
+			return;
+		}
+		if (HARD_BOUNDARY_REGEX.test(char)) sawCarryBoundary = true;
+	};
+	for (const char of text) {
+		const detected = detectLocaleForChar(char, currentLocale, options, context, !sawCarryBoundary, !sawCarryBoundary);
+		const targetLocale = detected ?? currentLocale;
+		if (buffer === "") {
+			currentLocale = targetLocale;
+			buffer = char;
+			bufferHasScript = detected !== null;
+			updateCarryBoundaryState(detected, char);
+			continue;
+		}
+		if (detected !== null && !bufferHasScript) {
+			currentLocale = targetLocale;
+			buffer += char;
+			bufferHasScript = true;
+			updateCarryBoundaryState(detected, char);
+			continue;
+		}
+		if (targetLocale !== currentLocale && detected !== null) {
+			if (currentLocale === "und-Latn" && isLatinLocale(targetLocale, context)) {
+				const promotionBreakIndex = findLastLatinPromotionBreakIndex(buffer);
+				if (promotionBreakIndex === -1) {
+					currentLocale = targetLocale;
+					buffer += char;
+					bufferHasScript = true;
+					updateCarryBoundaryState(detected, char);
+					continue;
+				}
+				const prefix = buffer.slice(0, promotionBreakIndex + 1);
+				const suffix = buffer.slice(promotionBreakIndex + 1);
+				if (prefix.length > 0) chunks.push({
+					locale: currentLocale,
+					text: prefix
+				});
+				currentLocale = targetLocale;
+				buffer = `${suffix}${char}`;
+				bufferHasScript = true;
+				updateCarryBoundaryState(detected, char);
+				continue;
+			}
+			chunks.push({
+				locale: currentLocale,
+				text: buffer
+			});
+			currentLocale = targetLocale;
+			buffer = char;
+			bufferHasScript = true;
+			updateCarryBoundaryState(detected, char);
+			continue;
+		}
+		buffer += char;
+		if (detected !== null) bufferHasScript = true;
+		updateCarryBoundaryState(detected, char);
+	}
+	if (buffer.length > 0) chunks.push({
+		locale: currentLocale,
+		text: buffer
+	});
+	return mergeAdjacentChunks(chunks);
+}
+function findLastLatinPromotionBreakIndex(buffer) {
+	for (let index = buffer.length - 1; index >= 0; index -= 1) {
+		const char = buffer[index];
+		if (!char) continue;
+		if (LATIN_PROMOTION_BREAK_REGEX.test(char)) return index;
+	}
+	return -1;
+}
+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,
+		latinHintRules: options.latinHintRules,
+		useDefaultLatinHints: options.useDefaultLatinHints,
+		hanLanguageHint: options.hanLanguageHint,
+		hanTagHint: options.hanTagHint
+	});
+	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
+			}))
+		}
+	};
+	if (mode === "collector") return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: aggregateByLocale(analyzed),
+			nonWords: collectNonWordsAggregate(analyzed, collectNonWords)
+		}
+	};
+	return {
+		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/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 (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 = (0, yaml.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/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, 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 sumTotals(items) {
+	return items.reduce((sum, item) => sum + item.result.total, 0);
+}
+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
+	};
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_HAN_TAG", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_HAN_TAG;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_LOCALE", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_LOCALE;
+	}
+});
+Object.defineProperty(exports, "aggregateByLocale", {
+	enumerable: true,
+	get: function() {
+		return aggregateByLocale;
+	}
+});
+Object.defineProperty(exports, "aggregateCharsByLocale", {
+	enumerable: true,
+	get: function() {
+		return aggregateCharsByLocale;
+	}
+});
+Object.defineProperty(exports, "analyzeCharChunk", {
+	enumerable: true,
+	get: function() {
+		return analyzeCharChunk;
+	}
+});
+Object.defineProperty(exports, "analyzeChunk", {
+	enumerable: true,
+	get: function() {
+		return analyzeChunk;
+	}
+});
+Object.defineProperty(exports, "countCharsForLocale", {
+	enumerable: true,
+	get: function() {
+		return countCharsForLocale;
+	}
+});
+Object.defineProperty(exports, "countSections", {
+	enumerable: true,
+	get: function() {
+		return countSections;
+	}
+});
+Object.defineProperty(exports, "countWordsForLocale", {
+	enumerable: true,
+	get: function() {
+		return countWordsForLocale;
+	}
+});
+Object.defineProperty(exports, "createNonWordCollection", {
+	enumerable: true,
+	get: function() {
+		return createNonWordCollection;
+	}
+});
+Object.defineProperty(exports, "mergeNonWordCollections", {
+	enumerable: true,
+	get: function() {
+		return mergeNonWordCollections;
+	}
+});
+Object.defineProperty(exports, "parseMarkdown", {
+	enumerable: true,
+	get: function() {
+		return parseMarkdown;
+	}
+});
+Object.defineProperty(exports, "resolveMode", {
+	enumerable: true,
+	get: function() {
+		return resolveMode;
+	}
+});
+Object.defineProperty(exports, "segmentTextByLocale", {
+	enumerable: true,
+	get: function() {
+		return segmentTextByLocale;
+	}
+});
+Object.defineProperty(exports, "wc_default", {
+	enumerable: true,
+	get: function() {
+		return wc_default;
+	}
+});
+
+//# sourceMappingURL=markdown.cjs.map