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

package/dist/esm/worker/count-worker.mjs

@@ -1,7 +1,10 @@
+import { createRequire } from "node:module";
 import { readFile } from "node:fs/promises";
 import { parentPort, workerData } from "node:worker_threads";
 import { parseDocument } from "yaml";
-
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 //#region src/markdown/toml/arrays.ts
 function ensureArrayContainer(result, key) {
 	const existing = result[key];
@@ -16,7 +19,6 @@ function flattenArrayTables(result) {
 		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) {
@@ -35,7 +37,6 @@ function normalizeKeyPath(key) {
 	if (segments.some((segment) => !segment)) return null;
 	return segments.join(".");
 }
-
 //#endregion
 //#region src/markdown/toml/strings.ts
 function stripInlineComment(line) {
@@ -84,7 +85,6 @@ function parseStringLiteral(value) {
 	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return null;
 }
-
 //#endregion
 //#region src/markdown/toml/values.ts
 function parsePrimitive(raw) {
@@ -242,7 +242,6 @@ function toPlainText(value) {
 	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) {
@@ -326,7 +325,6 @@ function parseTomlFrontmatter(frontmatter) {
 	flattenArrayTables(result);
 	return result;
 }
-
 //#endregion
 //#region src/markdown/parse-markdown.ts
 const FENCE_TO_TYPE = {
@@ -461,7 +459,6 @@ function parseMarkdown(input) {
 		frontmatterType: openingType
 	};
 }
-
 //#endregion
 //#region src/wc/segmenter.ts
 const segmenterCache = /* @__PURE__ */ new Map();
@@ -490,13 +487,11 @@ function countCharsForLocale(text, locale) {
 	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;
@@ -610,7 +605,6 @@ function createWhitespaceCounts() {
 		other: 0
 	};
 }
-
 //#endregion
 //#region src/wc/analyze.ts
 function analyzeChunk(chunk, collectNonWords, includeWhitespace) {
@@ -710,7 +704,6 @@ function aggregateByLocale(chunks) {
 	}
 	return order.map((locale) => map.get(locale));
 }
-
 //#endregion
 //#region src/wc/mode.ts
 const MODE_ALIASES = {
@@ -778,10 +771,7 @@ function normalizeMode(input) {
 function resolveMode(input, fallback = "chunk") {
 	return normalizeMode(input) ?? fallback;
 }
-
-//#endregion
-//#region src/wc/latin-hints.ts
-const DEFAULT_LATIN_HINT_RULES_SOURCE = [
+const DEFAULT_LATIN_HINT_RULES = Object.freeze([
 	{
 		tag: "de",
 		pattern: "[äöüÄÖÜß]"
@@ -818,9 +808,7 @@ const DEFAULT_LATIN_HINT_RULES_SOURCE = [
 		tag: "is",
 		pattern: "[ðÐþÞ]"
 	}
-];
-const DEFAULT_LATIN_HINT_RULES = Object.freeze(DEFAULT_LATIN_HINT_RULES_SOURCE.map((rule) => Object.freeze({ ...rule })));
-
+].map((rule) => Object.freeze({ ...rule })));
 //#endregion
 //#region src/wc/locale-detect.ts
 const DEFAULT_LOCALE = "und-Latn";
@@ -940,18 +928,17 @@ function detectLocaleForChar(char, previousLocale, options = {}, context = resol
 	if (regex.thai.test(char)) return "th";
 	if (regex.han.test(char)) {
 		if (allowJapaneseHanCarry && previousLocale && previousLocale.startsWith("ja")) return previousLocale;
-		return context.hanHint ?? DEFAULT_HAN_TAG;
+		return context.hanHint ?? "und-Hani";
 	}
 	if (regex.latin.test(char)) {
 		const hintedLocale = detectLatinLocale(char, context);
-		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
-		if (allowLatinLocaleCarry && previousLocale && isLatinLocale(previousLocale, context) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
+		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;
@@ -988,7 +975,7 @@ function segmentTextByLocale(text, options = {}) {
 			continue;
 		}
 		if (targetLocale !== currentLocale && detected !== null) {
-			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale, context)) {
+			if (currentLocale === "und-Latn" && isLatinLocale(targetLocale, context)) {
 				const promotionBreakIndex = findLastLatinPromotionBreakIndex(buffer);
 				if (promotionBreakIndex === -1) {
 					currentLocale = targetLocale;
@@ -1055,7 +1042,6 @@ function mergeAdjacentChunks(chunks) {
 	merged.push(last);
 	return merged;
 }
-
 //#endregion
 //#region src/wc/wc.ts
 function wordCounter(text, options = {}) {
@@ -1109,11 +1095,11 @@ function wordCounter(text, options = {}) {
 	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);
+		return sum + getNonWordTotal$1(chunk.nonWords);
 	}, 0) : 0;
 	const total = analyzed.reduce((sum, chunk) => {
 		let chunkTotal = chunk.words;
-		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal(chunk.nonWords);
+		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal$1(chunk.nonWords);
 		return sum + chunkTotal;
 	}, 0);
 	const counts = collectNonWords ? {
@@ -1141,7 +1127,7 @@ function wordCounter(text, options = {}) {
 		breakdown: {
 			mode,
 			items: aggregateByLocale(analyzed),
-			nonWords: collectNonWordsAggregate(analyzed, collectNonWords)
+			nonWords: collectNonWordsAggregate$1(analyzed, collectNonWords)
 		}
 	};
 	return {
@@ -1158,10 +1144,10 @@ function wordCounter(text, options = {}) {
 		}
 	};
 }
-function getNonWordTotal(nonWords) {
+function getNonWordTotal$1(nonWords) {
 	return nonWords.counts.emoji + nonWords.counts.symbols + nonWords.counts.punctuation + (nonWords.counts.whitespace ?? 0);
 }
-function collectNonWordsAggregate(analyzed, enabled) {
+function collectNonWordsAggregate$1(analyzed, enabled) {
 	if (!enabled) return;
 	const collection = createNonWordCollection();
 	for (const chunk of analyzed) {
@@ -1170,14 +1156,12 @@ function collectNonWordsAggregate(analyzed, enabled) {
 	}
 	return collection;
 }
-
 //#endregion
 //#region src/wc/index.ts
 var wc_default = wordCounter;
-
 //#endregion
 //#region src/markdown/section-count.ts
-function normalizeText(value) {
+function normalizeText$1(value) {
 	if (value == null) return "";
 	if (typeof value === "string") return value;
 	if (typeof value === "number" || typeof value === "boolean") return String(value);
@@ -1187,10 +1171,10 @@ function normalizeText(value) {
 		return String(value);
 	}
 }
-function buildPerKeyItems(data, mode, options) {
+function buildPerKeyItems$1(data, mode, options) {
 	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
 	return Object.entries(data).map(([key, value]) => {
-		const valueText = normalizeText(value);
+		const valueText = normalizeText$1(value);
 		return {
 			name: key,
 			source: "frontmatter",
@@ -1198,14 +1182,14 @@ function buildPerKeyItems(data, mode, options) {
 		};
 	});
 }
-function buildSingleItem(name, text, mode, options, source) {
+function buildSingleItem$1(name, text, mode, options, source) {
 	return [{
 		name,
 		source,
 		result: wc_default(text, options)
 	}];
 }
-function sumTotals(items) {
+function sumTotals$1(items) {
 	return items.reduce((sum, item) => sum + item.result.total, 0);
 }
 function countSections(input, section, options = {}) {
@@ -1227,11 +1211,188 @@ function countSections(input, section, options = {}) {
 	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")];
+	if (section === "frontmatter") items = buildSingleItem$1("frontmatter", frontmatterText, mode, options, "frontmatter");
+	else if (section === "content") items = buildSingleItem$1("content", contentText, mode, options, "content");
+	else if (section === "split") items = [...buildSingleItem$1("frontmatter", frontmatterText, mode, options, "frontmatter"), ...buildSingleItem$1("content", contentText, mode, options, "content")];
+	else if (section === "per-key") items = buildPerKeyItems$1(parsed.data, mode, options);
+	else if (section === "split-per-key") items = [...buildPerKeyItems$1(parsed.data, mode, options), ...buildSingleItem$1("content", contentText, mode, options, "content")];
+	return {
+		section,
+		total: sumTotals$1(items),
+		frontmatterType: parsed.frontmatterType,
+		items
+	};
+}
+//#endregion
+//#region src/detector/none.ts
+async function wordCounterWithRegexDetector(text, options = {}) {
+	return wc_default(text, options);
+}
+async function countSectionsWithRegexDetector(input, section, options = {}) {
+	return countSections(input, section, options);
+}
+//#endregion
+//#region src/detector/result-builder.ts
+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;
+}
+function buildWordCounterResultFromChunks(chunks, options = {}) {
+	const mode = resolveMode(options.mode, "chunk");
+	const collectNonWords = Boolean(options.nonWords);
+	const includeWhitespace = Boolean(options.includeWhitespace);
+	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
+			}))
+		}
+	};
+}
+//#endregion
+//#region src/detector/sections.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);
+	}
+}
+async function buildPerKeyItems(data, options) {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+	return Promise.all(Object.entries(data).map(async ([key, value]) => {
+		const valueText = normalizeText(value);
+		return {
+			name: key,
+			source: "frontmatter",
+			result: await wordCounterWithDetector(valueText ? `${key}: ${valueText}` : key, options)
+		};
+	}));
+}
+async function buildSingleItem(name, text, options, source) {
+	return [{
+		name,
+		source,
+		result: await wordCounterWithDetector(text, options)
+	}];
+}
+function sumTotals(items) {
+	return items.reduce((sum, item) => sum + item.result.total, 0);
+}
+async function countSectionsWithResolvedDetector(input, section, options = {}) {
+	options.mode;
+	if (section === "all") {
+		const result = await wordCounterWithDetector(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 = await buildSingleItem("frontmatter", frontmatterText, options, "frontmatter");
+	else if (section === "content") items = await buildSingleItem("content", contentText, options, "content");
+	else if (section === "split") items = [...await buildSingleItem("frontmatter", frontmatterText, options, "frontmatter"), ...await buildSingleItem("content", contentText, options, "content")];
+	else if (section === "per-key") items = await buildPerKeyItems(parsed.data, options);
+	else if (section === "split-per-key") items = [...await buildPerKeyItems(parsed.data, options), ...await buildSingleItem("content", contentText, options, "content")];
 	return {
 		section,
 		total: sumTotals(items),
@@ -1239,7 +1400,207 @@ function countSections(input, section, options = {}) {
 		items
 	};
 }
-
+const LATIN_WASM_MIN_CONFIDENCE = .75;
+const HANI_WASM_MIN_CONFIDENCE = .9;
+const LATIN_SCRIPT_REGEX = /\p{Script=Latin}/u;
+const HAN_SCRIPT_REGEX = /\p{Script=Han}/u;
+const DETECTOR_ROUTE_POLICIES = {
+	[DEFAULT_LOCALE]: {
+		routeTag: DEFAULT_LOCALE,
+		minScriptChars: 24,
+		minConfidence: LATIN_WASM_MIN_CONFIDENCE,
+		requireReliable: true
+	},
+	[DEFAULT_HAN_TAG]: {
+		routeTag: DEFAULT_HAN_TAG,
+		minScriptChars: 12,
+		minConfidence: HANI_WASM_MIN_CONFIDENCE,
+		requireReliable: true
+	}
+};
+function isAmbiguousDetectorRoute(locale) {
+	return locale === "und-Latn" || locale === "und-Hani";
+}
+function countScriptBearingCharsForRoute(text, routeTag) {
+	const matcher = routeTag === "und-Hani" ? HAN_SCRIPT_REGEX : LATIN_SCRIPT_REGEX;
+	let count = 0;
+	for (const char of text) if (matcher.test(char)) count += 1;
+	return count;
+}
+function shouldRunWasmDetector(text, routeTag) {
+	const policy = DETECTOR_ROUTE_POLICIES[routeTag];
+	return countScriptBearingCharsForRoute(text, routeTag) >= policy.minScriptChars;
+}
+function normalizeDetectorSampleForRoute(text, routeTag) {
+	const matcher = routeTag === "und-Hani" ? HAN_SCRIPT_REGEX : LATIN_SCRIPT_REGEX;
+	return [...text].map((char) => {
+		if (matcher.test(char)) return char;
+		if (/\s/u.test(char)) return " ";
+		return " ";
+	}).join("").replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/detector/whatlang-wasm.ts
+const GENERATED_FOLDER_NAME = "wasm-language-detector";
+const GENERATED_MODULE_FILE = "language_detector.js";
+const MAX_SEARCH_DEPTH = 8;
+const requireFromHere = createRequire(import.meta.url);
+const WASM_DETECTOR_RUNTIME_UNAVAILABLE_MESSAGE = "WASM detector runtime is unavailable. Run `bun run build:wasm` to generate it.";
+let modulePromise = null;
+function resolveCandidateModulePaths() {
+	const moduleDir = dirname(fileURLToPath(import.meta.url));
+	const candidates = /* @__PURE__ */ new Set();
+	let currentDir = moduleDir;
+	for (let depth = 0; depth < MAX_SEARCH_DEPTH; depth += 1) {
+		candidates.add(join(currentDir, GENERATED_FOLDER_NAME, GENERATED_MODULE_FILE));
+		candidates.add(join(currentDir, "generated", GENERATED_FOLDER_NAME, GENERATED_MODULE_FILE));
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return [...candidates];
+}
+function resolveWhatlangWasmModulePath() {
+	for (const candidate of resolveCandidateModulePaths()) if (existsSync(candidate)) return candidate;
+	throw new Error(WASM_DETECTOR_RUNTIME_UNAVAILABLE_MESSAGE);
+}
+async function loadWhatlangWasmModule() {
+	if (!modulePromise) modulePromise = (async () => {
+		return requireFromHere(resolveWhatlangWasmModulePath());
+	})();
+	return modulePromise;
+}
+async function detectWithWhatlangWasm(text, routeTag) {
+	return (await loadWhatlangWasmModule()).detect_language(text, routeTag);
+}
+//#endregion
+//#region src/detector/whatlang-map.ts
+const LATIN_LANGUAGE_TAGS = {
+	cat: "ca",
+	ces: "cs",
+	dan: "da",
+	deu: "de",
+	eng: "en",
+	fin: "fi",
+	fra: "fr",
+	hun: "hu",
+	ita: "it",
+	lat: "la",
+	nld: "nl",
+	pol: "pl",
+	por: "pt",
+	ron: "ro",
+	spa: "es",
+	swe: "sv",
+	tur: "tr"
+};
+const HANI_LANGUAGE_TAGS = {
+	cmn: "zh",
+	jpn: "ja"
+};
+function hasSupportedScript(result, routeTag) {
+	if (routeTag === "und-Latn") return result.script === "Latin";
+	return result.script === "Mandarin";
+}
+function remapLanguageTag(lang, routeTag) {
+	if (routeTag === "und-Latn") return LATIN_LANGUAGE_TAGS[lang];
+	return HANI_LANGUAGE_TAGS[lang];
+}
+function remapWhatlangResult(result, routeTag) {
+	if (!hasSupportedScript(result, routeTag)) return null;
+	const tag = remapLanguageTag(result.lang, routeTag);
+	if (!tag) return null;
+	return {
+		tag,
+		confidence: result.confidence,
+		reliable: result.reliable,
+		source: "wasm"
+	};
+}
+function getDetectorFallbackTag(routeTag) {
+	return routeTag === "und-Hani" ? DEFAULT_HAN_TAG : DEFAULT_LOCALE;
+}
+//#endregion
+//#region src/detector/wasm.ts
+function shouldAcceptDetectorTag(routeTag, confidence, reliable) {
+	const policy = DETECTOR_ROUTE_POLICIES[routeTag];
+	if (policy.requireReliable && reliable !== true) return false;
+	if (confidence === void 0) return false;
+	return confidence >= policy.minConfidence;
+}
+function buildDetectorWindows(chunks) {
+	const windows = [];
+	for (let index = 0; index < chunks.length; index += 1) {
+		const chunk = chunks[index];
+		if (!chunk || !isAmbiguousDetectorRoute(chunk.locale)) continue;
+		const previousWindow = windows[windows.length - 1];
+		if (previousWindow && previousWindow.routeTag === chunk.locale && previousWindow.endIndex === index - 1) {
+			previousWindow.endIndex = index;
+			previousWindow.text += chunk.text;
+			continue;
+		}
+		windows.push({
+			routeTag: chunk.locale,
+			startIndex: index,
+			endIndex: index,
+			text: chunk.text
+		});
+	}
+	return windows;
+}
+async function resolveWindowLocale(window) {
+	if (!shouldRunWasmDetector(window.text, window.routeTag)) return window.routeTag;
+	const rawResult = await detectWithWhatlangWasm(window.text, window.routeTag);
+	const rawRemapped = rawResult ? remapWhatlangResult(rawResult, window.routeTag) : null;
+	const normalizedSample = normalizeDetectorSampleForRoute(window.text, window.routeTag);
+	const normalizedResult = normalizedSample.length > 0 && normalizedSample !== window.text ? await detectWithWhatlangWasm(normalizedSample, window.routeTag) : null;
+	const normalizedRemapped = normalizedResult ? remapWhatlangResult(normalizedResult, window.routeTag) : null;
+	const candidates = [rawRemapped, normalizedRemapped].filter((value) => value !== null);
+	if (candidates.length === 0) return getDetectorFallbackTag(window.routeTag);
+	const strongestCandidate = candidates.reduce((best, current) => {
+		if (!best) return current;
+		return (current.confidence ?? 0) > (best.confidence ?? 0) ? current : best;
+	}, candidates[0]);
+	if (strongestCandidate && shouldAcceptDetectorTag(window.routeTag, strongestCandidate.confidence, strongestCandidate.reliable)) return strongestCandidate.tag;
+	if (window.routeTag === "und-Latn" && rawRemapped && normalizedRemapped && rawRemapped.tag === normalizedRemapped.tag) {
+		if (Math.max(rawRemapped.confidence ?? 0, normalizedRemapped.confidence ?? 0) >= .7) return rawRemapped.tag;
+	}
+	return getDetectorFallbackTag(window.routeTag);
+}
+async function segmentTextByLocaleWithWasmDetector(text, options = {}) {
+	const chunks = segmentTextByLocale(text, options);
+	const resolved = [...chunks];
+	const windows = buildDetectorWindows(chunks);
+	for (const window of windows) {
+		const resolvedLocale = await resolveWindowLocale(window);
+		for (let index = window.startIndex; index <= window.endIndex; index += 1) {
+			const chunk = resolved[index];
+			if (!chunk) continue;
+			resolved[index] = {
+				...chunk,
+				locale: resolvedLocale
+			};
+		}
+	}
+	return resolved;
+}
+async function wordCounterWithWasmDetector(text, options = {}) {
+	return buildWordCounterResultFromChunks(await segmentTextByLocaleWithWasmDetector(text, options), options);
+}
+async function countSectionsWithWasmDetector(input, section, options = {}) {
+	return countSectionsWithResolvedDetector(input, section, options);
+}
+function resolveDetectorMode(mode) {
+	return mode ?? "regex";
+}
+async function wordCounterWithDetector(text, options = {}) {
+	if (resolveDetectorMode(options.detector) === "wasm") return wordCounterWithWasmDetector(text, options);
+	return wordCounterWithRegexDetector(text, options);
+}
+async function countSectionsWithDetector(input, section, options = {}) {
+	if (resolveDetectorMode(options.detector) === "wasm") return countSectionsWithWasmDetector(input, section, options);
+	return countSectionsWithRegexDetector(input, section, options);
+}
 //#endregion
 //#region src/cli/batch/aggregate.ts
 function stripCollectorSegmentsFromWordCounterResult(result) {
@@ -1256,7 +1617,6 @@ function compactCollectorSegmentsInCountResult(result) {
 	}
 	stripCollectorSegmentsFromWordCounterResult(result);
 }
-
 //#endregion
 //#region src/cli/path/load.ts
 function isProbablyBinary(buffer) {
@@ -1273,7 +1633,6 @@ function isProbablyBinary(buffer) {
 	}
 	return suspicious / sampleSize > .3;
 }
-
 //#endregion
 //#region src/cli/batch/jobs/worker/count-worker.ts
 const config = workerData;
@@ -1335,7 +1694,13 @@ parentPort.on("message", async (message) => {
 	}
 	try {
 		const content = buffer.toString("utf8");
-		const result = config.section === "all" ? wc_default(content, config.wcOptions) : countSections(content, config.section, config.wcOptions);
+		const result = config.detectorMode === "regex" ? config.section === "all" ? wc_default(content, config.wcOptions) : countSections(content, config.section, config.wcOptions) : config.section === "all" ? await wordCounterWithDetector(content, {
+			...config.wcOptions,
+			detector: config.detectorMode
+		}) : await countSectionsWithDetector(content, config.section, {
+			...config.wcOptions,
+			detector: config.detectorMode
+		});
 		if (!config.preserveCollectorSegments) compactCollectorSegmentsInCountResult(result);
 		const response = {
 			type: "result",
@@ -1364,7 +1729,7 @@ parentPort.on("message", async (message) => {
 		parentPort?.postMessage(response);
 	}
 });
-
 //#endregion
-export {  };
+export {};
+
 //# sourceMappingURL=count-worker.mjs.map