@dev-pi2pie/word-counter 0.0.6

package/dist/cjs/index.cjs

@@ -0,0 +1,754 @@
+let yaml = require("yaml");
+
+//#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;
+}
+function countWordsForLocale(text, locale) {
+	const segmenter = getSegmenter(locale);
+	let count = 0;
+	for (const segment of segmenter.segment(text)) if (segment.isWordLike) count++;
+	return count;
+}
+
+//#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 = (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$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 src/utils/show-singular-or-plural-word.ts
+function showSingularOrPluralWord(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+
+//#endregion
+//#region src/index.cjs.ts
+const cjsExports = Object.assign(wc_default, {
+	default: wc_default,
+	wordCounter: wc_default,
+	countWordsForLocale,
+	segmentTextByLocale,
+	parseMarkdown,
+	countSections,
+	showSingularOrPluralWord
+});
+module.exports = cjsExports;
+
+//#endregion
+//# sourceMappingURL=index.cjs.map