@ls-stack/server-i18n 0.0.0-stage → 0.6.0

package/dist/cli.mjs

@@ -0,0 +1,2327 @@
+import { n as __require, t as __commonJSMin } from "./chunk-CQZEQomT.mjs";
+import { _ as string, m as object, o as array, p as number } from "./schemas-BfUoDuyI.mjs";
+import fs from "node:fs";
+import path, { join, relative, resolve, sep } from "node:path";
+import { readFileSync, writeFileSync } from "fs";
+import path$1 from "path";
+import ts from "@typescript/typescript6";
+import { lstat, readdir, realpath, stat } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { consoleFmt } from "@ls-stack/utils/consoleFmt";
+import { typeFlag } from "type-flag";
+
+//#region ../core/src/cli/ai-logger.ts
+const MAX_LOG_FILES = 10;
+function getAiLogsFolder() {
+	return process.env["I18N_AI_LOGS_FOLDER"] || null;
+}
+function cleanupOldLogs(folder) {
+	const files = fs.readdirSync(folder).filter((f) => f.startsWith("ai-log-") && f.endsWith(".json")).sort();
+	while (files.length >= MAX_LOG_FILES) {
+		const oldest = files.shift();
+		if (oldest) fs.unlinkSync(path.join(folder, oldest));
+	}
+}
+function logAiGeneration(data) {
+	const folder = getAiLogsFolder();
+	if (!folder) return null;
+	fs.mkdirSync(folder, { recursive: true });
+	cleanupOldLogs(folder);
+	const filename = `ai-log-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`;
+	const filepath = path.join(folder, filename);
+	fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
+	console.info(`AI log saved to: ${filepath}`);
+	return filepath;
+}
+
+//#endregion
+//#region ../core/src/cli/ai-translator.ts
+function buildTranslationsSchema() {
+	return object({
+		strings: array(object({
+			key: string(),
+			translation: string()
+		})),
+		plurals: array(object({
+			key: string(),
+			translation: object({
+				zero: string().nullable(),
+				one: string().nullable(),
+				plus2: string(),
+				many: string().nullable(),
+				manyLimit: number().nullable()
+			})
+		}))
+	});
+}
+function buildPrompt(contexts) {
+	const lines = [
+		"<role>",
+		"You are a professional translator specializing in i18n localization.",
+		"</role>",
+		"",
+		"<instructions>",
+		"- Translate the provided keys to the specified target locale",
+		"- Keep placeholders like {1}, {2}, # exactly as they appear",
+		"- For plural translations, provide an object with one and plus2 forms",
+		"- Use similar existing translations as style/terminology reference",
+		"- Respond with a JSON object containing two arrays: \"strings\" and \"plurals\"",
+		"- Each item in \"strings\" has \"key\" (the original source key) and \"translation\" (the translated string)",
+		"- Each item in \"plurals\" has \"key\" (the original source key) and \"translation\" (an object with plural forms)",
+		"</instructions>",
+		"",
+		"<plural-format>",
+		"Plural translations must be objects with these keys:",
+		"  one: text when count is 1",
+		"  plus2: text when count is 2 or more (use # as the number placeholder)",
+		"",
+		"English example: { \"one\": \"1 item\", \"plus2\": \"# items\" }",
+		"Portuguese example: { \"one\": \"1 item\", \"plus2\": \"# itens\" }",
+		"</plural-format>",
+		"",
+		"<keys>"
+	];
+	for (const ctx of contexts) {
+		lines.push("");
+		lines.push(`Key: "${ctx.sourceKey}"`);
+		lines.push(`Locale: ${ctx.targetLocale}`);
+		lines.push(`Type: ${ctx.isPlural ? "plural" : "string"}`);
+		if (ctx.similarTranslations.length > 0) {
+			lines.push("Similar translations:");
+			for (const match of ctx.similarTranslations.slice(0, 3)) {
+				const translationValue = typeof match.translation === "string" ? match.translation : JSON.stringify(match.translation);
+				lines.push(`  "${match.key}" → ${translationValue}`);
+			}
+		}
+	}
+	lines.push("</keys>");
+	return lines.join("\n");
+}
+function parseGeneratedObject(obj, contexts) {
+	const results = /* @__PURE__ */ new Map();
+	const validKeys = new Set(contexts.map((ctx) => ctx.sourceKey));
+	const pluralKeys = new Set(contexts.filter((ctx) => ctx.isPlural).map((ctx) => ctx.sourceKey));
+	for (const item of obj.strings) {
+		if (!validKeys.has(item.key) || pluralKeys.has(item.key)) continue;
+		results.set(item.key, {
+			type: "string",
+			value: item.translation
+		});
+	}
+	for (const item of obj.plurals) {
+		if (!validKeys.has(item.key) || !pluralKeys.has(item.key)) continue;
+		results.set(item.key, {
+			type: "plural",
+			value: {
+				zero: item.translation.zero ?? void 0,
+				one: item.translation.one ?? void 0,
+				"+2": item.translation.plus2,
+				many: item.translation.many ?? void 0,
+				manyLimit: item.translation.manyLimit ?? void 0
+			}
+		});
+	}
+	return results;
+}
+function createAITranslator(provider, model) {
+	return { async translateBatch(contexts) {
+		if (contexts.length === 0) return { translations: /* @__PURE__ */ new Map() };
+		const ai = await import("./dist-BCX2gdnz.mjs");
+		let languageModel;
+		if (model) languageModel = model;
+		else if (provider === "google") {
+			const { google } = await import("./dist-CrzKI7n8.mjs");
+			languageModel = google("gemini-2.5-flash");
+		} else {
+			const { openai } = await import("./dist-Dtrz_N2T.mjs");
+			languageModel = openai("gpt-5-mini");
+		}
+		const prompt = buildPrompt(contexts);
+		const schema = buildTranslationsSchema();
+		const startTime = Date.now();
+		try {
+			const result = await ai.generateText({
+				model: languageModel,
+				output: ai.Output.object({ schema }),
+				prompt
+			});
+			const output = result.output;
+			if (!output) {
+				logAiGeneration({
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					provider,
+					model: result.response.modelId,
+					prompt,
+					contexts,
+					results: [],
+					usage: void 0,
+					durationMs: Date.now() - startTime,
+					error: void 0
+				});
+				return { translations: /* @__PURE__ */ new Map() };
+			}
+			const { inputTokens, outputTokens, totalTokens } = result.usage;
+			const usage = inputTokens !== void 0 && outputTokens !== void 0 && totalTokens !== void 0 ? {
+				inputTokens,
+				outputTokens,
+				totalTokens
+			} : void 0;
+			const translations = parseGeneratedObject(output, contexts);
+			logAiGeneration({
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				provider,
+				model: result.response.modelId,
+				prompt,
+				contexts,
+				results: contexts.map((ctx) => ({
+					sourceKey: ctx.sourceKey,
+					result: translations.get(ctx.sourceKey)
+				})),
+				usage,
+				durationMs: Date.now() - startTime,
+				error: void 0
+			});
+			return {
+				translations,
+				model: result.response.modelId,
+				usage
+			};
+		} catch (err) {
+			logAiGeneration({
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				provider,
+				model: void 0,
+				prompt,
+				contexts,
+				results: [],
+				usage: void 0,
+				durationMs: Date.now() - startTime,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		}
+	} };
+}
+
+//#endregion
+//#region ../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.3",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}));
+
+//#endregion
+//#region ../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$1 = __require("fs");
+	const path$2 = __require("path");
+	const os = __require("os");
+	const crypto = __require("crypto");
+	const version = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version}] ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs$1.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path$2.resolve(process.cwd(), ".env.vault");
+		if (fs$1.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$2.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path$2.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$1.readFileSync(path, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`Failed to load ${path} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$2.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+//#endregion
+//#region ../core/src/cli/loadEnvFiles.ts
+var import_main = require_main();
+function loadEnvFiles() {
+	(0, import_main.config)({
+		path: [".env.local", ".env"],
+		quiet: true
+	});
+}
+
+//#endregion
+//#region ../core/src/cli/findMissingTranslations.ts
+function getHashFromTemplate(template) {
+	if (ts.isNoSubstitutionTemplateLiteral(template)) return template.text;
+	if (ts.isTemplateExpression(template)) {
+		let hash = "";
+		hash += template.head.text;
+		template.templateSpans.forEach((span, i) => {
+			hash += `{${i + 1}}${span.literal.text}`;
+		});
+		return hash;
+	}
+	return null;
+}
+function isPrimitiveInterpolation(node) {
+	if (ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return true;
+	if (ts.isIdentifier(node)) return true;
+	if (ts.isPropertyAccessExpression(node)) return true;
+	if (ts.isCallExpression(node)) return true;
+	if (ts.isConditionalExpression(node)) return isPrimitiveInterpolation(node.whenTrue) && isPrimitiveInterpolation(node.whenFalse);
+	if (ts.isBinaryExpression(node)) return isPrimitiveInterpolation(node.left) && isPrimitiveInterpolation(node.right);
+	if (ts.isParenthesizedExpression(node)) return isPrimitiveInterpolation(node.expression);
+	if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) return false;
+	if (ts.isJsxFragment(node)) return false;
+	return true;
+}
+function hasOnlyPrimitiveInterpolations(template) {
+	if (ts.isNoSubstitutionTemplateLiteral(template)) return true;
+	if (ts.isTemplateExpression(template)) {
+		for (const span of template.templateSpans) if (!isPrimitiveInterpolation(span.expression)) return false;
+		return true;
+	}
+	return true;
+}
+function getI18nUsagesInCode(fileName, code) {
+	if (!(code.includes("i18n") || code.includes("__`") || code.includes("__p(") || code.includes("__jsx`") || code.includes("__pjsx("))) return {
+		pluralTranslations: [],
+		stringTranslations: [],
+		jsxStringTranslations: /* @__PURE__ */ new Set(),
+		jsxPluralTranslations: /* @__PURE__ */ new Set(),
+		primitiveOnlyJsx: /* @__PURE__ */ new Set(),
+		usageMap: /* @__PURE__ */ new Map()
+	};
+	const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, void 0, ts.ScriptKind.TSX);
+	const pluralTranslations = /* @__PURE__ */ new Set();
+	const stringTranslations = /* @__PURE__ */ new Set();
+	const jsxStringTranslations = /* @__PURE__ */ new Set();
+	const jsxPluralTranslations = /* @__PURE__ */ new Set();
+	const primitiveOnlyJsx = /* @__PURE__ */ new Set();
+	const usageMap = /* @__PURE__ */ new Map();
+	function addUsage(hash, isJsx, isPlural, onlyPrimitives, node) {
+		const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+		const location = {
+			file: fileName,
+			line: line + 1,
+			column: character + 1
+		};
+		const existing = usageMap.get(hash);
+		if (existing) {
+			existing.locations.push(location);
+			if (!onlyPrimitives) existing.hasOnlyPrimitiveInterpolations = false;
+		} else usageMap.set(hash, {
+			hash,
+			isJsx,
+			isPlural,
+			hasOnlyPrimitiveInterpolations: onlyPrimitives,
+			locations: [location]
+		});
+	}
+	function checkNode(node) {
+		if (ts.isTaggedTemplateExpression(node)) {
+			const tteNode = node;
+			const isTranslationFn = (id) => {
+				return ts.idText(id) === "__";
+			};
+			const isJsxTranslationFn = (id) => {
+				return ts.idText(id) === "__jsx";
+			};
+			const isPluralTranslationFn = (id) => {
+				return ts.idText(id) === "__p";
+			};
+			const isJsxPluralTranslationFn = (id) => {
+				return ts.idText(id) === "__pjsx";
+			};
+			if (ts.isIdentifier(tteNode.tag) && isTranslationFn(tteNode.tag) || ts.isPropertyAccessExpression(tteNode.tag) && isTranslationFn(tteNode.tag.name)) {
+				const template = tteNode.template;
+				const hash = getHashFromTemplate(template);
+				if (hash) {
+					stringTranslations.add(hash);
+					addUsage(hash, false, false, true, node);
+				}
+			} else if (ts.isIdentifier(tteNode.tag) && isJsxTranslationFn(tteNode.tag) || ts.isPropertyAccessExpression(tteNode.tag) && isJsxTranslationFn(tteNode.tag.name)) {
+				const template = tteNode.template;
+				const hash = getHashFromTemplate(template);
+				if (hash) {
+					stringTranslations.add(hash);
+					jsxStringTranslations.add(hash);
+					const onlyPrimitives = hasOnlyPrimitiveInterpolations(template);
+					if (onlyPrimitives) primitiveOnlyJsx.add(hash);
+					addUsage(hash, true, false, onlyPrimitives, node);
+				}
+			} else if (ts.isCallExpression(tteNode.tag)) {
+				if (ts.isIdentifier(tteNode.tag.expression) && isPluralTranslationFn(tteNode.tag.expression) || ts.isPropertyAccessExpression(tteNode.tag.expression) && isPluralTranslationFn(tteNode.tag.expression.name)) {
+					const hash = getHashFromTemplate(tteNode.template);
+					if (hash) {
+						pluralTranslations.add(hash);
+						addUsage(hash, false, true, true, node);
+					}
+				} else if (ts.isIdentifier(tteNode.tag.expression) && isJsxPluralTranslationFn(tteNode.tag.expression) || ts.isPropertyAccessExpression(tteNode.tag.expression) && isJsxPluralTranslationFn(tteNode.tag.expression.name)) {
+					const hash = getHashFromTemplate(tteNode.template);
+					if (hash) {
+						pluralTranslations.add(hash);
+						jsxPluralTranslations.add(hash);
+						const onlyPrimitives = hasOnlyPrimitiveInterpolations(tteNode.template);
+						if (onlyPrimitives) primitiveOnlyJsx.add(hash);
+						addUsage(hash, true, true, onlyPrimitives, node);
+					}
+				}
+			}
+		}
+		ts.forEachChild(node, checkNode);
+	}
+	checkNode(sourceFile);
+	return {
+		pluralTranslations: Array.from(pluralTranslations),
+		stringTranslations: Array.from(stringTranslations),
+		jsxStringTranslations,
+		jsxPluralTranslations,
+		primitiveOnlyJsx,
+		usageMap
+	};
+}
+
+//#endregion
+//#region ../core/src/cli/similarity.ts
+const NUM_TOKEN = "__num__";
+const NUM_TOKEN_PLACEHOLDER = "numtoken";
+function normalizePlaceholders(text) {
+	let normalized = text.replace(/\{[^}]*\}/g, ` ${NUM_TOKEN} `);
+	normalized = normalized.replace(/#/g, ` ${NUM_TOKEN} `);
+	normalized = normalized.replace(/\d+/g, ` ${NUM_TOKEN} `);
+	return normalized;
+}
+function splitCamelCase(text) {
+	return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+}
+function tokenizeWords(text) {
+	let normalized = normalizePlaceholders(text);
+	normalized = splitCamelCase(normalized);
+	normalized = normalized.toLowerCase();
+	normalized = normalized.replaceAll(NUM_TOKEN, ` ${NUM_TOKEN_PLACEHOLDER} `);
+	normalized = normalized.replace(/[^a-z0-9]+/g, " ");
+	const tokens = /* @__PURE__ */ new Set();
+	for (const rawToken of normalized.trim().split(/\s+/)) {
+		if (!rawToken) continue;
+		const token = rawToken === NUM_TOKEN_PLACEHOLDER ? NUM_TOKEN : rawToken;
+		if (token.length >= 2 || token === NUM_TOKEN) tokens.add(token);
+	}
+	return tokens;
+}
+function normalizeForGrams(text) {
+	let normalized = normalizePlaceholders(text);
+	normalized = splitCamelCase(normalized);
+	normalized = normalized.toLowerCase();
+	normalized = normalized.replaceAll(NUM_TOKEN, NUM_TOKEN_PLACEHOLDER);
+	normalized = normalized.replace(/[^a-z0-9]+/g, "");
+	return normalized;
+}
+function tokenizeGrams(text) {
+	const normalized = normalizeForGrams(text);
+	const tokens = /* @__PURE__ */ new Set();
+	if (normalized.length >= 3) for (let i = 0; i <= normalized.length - 3; i++) tokens.add(`ng:${normalized.slice(i, i + 3)}`);
+	else if (normalized.length === 2) tokens.add(`ng2:${normalized}`);
+	else if (normalized.length === 1) tokens.add(`ng1:${normalized}`);
+	return tokens;
+}
+function jaccardSimilarity(set1, set2) {
+	if (set1.size === 0 && set2.size === 0) return 0;
+	let intersection = 0;
+	for (const item of set1) if (set2.has(item)) intersection++;
+	const union = set1.size + set2.size - intersection;
+	return union === 0 ? 0 : intersection / union;
+}
+function commonPrefixScoreNormalized(a, b) {
+	let prefixLen = 0;
+	const minLen = Math.min(a.length, b.length);
+	for (let i = 0; i < minLen; i++) if (a[i] === b[i]) prefixLen++;
+	else break;
+	const maxLen = Math.max(a.length, b.length);
+	return maxLen === 0 ? 0 : prefixLen / maxLen;
+}
+function getTokenWeight(token, idf, maxIdf) {
+	return idf.get(token) ?? maxIdf;
+}
+function sumTokenWeights(tokens, idf, maxIdf) {
+	let sum = 0;
+	for (const token of tokens) sum += getTokenWeight(token, idf, maxIdf);
+	return sum;
+}
+function weightedJaccard(set1, set2, idf, maxIdf, set1WeightSum, set2WeightSum) {
+	if (set1.size === 0 && set2.size === 0) return 0;
+	const weightSum1 = set1WeightSum ?? sumTokenWeights(set1, idf, maxIdf);
+	const weightSum2 = set2WeightSum ?? sumTokenWeights(set2, idf, maxIdf);
+	let intersectionWeight = 0;
+	if (set1.size <= set2.size) {
+		for (const token of set1) if (set2.has(token)) intersectionWeight += getTokenWeight(token, idf, maxIdf);
+	} else for (const token of set2) if (set1.has(token)) intersectionWeight += getTokenWeight(token, idf, maxIdf);
+	const union = weightSum1 + weightSum2 - intersectionWeight;
+	return union === 0 ? 0 : intersectionWeight / union;
+}
+function toTranslationText(translation) {
+	if (typeof translation === "string") return translation;
+	const parts = [];
+	if (translation.zero) parts.push(translation.zero);
+	if (translation.one) parts.push(translation.one);
+	if (translation["+2"]) parts.push(translation["+2"]);
+	if (translation.many) parts.push(translation.many);
+	return parts.join(" ");
+}
+function createSimilarityIndex(existingTranslations) {
+	const entries = [];
+	const tokenToEntries = /* @__PURE__ */ new Map();
+	const documentFrequency = /* @__PURE__ */ new Map();
+	for (const [key, translation] of existingTranslations) {
+		const wordTokens = tokenizeWords(key);
+		const gramTokens = tokenizeGrams(key);
+		const normalizedKey = normalizeForGrams(key);
+		const translationTokens = tokenizeWords(toTranslationText(translation));
+		const entryIndex = entries.length;
+		for (const token of wordTokens) {
+			documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
+			const existing = tokenToEntries.get(token);
+			if (existing) existing.push(entryIndex);
+			else tokenToEntries.set(token, [entryIndex]);
+		}
+		entries.push({
+			key,
+			translation,
+			wordTokens,
+			gramTokens,
+			normalizedKey,
+			wordWeightSum: 0,
+			translationTokens
+		});
+	}
+	const totalDocuments = entries.length;
+	const idf = /* @__PURE__ */ new Map();
+	for (const [token, count] of documentFrequency) idf.set(token, Math.log((totalDocuments + 1) / (count + 1)) + 1);
+	const maxIdf = Math.log((totalDocuments + 1) / 1) + 1;
+	for (const entry of entries) entry.wordWeightSum = sumTokenWeights(entry.wordTokens, idf, maxIdf);
+	return {
+		entries,
+		tokenToEntries,
+		idf,
+		maxIdf
+	};
+}
+function findSimilarFromIndex(index, sourceKey, maxResults = 5) {
+	if (index.entries.length === 0) return [];
+	const sourceTokens = tokenizeWords(sourceKey);
+	const sourceGrams = tokenizeGrams(sourceKey);
+	const sourceNormalized = normalizeForGrams(sourceKey);
+	const sourceWeightSum = sumTokenWeights(sourceTokens, index.idf, index.maxIdf);
+	let candidateIndexes = [];
+	if (sourceTokens.size > 0) {
+		const candidateSet = /* @__PURE__ */ new Set();
+		for (const token of sourceTokens) {
+			const matches = index.tokenToEntries.get(token);
+			if (!matches) continue;
+			for (const entryIndex of matches) candidateSet.add(entryIndex);
+		}
+		candidateIndexes = candidateSet.size === 0 ? index.entries.map((_entry, idx) => idx) : Array.from(candidateSet);
+	} else candidateIndexes = index.entries.map((_entry, idx) => idx);
+	const scored = [];
+	for (const entryIndex of candidateIndexes) {
+		const entry = index.entries[entryIndex];
+		if (!entry) continue;
+		const wordScore = weightedJaccard(sourceTokens, entry.wordTokens, index.idf, index.maxIdf, sourceWeightSum, entry.wordWeightSum);
+		const gramScore = jaccardSimilarity(sourceGrams, entry.gramTokens);
+		const prefixScore = commonPrefixScoreNormalized(sourceNormalized, entry.normalizedKey);
+		const keyScore = wordScore * .65 + gramScore * .25 + prefixScore * .1;
+		if (keyScore >= .12) scored.push({
+			index: entryIndex,
+			keyScore
+		});
+	}
+	if (scored.length === 0) return [];
+	scored.sort((a, b) => b.keyScore - a.keyScore);
+	const topCount = Math.min(20, scored.length);
+	const topEntry = scored[0];
+	if (!topEntry) return [];
+	const referenceTokens = index.entries[topEntry.index]?.translationTokens ?? /* @__PURE__ */ new Set();
+	const finalCandidates = [];
+	for (let i = 0; i < topCount; i++) {
+		const scoredEntry = scored[i];
+		if (!scoredEntry) continue;
+		const entry = index.entries[scoredEntry.index];
+		if (!entry) continue;
+		let translationScore = 0;
+		if (referenceTokens.size > 0 && entry.translationTokens.size > 0) translationScore = jaccardSimilarity(referenceTokens, entry.translationTokens);
+		const finalScore = scoredEntry.keyScore * .85 + translationScore * .15;
+		finalCandidates.push({
+			index: scoredEntry.index,
+			finalScore,
+			keyScore: scoredEntry.keyScore
+		});
+	}
+	for (let i = topCount; i < scored.length; i++) {
+		const scoredEntry = scored[i];
+		if (!scoredEntry) continue;
+		finalCandidates.push({
+			index: scoredEntry.index,
+			finalScore: scoredEntry.keyScore,
+			keyScore: scoredEntry.keyScore
+		});
+	}
+	finalCandidates.sort((a, b) => {
+		if (b.finalScore !== a.finalScore) return b.finalScore - a.finalScore;
+		if (b.keyScore !== a.keyScore) return b.keyScore - a.keyScore;
+		const aKey = index.entries[a.index]?.key ?? "";
+		const bKey = index.entries[b.index]?.key ?? "";
+		return aKey.localeCompare(bKey);
+	});
+	const results = [];
+	for (const candidate of finalCandidates.slice(0, maxResults)) {
+		const entry = index.entries[candidate.index];
+		if (!entry) continue;
+		results.push({
+			key: entry.key,
+			translation: entry.translation,
+			score: candidate.finalScore
+		});
+	}
+	return results;
+}
+
+//#endregion
+//#region ../node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
+const EntryTypes = {
+	FILE_TYPE: "files",
+	DIR_TYPE: "directories",
+	FILE_DIR_TYPE: "files_directories",
+	EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+	root: ".",
+	fileFilter: (_entryInfo) => true,
+	directoryFilter: (_entryInfo) => true,
+	type: EntryTypes.FILE_TYPE,
+	lstat: false,
+	depth: 2147483648,
+	alwaysStat: false,
+	highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = new Set([
+	"ENOENT",
+	"EPERM",
+	"EACCES",
+	"ELOOP",
+	RECURSIVE_ERROR_CODE
+]);
+const ALL_TYPES = [
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = new Set([
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = new Set([
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+	if (filter === void 0) return emptyFn;
+	if (typeof filter === "function") return filter;
+	if (typeof filter === "string") {
+		const fl = filter.trim();
+		return (entry) => entry.basename === fl;
+	}
+	if (Array.isArray(filter)) {
+		const trItems = filter.map((item) => item.trim());
+		return (entry) => trItems.some((f) => entry.basename === f);
+	}
+	return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+var ReaddirpStream = class extends Readable {
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const { root, type } = opts;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat : stat;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = type ? DIR_TYPES.has(type) : false;
+		this._wantsFile = type ? FILE_TYPES.has(type) : false;
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		this.parents = [this._exploreDir(root, 1)];
+		this.reading = false;
+		this.parent = void 0;
+	}
+	async _read(batch) {
+		if (this.reading) return;
+		this.reading = true;
+		try {
+			while (!this.destroyed && batch > 0) {
+				const par = this.parent;
+				const fil = par && par.files;
+				if (fil && fil.length > 0) {
+					const { path, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+					const awaited = await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						const entryType = await this._getEntryType(entry);
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+							if (this._wantsDir) {
+								this.push(entry);
+								batch--;
+							}
+						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+							if (this._wantsFile) {
+								this.push(entry);
+								batch--;
+							}
+						}
+					}
+				} else {
+					const parent = this.parents.pop();
+					if (!parent) {
+						this.push(null);
+						break;
+					}
+					this.parent = await parent;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path, depth) {
+		let files;
+		try {
+			files = await readdir(path, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path
+		};
+	}
+	async _formatEntry(dirent, path) {
+		let entry;
+		const basename = this._isDirent ? dirent.name : dirent;
+		try {
+			const fullPath = resolve(join(path, basename));
+			entry = {
+				path: relative(this._root, fullPath),
+				fullPath,
+				basename
+			};
+			entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+		} catch (err) {
+			this._onError(err);
+			return;
+		}
+		return entry;
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	async _getEntryType(entry) {
+		if (!entry && this._statsProp in entry) return "";
+		const stats = entry[this._statsProp];
+		if (stats.isFile()) return "file";
+		if (stats.isDirectory()) return "directory";
+		if (stats && stats.isSymbolicLink()) {
+			const full = entry.fullPath;
+			try {
+				const entryRealPath = await realpath(full);
+				const entryRealPathStats = await lstat(entryRealPath);
+				if (entryRealPathStats.isFile()) return "file";
+				if (entryRealPathStats.isDirectory()) {
+					const len = entryRealPath.length;
+					if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+						const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+						recursiveError.code = RECURSIVE_ERROR_CODE;
+						return this._onError(recursiveError);
+					}
+					return "directory";
+				}
+			} catch (error) {
+				this._onError(error);
+				return "";
+			}
+		}
+	}
+	_includeAsFile(entry) {
+		const stats = entry && entry[this._statsProp];
+		return stats && this._wantsEverything && !stats.isDirectory();
+	}
+};
+/**
+* Streaming version: Reads all files and directories in given root recursively.
+* Consumes ~constant small amount of RAM.
+* @param root Root directory
+* @param options Options to specify root (start directory), filters and recursion depth
+*/
+function readdirp(root, options = {}) {
+	let type = options.entryType || options.type;
+	if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
+	if (type) options.type = type;
+	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+	else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	options.root = root;
+	return new ReaddirpStream(options);
+}
+
+//#endregion
+//#region ../node_modules/.pnpm/runcheck@1.15.0/node_modules/runcheck/dist/chunk-JPCZKLXK.js
+function b(e) {
+	if (S(e)) return e;
+	if (w(e)) {
+		let r = {};
+		for (let [n, t] of Object.entries(e)) r[n] = b(t);
+		return x(r);
+	} else if (Array.isArray(e)) {
+		let [r, n] = e;
+		switch (r) {
+			case "optional": return b(n).optional();
+			case "nullish_or": return b(n).orNullish();
+			case "null_or": return b(n).orNull();
+			case "array_of": return P(b(n));
+			case "loose_array_of": return E(b(n));
+			case "optional_array_of": return P(b(n)).optional();
+			case "optional_loose_array_of": return E(b(n)).optional();
+			case "null_or_array_of": return P(b(n)).orNull();
+			case "null_or_loose_array_of": return E(b(n)).orNull();
+			case "nullish_or_array_of": return P(b(n)).orNullish();
+			case "nullish_or_loose_array_of": return E(b(n)).orNullish();
+			default: return r;
+		}
+	}
+	throw new Error(`invalid schema: ${e}`);
+}
+function x(e, { normalizeKeysFrom: r, extends: n } = {}) {
+	let t = {};
+	for (let [o, a] of Object.entries(e)) t[o] = b(a);
+	let s = Object.entries(t).map(([o, a]) => ({
+		key: o,
+		type: a
+	}));
+	return {
+		...T,
+		t,
+		e: n ? "extends_object" : "object",
+		T: "",
+		o: !0,
+		_: !!n,
+		r(o, a) {
+			return f(this, o, a, () => {
+				if (!w(o)) {
+					if (a.a = -1, a.s && !this.T) return !1;
+					if (!this.T) {
+						let l = `${this.e}{ `, y = 0;
+						for (let { key: _, type: k } of s) {
+							if (l.length > 100) {
+								l += ", ...";
+								break;
+							}
+							y !== 0 && (l += ", "), l += `${_}: ${k.e}`, y++;
+						}
+						l += " }", this.T = l;
+					}
+					return {
+						data: void 0,
+						errors: [p(a, `Type '${j(o, !1)}' is not assignable to '${this.T}'`)]
+					};
+				}
+				let i = this.e === "strict_obj" || a.i ? new Set(Object.keys(o)) : void 0;
+				if (i && i.size > s.length) {
+					a.a = -1;
+					let l = [];
+					if (a.s) return {
+						data: void 0,
+						errors: [p(a, `Expected strict object with ${s.length} keys but got ${i.size}`)]
+					};
+					for (let { key: y } of s) i.has(y) ? i.delete(y) : l.push(p(a, `Key '${y}' is missing`));
+					for (let y of i) l.push(p(a, `Key '${y}' is not defined in the object shape`));
+					return {
+						data: void 0,
+						errors: l
+					};
+				}
+				let c = {}, h = [], g = a.n, m = -1;
+				for (let l of s) {
+					let y = l.key, _ = l.type, k = y;
+					m += 1;
+					let R = `${g}${y === "" || y.includes(" ") ? `['${y}']` : `.${y}`}`;
+					a.n = R;
+					let O = o[y], D = y;
+					if (O === void 0 && _.u && (O = o[_.u], D = _.u), O === void 0 && r === "snake_case") {
+						let N = V(y);
+						O = o[N], D = N;
+					}
+					i?.delete(D);
+					let B = _.r(O, a);
+					if (B.ok) c[k] = B.data;
+					else {
+						for (let N of B.errors) a.n = R, h.push(N);
+						if (a.s) {
+							a.a = m;
+							break;
+						}
+					}
+				}
+				if (i && i.size > 0) for (let l of i) a.n = g, h.push(p(a, `Key '${l}' is not defined in the object shape`));
+				return h.length > 0 ? {
+					errors: h,
+					data: void 0
+				} : (a.n = g, this._ ? {
+					errors: !1,
+					data: {
+						...o,
+						...c
+					}
+				} : {
+					errors: !1,
+					data: c
+				});
+			});
+		}
+	};
+}
+var ie = () => {};
+function ue(e) {
+	return {
+		...this,
+		p: e === void 0 ? ie : e
+	};
+}
+function ce(e) {
+	return be(this, e);
+}
+function le(e) {
+	return ge(this, e);
+}
+function ye(e) {
+	return _e(this, e);
+}
+function fe(e, r) {
+	return $(e, this, r);
+}
+function Te(e, r) {
+	return je(e, this, r);
+}
+function p(e, r) {
+	return `${e.n ? `$${e.n}: ` : ""}${r}`;
+}
+function C(e, r) {
+	e.b.push(r.startsWith("$") ? r : p(e, r));
+}
+function J(e, r) {
+	r.forEach((n) => C(e, n));
+}
+function f(e, r, n, t) {
+	if (e.c && r === void 0) return {
+		ok: !0,
+		data: r,
+		errors: void 0
+	};
+	if (e.l && r == null) return {
+		ok: !0,
+		data: r,
+		errors: void 0
+	};
+	if (e.f && r === null) return {
+		ok: !0,
+		data: r,
+		errors: void 0
+	};
+	let s = t();
+	if (s && (s === !0 || !s.errors)) return {
+		ok: !0,
+		data: s === !0 ? r : s.data,
+		errors: void 0
+	};
+	if (!n.y) {
+		let o = e.p;
+		if (o !== void 0) return C(n, `Fallback used, errors -> ${L(s, n, e, r)}`), {
+			ok: !0,
+			data: U(o) ? o(r) : o,
+			errors: void 0
+		};
+		if (e.g && e.d) {
+			let a = e.d(r);
+			if (a) return a.safeFix || C(n, `Autofixed from error -> ${L(s, n, e, r)}`), a.errors ? {
+				ok: !1,
+				data: void 0,
+				errors: a.errors.map((u) => p(n, u))
+			} : {
+				ok: !0,
+				data: a.fixed,
+				errors: void 0
+			};
+		}
+	}
+	return {
+		ok: !1,
+		data: void 0,
+		errors: s ? s.errors : [p(n, Q(e, r))]
+	};
+}
+function L(e, r, n, t) {
+	return e ? e.errors.map((s) => s.replace(r.n, "")).join("; ") : Q(n, t);
+}
+function de(e) {
+	return {
+		...this,
+		g: !0,
+		d: e
+	};
+}
+function pe(e) {
+	return {
+		...this,
+		r: (r, n) => f(this, r, n, () => {
+			let t = this.r(r, n);
+			if (!t.ok) return {
+				errors: t.errors,
+				data: void 0
+			};
+			let s = e(t.data);
+			return s !== !0 ? {
+				errors: [p(n, `Predicate failed${s === !1 ? ` for type '${this.e}'` : `: ${s.error}`}`)],
+				data: void 0
+			} : {
+				errors: !1,
+				data: t.data
+			};
+		})
+	};
+}
+function M() {
+	return {
+		...this,
+		c: !0,
+		e: `undefined | ${this.e}`
+	};
+}
+function Q(e, r) {
+	return `Type '${j(r, !!e.k)}' is not assignable to '${e.e}'`;
+}
+function Re() {
+	return {
+		...this,
+		f: !0,
+		e: `null | ${this.e}`
+	};
+}
+function he() {
+	return {
+		...this,
+		l: !0,
+		e: `null | undefined | ${this.e}`
+	};
+}
+var T = {
+	__rc_type: void 0,
+	withFallback: ue,
+	where: pe,
+	r: void 0,
+	e: void 0,
+	optional: M,
+	optionalKey: M,
+	orNullish: he,
+	withAutofix: de,
+	orNull: Re,
+	default: ce,
+	nullishDefault: le,
+	or: ye,
+	parse: fe,
+	parseJson: Te,
+	R: void 0,
+	p: void 0,
+	m: void 0,
+	c: !1,
+	f: !1,
+	l: !1,
+	g: !1,
+	k: !1,
+	u: void 0,
+	d: void 0,
+	t: void 0,
+	T: void 0,
+	o: !1,
+	_: !1
+}, ze = {
+	...T,
+	r(e, r) {
+		return f(this, e, r, () => e === void 0);
+	},
+	e: "undefined"
+}, Je = {
+	...T,
+	r(e, r) {
+		return f(this, e, r, () => e === null);
+	},
+	e: "null"
+}, Qe = {
+	...T,
+	r(e) {
+		return {
+			ok: !0,
+			data: e,
+			errors: void 0
+		};
+	},
+	e: "any"
+}, Ze = {
+	...T,
+	r(e) {
+		return {
+			ok: !0,
+			data: e,
+			errors: void 0
+		};
+	},
+	e: "unknown"
+}, Ge = {
+	...T,
+	r(e, r) {
+		return f(this, e, r, () => typeof e == "boolean");
+	},
+	e: "boolean"
+}, He = {
+	...T,
+	r(e, r) {
+		return f(this, e, r, () => typeof e == "string");
+	},
+	e: "string"
+}, Xe = {
+	...T,
+	r(e, r) {
+		return f(this, e, r, () => typeof e == "number" && !Number.isNaN(e));
+	},
+	e: "number"
+}, Ye = {
+	...T,
+	r(e, r) {
+		return f(this, e, r, () => typeof e == "object" && e instanceof Date && !Number.isNaN(e.getTime()));
+	},
+	e: "date"
+};
+var z = 1;
+function _e(...e) {
+	if (e.length === 0) throw new Error("Unions should have at least one type");
+	let r = "", n = !1;
+	for (let t of e) r && (r += " | "), r += t.e, !n && t.o && (n = !0);
+	return {
+		...T,
+		e: r,
+		o: n,
+		r(t, s) {
+			return f(this, t, s, () => {
+				let o = s.n, a = [], u = 0, i = !1, c = [], h = 0;
+				for (let g of e) {
+					h += 1, g.o && (s.n = `${o}|union ${h}|`);
+					let m = s.s;
+					s.s = !0, s.a = 0;
+					let l = g.r(t, s), y = s.a;
+					if (s.s = m, s.a = 0, l.ok) return {
+						data: l.data,
+						errors: !1
+					};
+					g.o && y !== -1 ? y > 0 ? c.push(...l.errors) : (u < z && a.push(...l.errors), u += 1) : i = !0;
+				}
+				return s.n = o, c.length > 0 || a.length > 0 ? ((u > z || i) && a.push(p(s, "not matches any other union member")), {
+					errors: [...c, ...a],
+					data: void 0
+				}) : !1;
+			});
+		}
+	};
+}
+function be(e, r) {
+	return {
+		...e,
+		c: !1,
+		l: !1,
+		f: !1,
+		r(t, s) {
+			return f(this, t, s, () => {
+				if (t === void 0) return n();
+				let o = e.r(t, s);
+				return o.ok ? o.data === void 0 ? n() : {
+					data: o.data,
+					errors: !1
+				} : {
+					data: void 0,
+					errors: o.errors
+				};
+			});
+		},
+		e: `${e.e}_default`
+	};
+	function n() {
+		return {
+			data: U(r) ? r() : r,
+			errors: !1
+		};
+	}
+}
+function ge(e, r) {
+	return {
+		...e,
+		c: !1,
+		l: !1,
+		f: !1,
+		r(t, s) {
+			return f(this, t, s, () => {
+				if (t == null) return n();
+				let o = e.r(t, s);
+				return o.ok ? o.data === null || o.data === void 0 ? n() : {
+					data: o.data,
+					errors: !1
+				} : {
+					data: void 0,
+					errors: o.errors
+				};
+			});
+		},
+		e: `${e.e}_nullish_default`
+	};
+	function n() {
+		return {
+			data: U(r) ? r() : r,
+			errors: !1
+		};
+	}
+}
+function ke(e, { checkKey: r, looseCheck: n } = {}) {
+	return {
+		...T,
+		e: `record<string, ${e.e}>`,
+		o: !0,
+		r(t, s) {
+			return f(this, t, s, () => {
+				if (!w(t)) return !1;
+				let o = {}, a = [], u = s.n;
+				for (let [i, c] of Object.entries(t)) {
+					if (s.n = `${u}${i === "" || i.includes(" ") ? `['${i}']` : `.${i}`}`, r && !r(i)) {
+						a.push(p(s, `Key '${i}' is not allowed`));
+						continue;
+					}
+					let m = t[i], l = e.r(c, s);
+					if (l.ok) o[i] = m;
+					else {
+						let y = l.errors;
+						for (let _ of y) a.push(_);
+						if (s.s) break;
+					}
+				}
+				if (a.length > 0) if (n) J(s, a);
+				else return {
+					errors: a,
+					data: void 0
+				};
+				return s.n = u, {
+					errors: !1,
+					data: o
+				};
+			});
+		}
+	};
+}
+function A(e, r, n, t = !1, s) {
+	let o = t && !n.y && !n.h, a = s?.unique, u = [], i = [], c = a ? /* @__PURE__ */ new Set() : void 0, h = n.n, g = Array.isArray(r), m = -1;
+	for (let l of e) {
+		m++;
+		let y = g ? r[m] : r, _ = `[${m}]`, k = `${h}${_}`;
+		if (n.n = k, s?.filter) {
+			let R = s.filter(l);
+			if (typeof R == "boolean") {
+				if (!R) continue;
+			} else if ("errors" in R) if (o) {
+				u.push([R.errors, k]);
+				continue;
+			} else return {
+				errors: R.errors,
+				data: void 0
+			};
+			n.n = k;
+		}
+		let d = y.r(l, n);
+		if (n.n = k, d.ok && c) {
+			let R = d.data, O = typeof a == "string";
+			O ? R = d.data[a] : typeof a == "function" && (R = a(d.data)), c.has(R) ? (O && (n.n = `${h}${_}.${a}`), d = {
+				ok: !1,
+				data: void 0,
+				errors: [p(n, O ? `Type '${y.t?.[a]?.e}' with value "${R}" is not unique` : typeof a == "function" ? `Type '${y.e}' unique fn return with value "${R}" is not unique` : `${y.e} value is not unique`)]
+			}) : c.add(R);
+		}
+		if (d.ok) i.push(d.data);
+		else if (o) {
+			u.push([d.errors, k]);
+			continue;
+		} else return {
+			errors: d.errors,
+			data: void 0
+		};
+	}
+	if (u.length > 0) {
+		let l = [];
+		for (let [y, _] of u) {
+			for (let k of y) {
+				let d = k.slice(_.length + 1);
+				d.startsWith(": ") && (d = d.slice(2)), (d.startsWith(".") || d.startsWith("[")) && (d = `#${d}`);
+				let R = `$${_}: Rejected, error -> ${d}`;
+				l.push(R);
+			}
+			J(n, l);
+		}
+	}
+	return {
+		errors: !1,
+		data: i
+	};
+}
+function P(e, r) {
+	return {
+		...T,
+		e: `${e.e}[]`,
+		R: e,
+		r(n, t) {
+			return f(this, n, t, () => Array.isArray(n) ? n.length === 0 ? !0 : A.call(this, n, e, t, !1, r) : !1);
+		}
+	};
+}
+function E(e, r) {
+	return {
+		...T,
+		R: e,
+		e: `${e.e}[]`,
+		r(n, t) {
+			return f(this, n, t, () => Array.isArray(n) ? n.length === 0 ? !0 : A.call(this, n, e, t, !0, r) : !1);
+		}
+	};
+}
+function q(e) {
+	e.warnings && e.warnings.length > 0 && console.warn(`Unwrap warnings: ${e.warnings.join(`
+`)}`);
+}
+function v() {
+	if (this.errors) throw new I(this.errors);
+	return q(this), this.value;
+}
+function K(e) {
+	return this.errors ? e : (q(this), this.value);
+}
+function W() {
+	return this.errors ? null : (q(this), this.value);
+}
+function $(e, r, { noWarnings: n = !1 } = {}) {
+	let t = {
+		b: [],
+		n: "",
+		s: !1,
+		a: 0,
+		y: n,
+		i: !1,
+		h: !1
+	}, s = r.r(e, t);
+	return s.ok ? {
+		error: !1,
+		errors: !1,
+		ok: !0,
+		data: s.data,
+		value: s.data,
+		warnings: t.b.length > 0 ? t.b : !1,
+		unwrap: v,
+		unwrapOr: K,
+		unwrapOrNull: W
+	} : {
+		ok: !1,
+		error: !0,
+		errors: s.errors,
+		unwrap: v,
+		unwrapOr: K,
+		unwrapOrNull: W
+	};
+}
+var I = class extends Error {
+	constructor(n) {
+		super(n.join(`
+`));
+		this.errors = n;
+	}
+	name = "RcValidationError";
+};
+function j(e, r) {
+	let n = typeof e, t = (() => {
+		if (n === "object") {
+			if (Array.isArray(e)) return "array";
+			if (!e) return "null";
+		}
+		return typeof e == "number" && Number.isNaN(e) ? "NaN" : n;
+	})();
+	return r && (t === "string" || t === "number" || t === "boolean") ? `${t}(${e})` : t;
+}
+function w(e) {
+	return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function V(e) {
+	return e.replace(/\W+/g, " ").split(/ |\B(?=[A-Z])/).map((r) => r.toLowerCase()).join("_");
+}
+function je(e, r, n) {
+	try {
+		if (typeof e != "string") return {
+			ok: !1,
+			error: !0,
+			errors: [`expected a json string, got ${j(e, !0)}`],
+			unwrap: v,
+			unwrapOr: K,
+			unwrapOrNull: W
+		};
+		return $(JSON.parse(e), r, n);
+	} catch (t) {
+		return {
+			ok: !1,
+			error: !0,
+			errors: [`json parsing error: ${w(t) ? t.message : ""}`],
+			unwrap: v,
+			unwrapOr: K,
+			unwrapOrNull: W
+		};
+	}
+}
+function U(e) {
+	return typeof e == "function";
+}
+function S(e) {
+	return w(e) && "__rc_type" in e;
+}
+
+//#endregion
+//#region ../core/src/cli/validation.ts
+const translationFileSchema = ke(_e(He, Je, x({
+	manyLimit: Xe.optional(),
+	zero: He.optional(),
+	one: He.optional(),
+	"+2": _e(He, Je),
+	many: He.optional()
+})));
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const MISSING_START_MARKER = "👇 missing start 👇";
+const MISSING_END_MARKER = "👆 missing end 👆";
+const MISSING_MARKER_VALUE = "🛑 delete this line 🛑";
+function isMarkerKey(key) {
+	return key === MISSING_START_MARKER || key === MISSING_END_MARKER;
+}
+function findMarkerLine(fileContent) {
+	const lines = fileContent.split("\n");
+	for (let i = 0; i < lines.length; i++) if (lines[i].includes(MISSING_START_MARKER)) return i + 1;
+	return null;
+}
+function calculateInsertPosition(totalKeys) {
+	if (totalKeys === 0) return 0;
+	return Math.floor(Math.random() * totalKeys);
+}
+function buildOrderedTranslations(existing, missing, insertPosition, addMarkers = true, aiTranslated) {
+	const result = {};
+	const existingKeys = Object.keys(existing).filter((k) => k !== "" && !isMarkerKey(k));
+	const allNewKeys = /* @__PURE__ */ new Map();
+	if (aiTranslated) for (const [key, value] of aiTranslated) allNewKeys.set(key, value);
+	for (const [key, value] of missing) allNewKeys.set(key, value);
+	let inserted = false;
+	for (let i = 0; i < existingKeys.length; i++) {
+		if (i === insertPosition && !inserted && allNewKeys.size > 0) {
+			if (aiTranslated) for (const [key, value] of aiTranslated) result[key] = value;
+			if (missing.size > 0) {
+				if (addMarkers) result[MISSING_START_MARKER] = MISSING_MARKER_VALUE;
+				for (const [key, value] of missing) result[key] = value;
+				if (addMarkers) result[MISSING_END_MARKER] = MISSING_MARKER_VALUE;
+			}
+			inserted = true;
+		}
+		const key = existingKeys[i];
+		if (key !== void 0) result[key] = existing[key];
+	}
+	if (!inserted && allNewKeys.size > 0) {
+		if (aiTranslated) for (const [key, value] of aiTranslated) result[key] = value;
+		if (missing.size > 0) {
+			if (addMarkers) result[MISSING_START_MARKER] = MISSING_MARKER_VALUE;
+			for (const [key, value] of missing) result[key] = value;
+			if (addMarkers) result[MISSING_END_MARKER] = MISSING_MARKER_VALUE;
+		}
+	}
+	result[""] = "";
+	return result;
+}
+const defaultFs = {
+	readFileSync: (filePath, encoding) => readFileSync(filePath, encoding),
+	writeFileSync: (filePath, content) => writeFileSync(filePath, content),
+	async *scanDir(dirPath, options) {
+		for await (const entry_ of readdirp(dirPath, {
+			fileFilter: options.fileFilter,
+			directoryFilter: (entry) => !entry.path.includes("node_modules") && !entry.path.includes(".git")
+		})) {
+			const entry = entry_;
+			yield {
+				fullPath: entry.fullPath,
+				basename: entry.basename
+			};
+		}
+	}
+};
+function hasInterpolationPlaceholder(hash) {
+	return /\{[0-9]+\}/.test(hash);
+}
+function getInterpolationPrefix(value) {
+	const match = value.match(/^(.*?)\{[0-9]+\}/);
+	return match ? match[1] ?? "" : "";
+}
+function getInterpolationSuffix(value) {
+	const match = value.match(/\{[0-9]+\}([^{]*)$/);
+	return match ? match[1] ?? "" : "";
+}
+function isIgnoredAffix(value) {
+	return /^[\s?!.()""'']*$/.test(value);
+}
+function isPluralOnlyPlus2(value) {
+	return value.zero === void 0 && value.one === void 0 && value.many === void 0;
+}
+function getStringValue(value) {
+	if (value === void 0 || value === null) return null;
+	if (typeof value === "string") return value;
+	return value["+2"];
+}
+function formatIssue(issue, severity, srcPath) {
+	const icon = severity === "error" ? "❌" : "⚠️";
+	const location = issue.locations[0];
+	if (location) return `${icon} ${path$1.relative(path$1.dirname(srcPath), path$1.join(srcPath, location.file))}:${location.line}:${location.column} ${issue.message}`;
+	return `${icon} ${issue.message}`;
+}
+async function validateTranslations(options) {
+	const { configDir, srcDir, defaultLocale, fix = false, noColor = false, colorFn = (_, text) => text, fs = defaultFs, log = console, aiTranslator, rules = {}, maxTranslationIdSize = 80 } = options;
+	const getRuleSeverity = (rule) => {
+		return rules[rule] ?? "error";
+	};
+	const allStringTranslationHashs = /* @__PURE__ */ new Set();
+	const allPluralTranslationHashs = /* @__PURE__ */ new Set();
+	let hasError = false;
+	const srcPath = path$1.isAbsolute(srcDir) ? srcDir : path$1.join(process.cwd(), srcDir);
+	const globalUsageMap = /* @__PURE__ */ new Map();
+	const globalJsxStringTranslations = /* @__PURE__ */ new Set();
+	const globalJsxPluralTranslations = /* @__PURE__ */ new Set();
+	const globalPrimitiveOnlyJsx = /* @__PURE__ */ new Set();
+	for await (const entry of fs.scanDir(srcPath, { fileFilter: (entry) => entry.path.endsWith(".ts") || entry.path.endsWith(".tsx") })) {
+		const { fullPath } = entry;
+		const fileTextContent = fs.readFileSync(fullPath, "utf-8");
+		const i18nUsages = getI18nUsagesInCode(path$1.relative(srcPath, fullPath), fileTextContent);
+		for (const hash of i18nUsages.stringTranslations) allStringTranslationHashs.add(hash);
+		for (const hash of i18nUsages.pluralTranslations) allPluralTranslationHashs.add(hash);
+		for (const hash of i18nUsages.jsxStringTranslations) globalJsxStringTranslations.add(hash);
+		for (const hash of i18nUsages.jsxPluralTranslations) globalJsxPluralTranslations.add(hash);
+		for (const hash of i18nUsages.primitiveOnlyJsx) globalPrimitiveOnlyJsx.add(hash);
+		for (const [hash, usage] of i18nUsages.usageMap) {
+			const existing = globalUsageMap.get(hash);
+			if (existing) {
+				existing.locations.push(...usage.locations);
+				if (!usage.hasOnlyPrimitiveInterpolations) existing.hasOnlyPrimitiveInterpolations = false;
+			} else globalUsageMap.set(hash, { ...usage });
+		}
+	}
+	if (allStringTranslationHashs.size === 0 && allPluralTranslationHashs.size === 0) {
+		log.error("❌ No translations found in dir: ", srcDir);
+		return { hasError: true };
+	}
+	const configPath = path$1.isAbsolute(configDir) ? configDir : path$1.join(process.cwd(), configDir);
+	const allLocaleTranslations = /* @__PURE__ */ new Map();
+	const localeFiles = [];
+	for await (const entry of fs.scanDir(configPath, { fileFilter: (entry) => entry.path.endsWith(".json") })) localeFiles.push(entry);
+	for (const { fullPath, basename } of localeFiles) {
+		const fileParseResult = $(JSON.parse(fs.readFileSync(fullPath, "utf-8")), translationFileSchema);
+		if (!fileParseResult.ok) {
+			log.error(`❌ ${basename} has invalid format:`, fileParseResult.errors);
+			hasError = true;
+			continue;
+		}
+		const localeId = basename.replace(".json", "");
+		allLocaleTranslations.set(localeId, fileParseResult.value);
+	}
+	const validationIssues = [];
+	const allHashes = new Set([...allStringTranslationHashs, ...allPluralTranslationHashs]);
+	for (const hash of allHashes) {
+		if (hash.startsWith("$") || hash.includes("~~")) continue;
+		const locations = globalUsageMap.get(hash)?.locations ?? [];
+		if (getRuleSeverity("max-translation-id-size") !== "off" && hash.length > maxTranslationIdSize) {
+			const truncated = hash.length > 40 ? `${hash.slice(0, 37)}...` : hash;
+			validationIssues.push({
+				rule: "max-translation-id-size",
+				hash,
+				message: `translation ID exceeds ${maxTranslationIdSize} chars (${hash.length}): "${truncated}". Use a $shortId instead, e.g.: __\`$myKey\``,
+				locations
+			});
+		}
+		if (getRuleSeverity("constant-translation") !== "off") {
+			const values = [];
+			for (const [localeId, translations] of allLocaleTranslations) {
+				const value = translations[hash];
+				const strValue = getStringValue(value);
+				const isDefaultLocaleEntry = defaultLocale !== void 0 && localeId === defaultLocale;
+				if (strValue !== null) values.push(strValue);
+				else if (isDefaultLocaleEntry) values.push(hash);
+			}
+			if (values.length >= 2 && new Set(values).size === 1) validationIssues.push({
+				rule: "constant-translation",
+				hash,
+				message: `constant translation "${hash}" has the same value in all locales. Either translate it differently per locale, or use plain strings if it doesn't need translation`,
+				locations
+			});
+		}
+		if (getRuleSeverity("unnecessary-plural") !== "off" && allPluralTranslationHashs.has(hash)) {
+			let allOnlyPlus2 = true;
+			let hasAnyPluralTranslation = false;
+			for (const [, translations] of allLocaleTranslations) {
+				const value = translations[hash];
+				if (value !== null && value !== void 0 && isObject(value)) {
+					hasAnyPluralTranslation = true;
+					if (!isPluralOnlyPlus2(value)) {
+						allOnlyPlus2 = false;
+						break;
+					}
+				}
+			}
+			if (hasAnyPluralTranslation && allOnlyPlus2) validationIssues.push({
+				rule: "unnecessary-plural",
+				hash,
+				message: `unnecessary plural "${hash}" only uses the +2 form in all locales. Use __\`# items\` with interpolation instead of __p(count)\`# items\`, or add zero/one/many forms if needed`,
+				locations
+			});
+		}
+		if (getRuleSeverity("jsx-without-interpolation") !== "off") {
+			if ((globalJsxStringTranslations.has(hash) || globalJsxPluralTranslations.has(hash)) && !hasInterpolationPlaceholder(hash)) validationIssues.push({
+				rule: "jsx-without-interpolation",
+				hash,
+				message: `__jsx used without interpolations for "${hash}". Use __\`${hash}\` instead since there are no JSX elements to interpolate`,
+				locations
+			});
+		}
+		if (getRuleSeverity("jsx-without-jsx-nodes") !== "off") {
+			const isJsx = globalJsxStringTranslations.has(hash) || globalJsxPluralTranslations.has(hash);
+			const isPrimitiveOnly = globalPrimitiveOnlyJsx.has(hash);
+			if (isJsx && isPrimitiveOnly && hasInterpolationPlaceholder(hash)) validationIssues.push({
+				rule: "jsx-without-jsx-nodes",
+				hash,
+				message: `__jsx used but all interpolations are primitives (strings/numbers) for "${hash}". Use __\`...\` instead of __jsx\`...\` when not interpolating JSX elements`,
+				locations
+			});
+		}
+		if (getRuleSeverity("unnecessary-interpolated-affix") !== "off" && hasInterpolationPlaceholder(hash)) {
+			const prefixes = [];
+			const suffixes = [];
+			for (const [localeId, translations] of allLocaleTranslations) {
+				const value = translations[hash];
+				const strValue = getStringValue(value);
+				const effectiveValue = strValue !== null ? strValue : defaultLocale !== void 0 && localeId === defaultLocale ? hash : null;
+				if (effectiveValue !== null) {
+					prefixes.push(getInterpolationPrefix(effectiveValue));
+					suffixes.push(getInterpolationSuffix(effectiveValue));
+				}
+			}
+			if (prefixes.length >= 2) {
+				const uniquePrefixes = new Set(prefixes);
+				const prefix = prefixes[0] ?? "";
+				if (uniquePrefixes.size === 1 && prefix !== "" && !isIgnoredAffix(prefix)) validationIssues.push({
+					rule: "unnecessary-interpolated-affix",
+					hash,
+					message: `prefix "${prefix}" before interpolation in "${hash}" is identical in all locales. Move it outside the translation: "${prefix}" + __\`...\``,
+					locations
+				});
+			}
+			if (suffixes.length >= 2) {
+				const uniqueSuffixes = new Set(suffixes);
+				const suffix = suffixes[0] ?? "";
+				if (uniqueSuffixes.size === 1 && suffix !== "" && !isIgnoredAffix(suffix)) validationIssues.push({
+					rule: "unnecessary-interpolated-affix",
+					hash,
+					message: `suffix "${suffix}" after interpolation in "${hash}" is identical in all locales. Move it outside the translation: __\`...\` + "${suffix}"`,
+					locations
+				});
+			}
+		}
+	}
+	for (const issue of validationIssues) {
+		const severity = getRuleSeverity(issue.rule);
+		if (severity === "off") continue;
+		const message = formatIssue(issue, severity, srcPath);
+		if (severity === "error") {
+			hasError = true;
+			log.error(message);
+		} else log.info(message);
+	}
+	const aiTranslationTasks = [];
+	for (const { fullPath, basename } of localeFiles) {
+		const invalidPluralTranslations = [];
+		const invalidSpecialTranslations = [];
+		const incompletePluralTranslations = [];
+		const localeId = basename.replace(".json", "");
+		const localeTranslations = allLocaleTranslations.get(localeId);
+		if (!localeTranslations) continue;
+		const isDefaultLocale = basename === `${defaultLocale}.json`;
+		const localeFileHashs = Object.keys(localeTranslations);
+		const extraHashs = new Set(localeFileHashs);
+		const missingHashs = new Set([...isDefaultLocale ? [] : [...allStringTranslationHashs], ...allPluralTranslationHashs]);
+		extraHashs.delete("");
+		for (const hash of localeFileHashs) if (allStringTranslationHashs.has(hash)) {
+			const translationValue = localeTranslations[hash];
+			const isNullTranslation = translationValue === null;
+			const isUnneededDefaultHash = isDefaultLocale && (isNullTranslation || translationValue === hash);
+			const isIncompleteNonDefaultTranslation = defaultLocale !== void 0 && !isDefaultLocale && isNullTranslation;
+			if (isUnneededDefaultHash) missingHashs.delete(hash);
+			else if (!isIncompleteNonDefaultTranslation) {
+				missingHashs.delete(hash);
+				extraHashs.delete(hash);
+			}
+			if ((hash.includes("~~") || hash.startsWith("$")) && translationValue === hash) invalidSpecialTranslations.push(hash);
+		} else if (allPluralTranslationHashs.has(hash)) {
+			missingHashs.delete(hash);
+			extraHashs.delete(hash);
+			const pluralValue = localeTranslations[hash];
+			if (pluralValue !== void 0 && !isObject(pluralValue)) {
+				invalidPluralTranslations.push(hash);
+				delete localeTranslations[hash];
+				if (fix) missingHashs.add(hash);
+			} else if (!isDefaultLocale && isObject(pluralValue) && pluralValue["+2"] === null) incompletePluralTranslations.push(hash);
+		} else missingHashs.delete(hash);
+		if (missingHashs.size > 0 || extraHashs.size > 0 || invalidPluralTranslations.length > 0 || invalidSpecialTranslations.length > 0 || incompletePluralTranslations.length > 0) if (!fix) {
+			hasError = true;
+			if (invalidPluralTranslations.length > 0) log.error(`❌ ${basename} has invalid plural translations: `, invalidPluralTranslations);
+			if (incompletePluralTranslations.length > 0) log.error(`❌ ${basename} has incomplete plural translations ('+2' is null, which is only allowed in the default locale): `, incompletePluralTranslations);
+			if (invalidSpecialTranslations.length > 0) log.error(`❌ ${basename} has invalid special translations (value equals key): `, invalidSpecialTranslations);
+			if (missingHashs.size > 0 || extraHashs.size > 0) {
+				const parts = [];
+				if (missingHashs.size) {
+					const countStr = noColor ? String(missingHashs.size) : colorFn("red", String(missingHashs.size));
+					parts.push(`missing ${countStr}`);
+				}
+				if (extraHashs.size) {
+					const countStr = noColor ? String(extraHashs.size) : colorFn("red", String(extraHashs.size));
+					parts.push(`extra ${countStr}`);
+				}
+				const allExtrasAreMarkers = extraHashs.size > 0 && [...extraHashs].every((k) => isMarkerKey(k));
+				let lineInfo = "";
+				if (allExtrasAreMarkers) {
+					const markerLine = findMarkerLine(fs.readFileSync(fullPath, "utf-8"));
+					lineInfo = markerLine ? `:${markerLine}` : "";
+				}
+				log.error(`❌ ${basename}${lineInfo} has invalid translations: ${parts.join(", ")}`);
+			}
+		} else if (invalidSpecialTranslations.length > 0) log.error(`❌ ${basename} has invalid special translations (value equals key): `, invalidSpecialTranslations);
+		else if (missingHashs.size === 0 && extraHashs.size > 0 && [...extraHashs].every((k) => isMarkerKey(k))) {
+			const markerLine = findMarkerLine(fs.readFileSync(fullPath, "utf-8"));
+			const lineInfo = markerLine ? `:${markerLine}` : "";
+			log.error(`❌ ${basename}${lineInfo} has missing translations`);
+		} else {
+			const cleanedExisting = {};
+			for (const key of Object.keys(localeTranslations)) {
+				if (key === "" || isMarkerKey(key) || extraHashs.has(key)) continue;
+				cleanedExisting[key] = localeTranslations[key];
+			}
+			const missingSpecialTranslations = [];
+			for (const hash of missingHashs) if (hash.startsWith("$") || hash.includes("~~")) missingSpecialTranslations.push(hash);
+			const regularMissingHashs = new Set([...missingHashs].filter((h) => !h.startsWith("$") && !h.includes("~~")));
+			if (aiTranslator && missingSpecialTranslations.length > 0) {
+				hasError = true;
+				log.error(`❌ ${basename} has missing $ or ~~ translations that require manual translation:`, missingSpecialTranslations);
+			}
+			if (aiTranslator && regularMissingHashs.size > 0) {
+				const targetLocale = basename.replace(".json", "");
+				const existingTranslationsMap = /* @__PURE__ */ new Map();
+				for (const [key, value] of Object.entries(cleanedExisting)) if (typeof value === "string" || typeof value === "object" && value !== null) existingTranslationsMap.set(key, value);
+				for (const extraKey of extraHashs) {
+					if (isMarkerKey(extraKey) || existingTranslationsMap.has(extraKey)) continue;
+					const value = localeTranslations[extraKey];
+					if (typeof value === "string" || typeof value === "object" && value !== null) existingTranslationsMap.set(extraKey, value);
+				}
+				const contexts = [];
+				const similarityIndex = createSimilarityIndex(existingTranslationsMap);
+				for (const hash of regularMissingHashs) {
+					const isPlural = allPluralTranslationHashs.has(hash);
+					const similarTranslations = findSimilarFromIndex(similarityIndex, hash);
+					contexts.push({
+						sourceKey: hash,
+						targetLocale,
+						isPlural,
+						similarTranslations
+					});
+				}
+				aiTranslationTasks.push({
+					fullPath,
+					basename,
+					cleanedExisting,
+					regularMissingHashs,
+					missingSpecialTranslations,
+					contexts,
+					extraHashs,
+					missingHashs
+				});
+			} else {
+				const missingMap = /* @__PURE__ */ new Map();
+				for (const hash of missingHashs) {
+					const value = allPluralTranslationHashs.has(hash) ? {
+						zero: "No x",
+						one: "1 x",
+						"+2": "# x",
+						many: void 0,
+						manyLimit: void 0
+					} : null;
+					missingMap.set(hash, value);
+				}
+				const existingKeysCount = Object.keys(cleanedExisting).length;
+				const orderedTranslations = buildOrderedTranslations(cleanedExisting, missingMap, calculateInsertPosition(existingKeysCount), missingMap.size > 0);
+				const writtenContent = JSON.stringify(orderedTranslations, null, 2);
+				if (missingHashs.size > 0) {
+					hasError = true;
+					const markerLine = findMarkerLine(writtenContent);
+					const lineInfo = markerLine ? `:${markerLine}` : "";
+					log.info(`🟠 ${basename}${lineInfo} translations keys were added`);
+				} else log.info(`✅ ${basename} translations fixed`);
+				fs.writeFileSync(fullPath, writtenContent);
+			}
+		}
+		else log.info(`✅ ${basename} translations are up to date`);
+	}
+	if (aiTranslationTasks.length > 0) {
+		const aiResults = await Promise.all(aiTranslationTasks.map(async (task) => {
+			try {
+				return {
+					task,
+					result: await aiTranslator.translateBatch(task.contexts),
+					error: null
+				};
+			} catch (error) {
+				return {
+					task,
+					result: null,
+					error
+				};
+			}
+		}));
+		for (const { task, result, error } of aiResults) {
+			const { fullPath, basename, cleanedExisting, regularMissingHashs, missingSpecialTranslations, missingHashs } = task;
+			const missingMap = /* @__PURE__ */ new Map();
+			const aiTranslatedMap = /* @__PURE__ */ new Map();
+			if (error) {
+				log.error(`❌ AI translation failed for ${basename}:`, error instanceof Error ? error.message : error);
+				for (const hash of regularMissingHashs) {
+					const value = allPluralTranslationHashs.has(hash) ? {
+						zero: "No x",
+						one: "1 x",
+						"+2": "# x",
+						many: void 0,
+						manyLimit: void 0
+					} : null;
+					missingMap.set(hash, value);
+				}
+			} else if (result) {
+				const { translations: aiTranslations, model, usage } = result;
+				for (const hash of regularMissingHashs) {
+					const aiResult = aiTranslations.get(hash);
+					if (aiResult) aiTranslatedMap.set(hash, aiResult.value);
+					else {
+						const fallbackValue = allPluralTranslationHashs.has(hash) ? {
+							zero: "No x",
+							one: "1 x",
+							"+2": "# x",
+							many: void 0,
+							manyLimit: void 0
+						} : null;
+						missingMap.set(hash, fallbackValue);
+					}
+				}
+				if (model || usage) {
+					const parts = [];
+					if (model) parts.push(`Model: ${model}`);
+					if (usage) parts.push(`Tokens: ${usage.inputTokens} in / ${usage.outputTokens} out`);
+					log.info(`   ${basename}: ${parts.join(" | ")}`);
+				}
+			}
+			for (const hash of missingSpecialTranslations) {
+				const value = allPluralTranslationHashs.has(hash) ? {
+					zero: "No x",
+					one: "1 x",
+					"+2": "# x",
+					many: void 0,
+					manyLimit: void 0
+				} : null;
+				missingMap.set(hash, value);
+			}
+			const existingKeysCount = Object.keys(cleanedExisting).length;
+			const orderedTranslations = buildOrderedTranslations(cleanedExisting, missingMap, calculateInsertPosition(existingKeysCount), missingMap.size > 0, aiTranslatedMap.size > 0 ? aiTranslatedMap : void 0);
+			const writtenContent = JSON.stringify(orderedTranslations, null, 2);
+			if (missingHashs.size > 0) if (missingMap.size === 0) log.info(`✅ ${basename} translations were AI-generated`);
+			else {
+				hasError = true;
+				const markerLine = findMarkerLine(writtenContent);
+				const lineInfo = markerLine ? `:${markerLine}` : "";
+				log.info(`🟠 ${basename}${lineInfo} translations keys were added`);
+			}
+			else log.info(`✅ ${basename} translations fixed`);
+			fs.writeFileSync(fullPath, writtenContent);
+		}
+	}
+	return { hasError };
+}
+
+//#endregion
+//#region src/cli.ts
+loadEnvFiles();
+const parsed = typeFlag({
+	"config-dir": {
+		type: String,
+		alias: "c"
+	},
+	"src-dir": {
+		type: String,
+		alias: "r"
+	},
+	default: {
+		type: String,
+		alias: "d"
+	},
+	fix: {
+		type: Boolean,
+		alias: "f",
+		default: false
+	},
+	"no-color": {
+		type: Boolean,
+		default: false
+	},
+	ai: { type: String },
+	"max-id-size": {
+		type: Number,
+		default: 80
+	},
+	"disable-rule": {
+		type: [String],
+		default: []
+	},
+	"warn-rule": {
+		type: [String],
+		default: []
+	}
+});
+const srcDir = parsed.flags["src-dir"];
+if (!srcDir) {
+	console.error("--src-dir is required");
+	process.exit(1);
+}
+const configDir = parsed.flags["config-dir"];
+if (!configDir) {
+	console.error("--config-dir is required");
+	process.exit(1);
+}
+let aiTranslator;
+const aiProviderInput = parsed.flags.ai ?? process.env["I18N_AI_AUTO_TRANSLATE"];
+if (aiProviderInput) {
+	if (aiProviderInput !== "google" && aiProviderInput !== "openai") {
+		console.error(`Invalid AI provider: ${aiProviderInput}. Must be 'google' or 'openai'.`);
+		process.exit(1);
+	}
+	const provider = aiProviderInput;
+	const apiKeyEnvVar = provider === "google" ? "GOOGLE_GENERATIVE_AI_API_KEY" : "OPENAI_API_KEY";
+	if (!Boolean(process.env[apiKeyEnvVar])) console.warn(`Warning: ${apiKeyEnvVar} not set. AI translation will be skipped.`);
+	else aiTranslator = createAITranslator(provider);
+}
+const validRuleNames = [
+	"constant-translation",
+	"unnecessary-plural",
+	"jsx-without-interpolation",
+	"jsx-without-jsx-nodes",
+	"unnecessary-interpolated-affix",
+	"max-translation-id-size"
+];
+const rules = {};
+for (const rule of parsed.flags["disable-rule"]) {
+	if (!validRuleNames.includes(rule)) {
+		console.error(`Unknown rule: ${rule}`);
+		process.exit(1);
+	}
+	rules[rule] = "off";
+}
+for (const rule of parsed.flags["warn-rule"]) {
+	if (!validRuleNames.includes(rule)) {
+		console.error(`Unknown rule: ${rule}`);
+		process.exit(1);
+	}
+	rules[rule] = "warning";
+}
+const { hasError } = await validateTranslations({
+	srcDir,
+	configDir,
+	defaultLocale: parsed.flags.default,
+	fix: parsed.flags.fix,
+	noColor: parsed.flags["no-color"],
+	colorFn: (color, text) => consoleFmt.color(color, text),
+	aiTranslator,
+	rules,
+	maxTranslationIdSize: parsed.flags["max-id-size"]
+});
+if (hasError) process.exit(1);
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map