react-autolocale 0.2.0 → 0.3.0-beta.1

package/dist/project-BazDFtnp.js

@@ -0,0 +1,1400 @@
+import { t as BANNER_EN } from "./suggestion-CkZQqMvZ.js";
+import { r as PROVIDER_NAMES } from "./config-U-SpTtCW.js";
+import path from "node:path";
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import os from "node:os";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import { JSDOM } from "jsdom";
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import * as t from "@babel/types";
+const byCode = new Map([
+	{
+		code: "en",
+		native: "English",
+		english: "English",
+		nllb: "eng_Latn"
+	},
+	{
+		code: "fr",
+		native: "Français",
+		english: "French",
+		nllb: "fra_Latn",
+		opus: "fr"
+	},
+	{
+		code: "es",
+		native: "Español",
+		english: "Spanish",
+		nllb: "spa_Latn",
+		opus: "es"
+	},
+	{
+		code: "de",
+		native: "Deutsch",
+		english: "German",
+		nllb: "deu_Latn",
+		opus: "de"
+	},
+	{
+		code: "it",
+		native: "Italiano",
+		english: "Italian",
+		nllb: "ita_Latn",
+		opus: "it"
+	},
+	{
+		code: "pt",
+		native: "Português",
+		english: "Portuguese",
+		nllb: "por_Latn"
+	},
+	{
+		code: "nl",
+		native: "Nederlands",
+		english: "Dutch",
+		nllb: "nld_Latn",
+		opus: "nl"
+	},
+	{
+		code: "ru",
+		native: "Русский",
+		english: "Russian",
+		nllb: "rus_Cyrl",
+		opus: "ru"
+	},
+	{
+		code: "zh",
+		native: "中文",
+		english: "Chinese (Simplified)",
+		nllb: "zho_Hans",
+		opus: "zh"
+	},
+	{
+		code: "ja",
+		native: "日本語",
+		english: "Japanese",
+		nllb: "jpn_Jpan"
+	},
+	{
+		code: "ko",
+		native: "한국어",
+		english: "Korean",
+		nllb: "kor_Hang"
+	},
+	{
+		code: "ar",
+		native: "العربية",
+		english: "Arabic",
+		nllb: "arb_Arab",
+		opus: "ar",
+		rtl: true
+	},
+	{
+		code: "hi",
+		native: "हिन्दी",
+		english: "Hindi",
+		nllb: "hin_Deva",
+		opus: "hi"
+	},
+	{
+		code: "tr",
+		native: "Türkçe",
+		english: "Turkish",
+		nllb: "tur_Latn"
+	},
+	{
+		code: "pl",
+		native: "Polski",
+		english: "Polish",
+		nllb: "pol_Latn"
+	},
+	{
+		code: "sv",
+		native: "Svenska",
+		english: "Swedish",
+		nllb: "swe_Latn",
+		opus: "sv"
+	},
+	{
+		code: "da",
+		native: "Dansk",
+		english: "Danish",
+		nllb: "dan_Latn",
+		opus: "da"
+	},
+	{
+		code: "no",
+		native: "Norsk",
+		english: "Norwegian",
+		nllb: "nob_Latn"
+	},
+	{
+		code: "fi",
+		native: "Suomi",
+		english: "Finnish",
+		nllb: "fin_Latn",
+		opus: "fi"
+	},
+	{
+		code: "cs",
+		native: "Čeština",
+		english: "Czech",
+		nllb: "ces_Latn",
+		opus: "cs"
+	},
+	{
+		code: "hu",
+		native: "Magyar",
+		english: "Hungarian",
+		nllb: "hun_Latn",
+		opus: "hu"
+	},
+	{
+		code: "ro",
+		native: "Română",
+		english: "Romanian",
+		nllb: "ron_Latn",
+		opus: "ro"
+	},
+	{
+		code: "uk",
+		native: "Українська",
+		english: "Ukrainian",
+		nllb: "ukr_Cyrl",
+		opus: "uk"
+	},
+	{
+		code: "el",
+		native: "Ελληνικά",
+		english: "Greek",
+		nllb: "ell_Grek"
+	},
+	{
+		code: "he",
+		native: "עברית",
+		english: "Hebrew",
+		nllb: "heb_Hebr",
+		rtl: true
+	},
+	{
+		code: "vi",
+		native: "Tiếng Việt",
+		english: "Vietnamese",
+		nllb: "vie_Latn",
+		opus: "vi"
+	},
+	{
+		code: "id",
+		native: "Bahasa Indonesia",
+		english: "Indonesian",
+		nllb: "ind_Latn",
+		opus: "id"
+	},
+	{
+		code: "th",
+		native: "ไทย",
+		english: "Thai",
+		nllb: "tha_Thai"
+	},
+	{
+		code: "bn",
+		native: "বাংলা",
+		english: "Bengali",
+		nllb: "ben_Beng"
+	},
+	{
+		code: "fa",
+		native: "فارسی",
+		english: "Persian",
+		nllb: "pes_Arab",
+		rtl: true
+	},
+	{
+		code: "ur",
+		native: "اردو",
+		english: "Urdu",
+		nllb: "urd_Arab",
+		rtl: true
+	},
+	{
+		code: "bg",
+		native: "Български",
+		english: "Bulgarian",
+		nllb: "bul_Cyrl"
+	},
+	{
+		code: "hr",
+		native: "Hrvatski",
+		english: "Croatian",
+		nllb: "hrv_Latn"
+	},
+	{
+		code: "sk",
+		native: "Slovenčina",
+		english: "Slovak",
+		nllb: "slk_Latn"
+	},
+	{
+		code: "ca",
+		native: "Català",
+		english: "Catalan",
+		nllb: "cat_Latn"
+	},
+	{
+		code: "ms",
+		native: "Bahasa Melayu",
+		english: "Malay",
+		nllb: "zsm_Latn"
+	},
+	{
+		code: "sw",
+		native: "Kiswahili",
+		english: "Swahili",
+		nllb: "swh_Latn"
+	},
+	{
+		code: "tl",
+		native: "Tagalog",
+		english: "Tagalog",
+		nllb: "tgl_Latn"
+	}
+].map((l) => [l.code, l]));
+function getLanguage(code) {
+	return byCode.get(code);
+}
+//#endregion
+//#region src/core/translate.ts
+/**
+* A translation that could not be done. `fatal` errors (missing key, bad credentials, unknown model, missing
+* package) stop the whole run, since every further request would fail the same way.
+*/
+var TranslationError = class extends Error {
+	fatal;
+	constructor(message, fatal = false) {
+		super(message);
+		this.fatal = fatal;
+		this.name = "TranslationError";
+	}
+};
+function toTranslator(engine) {
+	if (typeof engine !== "function") return engine;
+	return { translate: (texts, from, to, contexts = []) => engine({
+		texts,
+		contexts: texts.map((_, i) => contexts[i] ?? ""),
+		from,
+		to
+	}) };
+}
+/**
+* Uses a local LLM through Ollama (free, runs on your machine). Unlike the default models it is told
+* where each string appears, which fixes most one-word mistakes ("Home" in a nav bar is not "Sommaire").
+*/
+function ollama(options = { model: "llama3.1" }) {
+	const url = (options.url ?? "http://localhost:11434").replace(/\/+$/, "");
+	return { async translate(texts, from, to, contexts = []) {
+		const out = [];
+		for (let i = 0; i < texts.length; i++) {
+			const where = contexts[i] ? ` It appears in a website ${contexts[i]} element.` : "";
+			const res = await fetch(`${url}/api/chat`, {
+				method: "POST",
+				signal: AbortSignal.timeout(12e4),
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					model: options.model,
+					stream: false,
+					options: { temperature: 0 },
+					messages: [{
+						role: "system",
+						content: `You translate website interface text from ${from} to ${to}.${where} Keep tokens like X0X, X1X and {name} exactly as written. Reply with only the translation.`
+					}, {
+						role: "user",
+						content: texts[i]
+					}]
+				})
+			}).catch((err) => {
+				throw new TranslationError(`Could not reach Ollama at ${url} (${err.message}). Is it running?`, err.name !== "TimeoutError");
+			});
+			if (!res.ok) throw new TranslationError(`Ollama request failed (${res.status}). Is the model "${options.model}" pulled?`, res.status === 404);
+			const body = await res.json();
+			out.push((body.message?.content ?? "").trim());
+		}
+		return out;
+	} };
+}
+const ENGINE_PACKAGE = "@huggingface/transformers@^4.3.1";
+const ENGINE_DIR = path.join(os.homedir(), ".cache", "react-autolocale", "engine");
+/**
+* Finds the translation engine. Uses the project's own copy if it has one; otherwise installs it once
+* into ~/.cache/react-autolocale/engine (shared by all projects, never touches the project's node_modules).
+*/
+async function loadEngine(log) {
+	try {
+		return await import("@huggingface/transformers");
+	} catch {}
+	const require = createRequire(path.join(ENGINE_DIR, "package.json"));
+	const find = () => require.resolve("@huggingface/transformers");
+	let entry;
+	try {
+		entry = find();
+	} catch {
+		log("[react-autolocale] Installing the translation engine (one time, about 440 MB)...");
+		fs.mkdirSync(ENGINE_DIR, { recursive: true });
+		const pkg = path.join(ENGINE_DIR, "package.json");
+		if (!fs.existsSync(pkg)) fs.writeFileSync(pkg, JSON.stringify({
+			name: "react-autolocale-engine",
+			private: true
+		}));
+		const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+		const res = spawnSync(npm, [
+			"install",
+			"--prefix",
+			ENGINE_DIR,
+			"--no-audit",
+			"--no-fund",
+			"--loglevel=error",
+			ENGINE_PACKAGE
+		], {
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		try {
+			if (res.status !== 0) throw new Error("npm failed");
+			entry = find();
+		} catch {
+			throw new TranslationError(`Could not install the translation engine automatically. Install it yourself: npm install -D @huggingface/transformers`, true);
+		}
+	}
+	const mod = await import(pathToFileURL(entry).href);
+	return mod.pipeline ? mod : mod.default;
+}
+const NLLB_MODEL = "Xenova/nllb-200-distilled-600M";
+const batchSize = (model) => model.includes("opus-mt") ? 8 : 1;
+/**
+* Free, offline translation using Transformers.js (ONNX models run on the CPU).
+* Models are downloaded once from Hugging Face and cached in ~/.cache/react-autolocale.
+* English -> X uses small per-language OPUS-MT models where they exist; everything else uses NLLB-200.
+*/
+function createLocalTranslator(log = () => {}) {
+	const pipes = /* @__PURE__ */ new Map();
+	let hf = null;
+	const getPipe = (model) => {
+		let p = pipes.get(model);
+		if (!p) {
+			hf ??= loadEngine(log).then((m) => {
+				m.env.cacheDir = path.join(os.homedir(), ".cache", "react-autolocale", "models");
+				return m;
+			});
+			log(`Loading model ${model} (downloaded once into ~/.cache/react-autolocale/models)...`);
+			const lastPct = /* @__PURE__ */ new Map();
+			p = hf.then((m) => m.pipeline("translation", model, {
+				dtype: "q8",
+				progress_callback: (e) => {
+					if (e.status === "progress" && e.progress - (lastPct.get(e.file) ?? -10) >= 10) {
+						lastPct.set(e.file, e.progress);
+						log(`  model ${model.split("/").pop()} ${e.file}: ${Math.round(e.progress)}% (download or cache read)`);
+					}
+				}
+			}));
+			pipes.set(model, p);
+		}
+		return p;
+	};
+	const run = async (model, texts, options) => {
+		const pipe = await getPipe(model);
+		const out = [];
+		const step = batchSize(model);
+		for (let i = 0; i < texts.length; i += step) {
+			const res = await pipe(texts.slice(i, i + step), {
+				max_new_tokens: 256,
+				...options
+			});
+			out.push(...res.map((r) => r.translation_text.trim()));
+		}
+		return out;
+	};
+	return { async translate(texts, from, to) {
+		const src = getLanguage(from);
+		const dst = getLanguage(to);
+		if (!src || !dst) throw new Error(`Unsupported language: ${!src ? from : to}`);
+		if (from === "en" && dst.opus) try {
+			return await run(`Xenova/opus-mt-en-${dst.opus}`, texts, {});
+		} catch (err) {
+			log(`  OPUS-MT model for "${to}" unavailable (${err.message}); falling back to NLLB.`);
+		}
+		return run(NLLB_MODEL, texts, {
+			src_lang: src.nllb,
+			tgt_lang: dst.nllb
+		});
+	} };
+}
+const token = (i) => `X${i}X`;
+/** Prices, phone numbers, versions, hours, percentages: kept exactly as written. */
+const NUMBER = /[$€£¥]?\d+(?:[.,:\-/]\d+)*(?:[a-zA-Z]{1,2}\b)?%?/g;
+/** Runtime values like {name} must survive translation untouched. */
+const PLACEHOLDER = /\{\w+\}/g;
+/**
+* Swaps protected pieces for placeholders so the model leaves them alone: excluded phrases and glossary terms
+* (restored as given), {placeholders}, and numbers. `phrases[i]` is what `X{i}X` turns back into.
+*/
+function mask(text, exclude, opts = {}) {
+	const phrases = [];
+	const mark = (restore) => {
+		phrases.push(restore);
+		return String.fromCharCode(57344) + String.fromCharCode(57600 + phrases.length - 1) + String.fromCharCode(57345);
+	};
+	let masked = text;
+	const entries = [...exclude.map((p) => [p, p]), ...Object.entries(opts.glossary ?? {})].sort((a, b) => b[0].length - a[0].length);
+	for (const [from, to] of entries) if (from && masked.includes(from)) masked = masked.split(from).join(mark(to));
+	masked = masked.replace(PLACEHOLDER, (m) => mark(m));
+	if (opts.numbers !== false) masked = masked.replace(NUMBER, (m) => mark(m));
+	return {
+		masked: masked.replace(/\uE000([\uE100-\uE9FF])\uE001/g, (_, c) => token(c.charCodeAt(0) - 57600)),
+		phrases
+	};
+}
+/** Puts protected pieces back. Returns null if the model dropped or mangled a placeholder. */
+function unmask(translated, phrases) {
+	let out = translated;
+	for (let i = 0; i < phrases.length; i++) {
+		if (!out.includes(token(i))) return null;
+		out = out.split(token(i)).join(phrases[i]);
+	}
+	return /X\d+X/.test(out) ? null : out;
+}
+/** True if every run of digits in the source still appears in the translation. */
+function digitsPreserved(source, translated) {
+	const key = (s) => (s.match(/\d+/g) ?? []).sort().join(",");
+	return key(source) === key(translated);
+}
+//#endregion
+//#region src/core/cache.ts
+/** Where versions before the CLI workflow kept translations (keyed by source text). Read only, for migration. */
+function legacyCacheDir(root) {
+	return path.join(root, "node_modules", ".cache", "react-autolocale");
+}
+function legacyCacheFile(root, lang) {
+	return path.join(legacyCacheDir(root), `${lang}.json`);
+}
+/** Strings that are entirely an excluded phrase need no translation. */
+function needsTranslation(s, exclude) {
+	return !exclude.includes(s.trim());
+}
+/**
+* Machine-translates `strings` with protected pieces masked. Strings whose result lost a placeholder or changed
+* a number are retried once with numbers locked; if that fails too they are reported in `failed`, never
+* returned as a wrong or empty translation. Provider errors propagate to the caller.
+*/
+async function translateTexts(opts) {
+	const { strings, exclude, translator } = opts;
+	const terms = opts.glossary ?? {};
+	const translated = {};
+	const failed = [];
+	for (const s of strings) if (terms[s]) translated[s] = terms[s];
+	const todo = strings.filter((s) => !terms[s]);
+	if (!todo.length) return {
+		translated,
+		failed
+	};
+	const ctx = todo.map((s) => opts.contexts?.[s] ?? "");
+	const run = async (items, contextList, numbers) => {
+		const jobs = items.map((s) => mask(s, exclude, {
+			glossary: terms,
+			numbers
+		}));
+		const out = await translator.translate(jobs.map((j) => j.masked), opts.from, opts.to, contextList);
+		return jobs.map((job, i) => unmask(out[i] ?? "", job.phrases));
+	};
+	const first = await run(todo, ctx, false);
+	const redo = todo.map((_, i) => i).filter((i) => !first[i] || !digitsPreserved(todo[i], first[i]));
+	const second = redo.length ? await run(redo.map((i) => todo[i]), redo.map((i) => ctx[i]), true) : [];
+	todo.forEach((source, i) => {
+		const result = redo.includes(i) ? second[redo.indexOf(i)] : first[i];
+		if (result && result.trim()) translated[source] = result;
+		else failed.push(source);
+	});
+	return {
+		translated,
+		failed
+	};
+}
+//#endregion
+//#region src/core/files.ts
+/** Writes through a temp file and a rename, so an interrupted run never leaves half a file behind. */
+function writeFileAtomic(file, content) {
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	fs.writeFileSync(tmp, content);
+	fs.renameSync(tmp, file);
+}
+/** Pretty JSON with sorted keys, so new entries land in place and diffs stay small. Skips unchanged files. */
+function writeJson(file, data) {
+	const content = JSON.stringify(sortKeys(data), null, 2) + "\n";
+	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === content) return false;
+	writeFileAtomic(file, content);
+	return true;
+}
+/** Missing file: `fallback`. Broken file: an error naming it (never silently treated as empty). */
+function readJson(file, fallback) {
+	if (!fs.existsSync(file)) return fallback;
+	try {
+		return JSON.parse(fs.readFileSync(file, "utf8"));
+	} catch (err) {
+		throw new Error(`${file} is not valid JSON (${err.message}). Fix or delete it, then run the command again.`);
+	}
+}
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((k) => [k, sortKeys(value[k])]));
+	return value;
+}
+//#endregion
+//#region src/core/banner.ts
+/** The banner phrases live next to the catalogs. */
+function bannerFile(output) {
+	return path.join(output, "banner.json");
+}
+/** Banner phrases for the plugin: the generated file, else what older versions cached, else English only. */
+function readBanner(output, root) {
+	const source = JSON.stringify(BANNER_EN);
+	for (const file of [bannerFile(output), path.join(legacyCacheDir(root), "_banner.json")]) try {
+		const { _source, ...langs } = JSON.parse(fs.readFileSync(file, "utf8"));
+		if (_source === source) return {
+			...langs,
+			en: BANNER_EN
+		};
+	} catch {}
+	return { en: BANNER_EN };
+}
+/** The banner's fixed phrases in every language, so a visitor sees them in their own language. */
+async function ensureBanner(opts) {
+	const source = JSON.stringify(BANNER_EN);
+	let cached = {};
+	try {
+		const file = JSON.parse(fs.readFileSync(bannerFile(opts.output), "utf8"));
+		if (file._source === source) cached = file;
+	} catch {}
+	const out = { en: BANNER_EN };
+	let changed = false;
+	const keys = Object.keys(BANNER_EN);
+	for (const lang of opts.langs) {
+		if (lang === "en") continue;
+		if (cached[lang]) {
+			out[lang] = cached[lang];
+			continue;
+		}
+		opts.log?.(`[react-autolocale] ${lang}: translating banner text...`);
+		const jobs = keys.map((k) => mask(BANNER_EN[k], ["{language}"]));
+		const translated = await opts.getTranslator().translate(jobs.map((j) => j.masked), "en", lang);
+		const text = { ...BANNER_EN };
+		keys.forEach((k, i) => {
+			text[k] = unmask(translated[i] ?? "", jobs[i].phrases) ?? BANNER_EN[k];
+		});
+		out[lang] = text;
+		cached[lang] = text;
+		changed = true;
+	}
+	if (changed) writeJson(bannerFile(opts.output), {
+		_source: source,
+		...cached
+	});
+	return out;
+}
+//#endregion
+//#region src/core/ids.ts
+/**
+* Stable id for a source string: a hash of its normalized text, so moving code or editing other files never
+* changes it. Identical text shares one id (and one translation). 40 bits keeps collisions out of reach for
+* any real app; `findCollisions` reports one if it ever happens.
+*/
+function messageId(text) {
+	return "msg_" + createHash("sha256").update(normalize(text)).digest("hex").slice(0, 10);
+}
+/** Whitespace runs collapse to one space, as they render in the browser. */
+function normalize(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+/** Different texts that hash to the same id. */
+function findCollisions(texts) {
+	const seen = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const text of texts) {
+		const id = messageId(text);
+		const prev = seen.get(id);
+		if (prev !== void 0 && normalize(prev) !== normalize(text)) out.push([prev, text]);
+		else seen.set(id, text);
+	}
+	return out;
+}
+//#endregion
+//#region src/core/head.ts
+const META_SELECTORS = [
+	"meta[name=\"description\"]",
+	"meta[property=\"og:title\"]",
+	"meta[property=\"og:description\"]",
+	"meta[name=\"twitter:title\"]",
+	"meta[name=\"twitter:description\"]"
+];
+/** Title and description-like tags worth translating (only used when seo is on). */
+function headStrings(html) {
+	const doc = new JSDOM(html).window.document;
+	const out = /* @__PURE__ */ new Set();
+	const title = doc.title.trim();
+	if (title && /\p{L}/u.test(title)) out.add(title);
+	for (const sel of META_SELECTORS) {
+		const v = doc.querySelector(sel)?.getAttribute("content")?.trim();
+		if (v && /\p{L}/u.test(v)) out.add(v);
+	}
+	return [...out];
+}
+function translateHead(doc, dict) {
+	const title = doc.title.trim();
+	if (title && dict[title]) doc.title = dict[title];
+	for (const sel of META_SELECTORS) {
+		const el = doc.querySelector(sel);
+		const v = el?.getAttribute("content")?.trim();
+		if (el && v && dict[v]) el.setAttribute("content", dict[v]);
+	}
+}
+//#endregion
+//#region src/core/transform.ts
+const traverse$1 = _traverse.default ?? _traverse;
+const generate = _generate.default ?? _generate;
+/** Attributes whose string value is user-visible text. */
+const TRANSLATABLE_ATTRS = /* @__PURE__ */ new Set([
+	"placeholder",
+	"title",
+	"alt",
+	"aria-label",
+	"aria-placeholder",
+	"aria-description"
+]);
+/** Elements whose text content is code, not copy. */
+const SKIP_ELEMENTS = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"code",
+	"pre",
+	"kbd",
+	"samp",
+	"svg",
+	"textarea"
+]);
+const T_IMPORT = "__RLT";
+const TD_IMPORT = "__RLTD";
+const HOOK_IMPORT = "__rlUseT";
+const HOOK_VAR = "__rl";
+const RUNTIME = "react-autolocale";
+function parserPlugins(file) {
+	if (/\.tsx$/.test(file)) return ["typescript", "jsx"];
+	if (/\.ts$/.test(file)) return ["typescript"];
+	return ["jsx"];
+}
+/** Collapses JSX text the way React does: lines are trimmed and joined with one space. */
+function cleanJsxText(raw) {
+	const lines = raw.split(/\r\n|\n|\r/);
+	let last = 0;
+	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.test(lines[i])) last = i;
+	let out = "";
+	for (let i = 0; i < lines.length; i++) {
+		let line = lines[i].replace(/\t/g, " ");
+		if (i !== 0) line = line.replace(/^[ ]+/, "");
+		if (i !== lines.length - 1) line = line.replace(/[ ]+$/, "");
+		if (line) {
+			if (i !== last) line += " ";
+			out += line;
+		}
+	}
+	return out;
+}
+/** Text worth translating: must contain at least one letter in any script. */
+function isTranslatable(text) {
+	return /\p{L}/u.test(text);
+}
+function isComponentName(name) {
+	return !!name && /^[A-Z]/.test(name);
+}
+/** Finds the function that is a React component (PascalCase name, possibly wrapped in memo/forwardRef). */
+function enclosingComponent(path) {
+	let p = path.parentPath;
+	while (p) {
+		if (p.isFunction()) {
+			const fn = p;
+			let name;
+			if ((fn.node.type === "FunctionDeclaration" || fn.node.type === "FunctionExpression") && fn.node.id) name = fn.node.id.name;
+			if (!name) {
+				let up = fn.parentPath;
+				while (up && up.isCallExpression()) up = up.parentPath;
+				if (up?.isVariableDeclarator() && t.isIdentifier(up.node.id)) name = up.node.id.name;
+			}
+			if (isComponentName(name)) return fn;
+		}
+		p = p.parentPath;
+	}
+	return null;
+}
+/** `translate="no"` on an element (or any ancestor) keeps its text and attributes exactly as written. */
+function hasNoTranslate(opening) {
+	return opening.attributes.some((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name: "translate" }) && (t.isStringLiteral(a.value, { value: "no" }) || t.isJSXExpressionContainer(a.value) && t.isStringLiteral(a.value.expression, { value: "no" })));
+}
+function insideNoTranslate(path) {
+	for (let p = path; p; p = p.parentPath) if (p.isJSXElement() && hasNoTranslate(p.node.openingElement)) return true;
+	return false;
+}
+/** A value we can safely hand to the runtime: `name`, `user.name`, `this.props.count`, `items?.[0]`. */
+function simpleValueName(node) {
+	const root = (n) => t.isIdentifier(n) || t.isThisExpression(n) || (t.isMemberExpression(n) || t.isOptionalMemberExpression(n)) && root(n.object) && (n.computed ? t.isNumericLiteral(n.property) || t.isStringLiteral(n.property) : t.isIdentifier(n.property));
+	if (!root(node)) return null;
+	if (t.isIdentifier(node)) return node.name;
+	if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) && !node.computed && t.isIdentifier(node.property)) return node.property.name;
+	return "value";
+}
+/**
+* "Hello {name}!" -> template "Hello {name}!" plus the values to fill in at runtime.
+* Only text mixed with plain variables qualifies: no nested elements, calls, conditions or JSX.
+*/
+function buildTemplate(node) {
+	let text = "";
+	const values = [];
+	const used = /* @__PURE__ */ new Set();
+	for (const child of node.children) if (t.isJSXText(child)) text += cleanJsxText(child.value);
+	else if (t.isJSXExpressionContainer(child)) {
+		const e = child.expression;
+		if (t.isJSXEmptyExpression(e)) continue;
+		if (t.isStringLiteral(e)) {
+			text += e.value;
+			continue;
+		}
+		const base = simpleValueName(e);
+		if (!base) return null;
+		let name = base;
+		for (let i = 2; used.has(name); i++) name = `${base}_${i}`;
+		used.add(name);
+		values.push({
+			name,
+			expr: e
+		});
+		text += `{${name}}`;
+	} else return null;
+	const letters = text.replace(/\{\w+\}/g, "");
+	if (!values.length || !isTranslatable(letters)) return null;
+	return {
+		text: text.trim(),
+		values,
+		lead: /^\s/.test(text),
+		trail: /\s$/.test(text)
+	};
+}
+/** Parses a file, extracts translatable strings, and rewrites JSX to render translations. */
+function transformJsx(code, file, opts = {}) {
+	const rewrite = opts.rewrite !== false;
+	if (!code.includes("<")) return null;
+	let ast;
+	try {
+		ast = parse(code, {
+			sourceType: "module",
+			sourceFilename: file,
+			plugins: parserPlugins(file)
+		});
+	} catch {
+		return null;
+	}
+	const strings = /* @__PURE__ */ new Set();
+	/** What kind of element each string sits in ("button", "h1", "placeholder", ...), for context-aware engines. */
+	const contexts = {};
+	const record = (text, context) => {
+		strings.add(text);
+		contexts[text] ??= context;
+	};
+	const hookTargets = /* @__PURE__ */ new Set();
+	let usedT = false;
+	let usedTD = false;
+	const space = () => t.jsxExpressionContainer(t.stringLiteral(" "));
+	traverse$1(ast, {
+		"JSXElement|JSXFragment"(path) {
+			const node = path.node;
+			const name = t.isJSXElement(node) && t.isJSXIdentifier(node.openingElement.name) ? node.openingElement.name.name : null;
+			if (name && SKIP_ELEMENTS.has(name)) return;
+			if (insideNoTranslate(path)) return;
+			const context = name ?? "text";
+			if (node.children.some((c) => t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression) && !t.isStringLiteral(c.expression))) {
+				const tpl = buildTemplate(node);
+				if (!tpl) return;
+				record(tpl.text, context);
+				if (!rewrite) return;
+				const valueObject = t.objectExpression(tpl.values.map((v) => t.objectProperty(t.identifier(v.name), t.cloneNode(v.expr))));
+				node.children = [
+					...tpl.lead ? [space()] : [],
+					t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TD_IMPORT), [
+						t.jsxAttribute(t.jsxIdentifier("i"), t.stringLiteral(messageId(tpl.text))),
+						t.jsxAttribute(t.jsxIdentifier("s"), t.stringLiteral(tpl.text)),
+						t.jsxAttribute(t.jsxIdentifier("v"), t.jsxExpressionContainer(valueObject))
+					], true), null, []),
+					...tpl.trail ? [space()] : []
+				];
+				usedTD = true;
+				return;
+			}
+			const children = [];
+			let changed = false;
+			for (const child of node.children) {
+				const cleaned = t.isJSXText(child) ? cleanJsxText(child.value) : "";
+				const text = cleaned.trim();
+				if (!t.isJSXText(child) || !text || !isTranslatable(text)) {
+					children.push(child);
+					continue;
+				}
+				record(text, context);
+				if (!rewrite) {
+					children.push(child);
+					continue;
+				}
+				if (/^\s/.test(cleaned)) children.push(space());
+				children.push(t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(T_IMPORT), [t.jsxAttribute(t.jsxIdentifier("i"), t.stringLiteral(messageId(text))), t.jsxAttribute(t.jsxIdentifier("s"), t.stringLiteral(text))], true), null, []));
+				if (/\s$/.test(cleaned)) children.push(space());
+				usedT = true;
+				changed = true;
+			}
+			if (changed) node.children = children;
+		},
+		JSXAttribute(path) {
+			const { name, value } = path.node;
+			if (!t.isJSXIdentifier(name) || !TRANSLATABLE_ATTRS.has(name.name)) return;
+			if (!t.isStringLiteral(value)) return;
+			const opening = path.parent;
+			if (!t.isJSXIdentifier(opening.name) || !/^[a-z]/.test(opening.name.name)) return;
+			if (insideNoTranslate(path.parentPath.parentPath)) return;
+			const text = value.value.trim();
+			if (!text || !isTranslatable(text)) return;
+			const component = enclosingComponent(path);
+			if (!component) return;
+			record(text, name.name);
+			if (!rewrite) return;
+			path.node.value = t.jsxExpressionContainer(t.callExpression(t.identifier(HOOK_VAR), [t.stringLiteral(messageId(text)), t.stringLiteral(text)]));
+			hookTargets.add(component);
+		}
+	});
+	if (strings.size === 0) return null;
+	if (!rewrite) return {
+		code,
+		map: null,
+		strings: [...strings],
+		contexts
+	};
+	for (const fn of hookTargets) {
+		if (!t.isBlockStatement(fn.node.body)) fn.node.body = t.blockStatement([t.returnStatement(fn.node.body)]);
+		fn.node.body.body.unshift(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(HOOK_VAR), t.callExpression(t.identifier(HOOK_IMPORT), []))]));
+	}
+	const specifiers = [];
+	if (usedT) specifiers.push(t.importSpecifier(t.identifier(T_IMPORT), t.identifier("__T")));
+	if (usedTD) specifiers.push(t.importSpecifier(t.identifier(TD_IMPORT), t.identifier("__TD")));
+	if (hookTargets.size) specifiers.push(t.importSpecifier(t.identifier(HOOK_IMPORT), t.identifier("__useT")));
+	ast.program.body.unshift(t.importDeclaration(specifiers, t.stringLiteral(RUNTIME)));
+	const out = generate(ast, {
+		sourceMaps: true,
+		sourceFileName: file
+	}, code);
+	return {
+		code: out.code,
+		map: out.map,
+		strings: [...strings],
+		contexts
+	};
+}
+/** Strings (and where they appear), without rewriting. */
+function extractItems(code, file) {
+	const r = transformJsx(code, file, { rewrite: false });
+	return {
+		strings: r?.strings ?? [],
+		contexts: r?.contexts ?? {}
+	};
+}
+//#endregion
+//#region src/core/scan.ts
+const EXTENSIONS = /* @__PURE__ */ new Set([
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+]);
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"coverage"
+]);
+function isSourceFile(file) {
+	return EXTENSIONS.has(path.extname(file)) && !file.endsWith(".d.ts") && !/\.(test|spec)\./.test(file);
+}
+function* walk(dir) {
+	if (!fs.existsSync(dir)) return;
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name.startsWith(".") || IGNORED_DIRS.has(entry.name)) continue;
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) yield* walk(full);
+		else if (isSourceFile(full)) yield full;
+	}
+}
+/** Every translatable string under the configured folders, in stable file order, and where each appears. */
+function scanProjectDetailed(root, include) {
+	const found = /* @__PURE__ */ new Set();
+	const contexts = {};
+	const files = {};
+	let fileCount = 0;
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) {
+		fileCount++;
+		const rel = path.relative(root, file).split(path.sep).join("/");
+		const items = extractItems(fs.readFileSync(file, "utf8"), file);
+		for (const s of items.strings) {
+			found.add(s);
+			contexts[s] ??= items.contexts[s] ?? "";
+			(files[s] ??= []).push(rel);
+		}
+	}
+	return {
+		strings: [...found],
+		contexts,
+		files,
+		fileCount
+	};
+}
+function manifestFile(project) {
+	return path.join(project.meta, "manifest.json");
+}
+function readManifest(project) {
+	const m = readJson(manifestFile(project), null);
+	if (m && m.version !== 1) throw new Error(`${manifestFile(project)} has version ${m.version}; this react-autolocale understands version 1. Update the package.`);
+	return m;
+}
+/** Scans the source, updates .auto-locale/manifest.json and the source-language catalog. Never translates. */
+function scanProject(project) {
+	const { root, site } = project;
+	const scan = scanProjectDetailed(root, project.include);
+	if (site.seo) {
+		const html = path.join(root, "index.html");
+		if (fs.existsSync(html)) for (const s of headStrings(fs.readFileSync(html, "utf8"))) {
+			if (!scan.files[s]) scan.strings.push(s);
+			scan.contexts[s] ??= "head";
+			(scan.files[s] ??= []).push("index.html");
+		}
+	}
+	const collisions = findCollisions(scan.strings);
+	if (collisions.length) throw new Error("Two different strings got the same message id (extremely rare). Reword one of them slightly:\n" + collisions.map(([a, b]) => `  "${a}"  vs  "${b}"`).join("\n"));
+	const prev = readManifest(project);
+	const messages = {};
+	for (const [id, m] of Object.entries(prev?.messages ?? {})) messages[id] = {
+		...m,
+		status: "unused"
+	};
+	const active = [];
+	const added = [];
+	for (const text of scan.strings) {
+		const id = messageId(text);
+		if (!prev?.messages[id]) added.push(id);
+		active.push(id);
+		messages[id] = {
+			text,
+			context: scan.contexts[text] ?? "",
+			files: [...new Set(scan.files[text] ?? [])].sort(),
+			status: "active"
+		};
+	}
+	const removed = Object.keys(messages).filter((id) => messages[id].status === "unused" && prev?.messages[id]?.status === "active");
+	const manifest = {
+		version: 1,
+		sourceLocale: site.original,
+		output: project.outputRel,
+		messages
+	};
+	writeJson(manifestFile(project), manifest);
+	writeJson(path.join(project.output, `${site.original}.json`), Object.fromEntries(Object.entries(messages).map(([id, m]) => [id, m.text])));
+	writeIndex(project);
+	return {
+		manifest,
+		fileCount: scan.fileCount,
+		active,
+		added,
+		removed,
+		previousOutput: prev && prev.output !== project.outputRel ? prev.output : void 0,
+		previousSource: prev && prev.sourceLocale !== site.original ? prev.sourceLocale : void 0
+	};
+}
+/** A small, stable module describing the catalogs, for code that wants to read them directly. */
+function writeIndex(project) {
+	const ts = fs.existsSync(path.join(project.root, "tsconfig.json"));
+	const file = path.join(project.output, ts ? "index.ts" : "index.js");
+	const locales = [project.site.original, ...project.site.languages];
+	const content = `// Generated by react-autolocale. Do not edit: run \`npx react-autolocale generate\` to update.\nexport const sourceLocale = ${JSON.stringify(project.site.original)};\nexport const locales = ${JSON.stringify(locales)}${ts ? " as const" : ""};\n/** Catalog files in this folder: message id -> text. */\nexport const catalogFiles = {${locales.map((l) => ` ${JSON.stringify(l)}: "./${l}.json"`).join(",")} };\n`;
+	if (!fs.existsSync(file) || fs.readFileSync(file, "utf8") !== content) writeFileAtomic(file, content);
+}
+//#endregion
+//#region src/core/catalog.ts
+function catalogFile(project, lang) {
+	return path.join(project.output, `${lang}.json`);
+}
+function readCatalog(project, lang) {
+	return readJson(catalogFile(project, lang), {});
+}
+/** A usable catalog value: non-empty text. Anything else counts as missing. */
+const valid = (v) => typeof v === "string" && v.trim() !== "";
+const cachePath = (project) => path.join(project.meta, "cache.json");
+function readCache(project) {
+	return readJson(cachePath(project), {
+		version: 1,
+		entries: {}
+	});
+}
+/**
+* Copies translations made by older versions (node_modules/.cache/react-autolocale, keyed by text) into the
+* cache, so upgrading never retranslates. The old files are left in place.
+*/
+function importLegacyCache(project) {
+	if (!fs.existsSync(legacyCacheDir(project.root))) return 0;
+	const cache = readCache(project);
+	let added = 0;
+	for (const lang of project.site.languages) {
+		const old = readJson(legacyCacheFile(project.root, lang), {});
+		const entries = cache.entries[lang] ??= {};
+		for (const [text, value] of Object.entries(old)) if (valid(value) && !entries[text]) entries[text] = {
+			value,
+			provider: "legacy"
+		}, added++;
+	}
+	if (added) writeJson(cachePath(project), cache);
+	return added;
+}
+/** Fills every active message missing from each target catalog. Valid existing entries are never replaced. */
+async function translateMissing(project, manifest, opts) {
+	const { site } = project;
+	const log = opts.log ?? (() => {});
+	const chunkSize = opts.chunkSize ?? 40;
+	const cache = readCache(project);
+	const report = { langs: {} };
+	const active = Object.entries(manifest.messages).filter(([, m]) => m.status === "active" && needsTranslation(m.text, site.exclude));
+	const contexts = Object.fromEntries(active.map(([, m]) => [m.text, m.context]));
+	for (const lang of opts.langs ?? site.languages) {
+		const r = {
+			kept: 0,
+			reused: 0,
+			translated: 0,
+			overridden: 0,
+			failed: []
+		};
+		report.langs[lang] = r;
+		const catalog = readCatalog(project, lang);
+		const cached = cache.entries[lang] ??= {};
+		const fixed = opts.overrides?.[lang] ?? {};
+		const terms = project.glossary[lang] ?? {};
+		const missing = [];
+		for (const [id, m] of active) if (valid(catalog[id])) r.kept++;
+		else if (valid(fixed[m.text])) r.overridden++;
+		else if (valid(cached[m.text]?.value)) catalog[id] = cached[m.text].value, r.reused++;
+		else if (valid(terms[m.text])) catalog[id] = terms[m.text], r.reused++;
+		else missing.push([id, m.text]);
+		if (r.reused) writeJson(catalogFile(project, lang), catalog);
+		if (!missing.length) continue;
+		log(`${lang}: translating ${missing.length} string${missing.length === 1 ? "" : "s"}...`);
+		for (let i = 0; i < missing.length; i += chunkSize) {
+			if (opts.shouldStop?.()) {
+				report.stopped ??= "interrupted";
+				break;
+			}
+			const chunk = missing.slice(i, i + chunkSize);
+			try {
+				const { translated, failed } = await translateTexts({
+					strings: chunk.map(([, text]) => text),
+					from: site.original,
+					to: lang,
+					exclude: site.exclude,
+					contexts,
+					glossary: terms,
+					translator: opts.translator
+				});
+				for (const [id, text] of chunk) if (valid(translated[text])) {
+					catalog[id] = translated[text];
+					cached[text] = {
+						value: translated[text],
+						provider: opts.providerName
+					};
+					r.translated++;
+				}
+				for (const text of failed) r.failed.push({
+					id: messageId(text),
+					text,
+					reason: "the result lost a number, placeholder or protected phrase"
+				});
+			} catch (err) {
+				const reason = err.message;
+				for (const [id, text] of chunk) r.failed.push({
+					id,
+					text,
+					reason
+				});
+				if (err.fatal) report.stopped = reason;
+			}
+			writeJson(catalogFile(project, lang), catalog);
+			writeJson(cachePath(project), cache);
+			log(`${lang}: ${Math.min(i + chunkSize, missing.length)}/${missing.length}`);
+			if (report.stopped) break;
+		}
+		if (report.stopped) break;
+	}
+	return report;
+}
+/** Removes ids from every catalog (source and targets). Returns how many entries were removed. */
+function removeFromCatalogs(project, ids) {
+	let removed = 0;
+	for (const lang of [project.site.original, ...project.site.languages]) {
+		const file = catalogFile(project, lang);
+		if (!fs.existsSync(file)) continue;
+		const catalog = readCatalog(project, lang);
+		for (const id of ids) if (id in catalog) delete catalog[id], removed++;
+		writeJson(file, catalog);
+	}
+	return removed;
+}
+/** Reads the generated catalogs (no translation, no network). Overrides win; legacy translations fill gaps. */
+function loadDicts(project, overrides = {}) {
+	const manifest = fs.existsSync(path.join(project.meta, "manifest.json")) ? readManifest(project) : null;
+	const source = readCatalog(project, project.site.original);
+	const legacyText = {};
+	const textOf = (id) => manifest?.messages[id]?.text ?? source[id] ?? legacyText[id];
+	const isActive = (id) => !manifest || manifest.messages[id]?.status === "active";
+	const out = {
+		byId: {},
+		byText: {},
+		missing: {},
+		usedLegacy: false
+	};
+	for (const lang of project.site.languages) {
+		const byId = {};
+		for (const [id, value] of Object.entries(readCatalog(project, lang))) if (valid(value) && isActive(id)) byId[id] = value;
+		for (const [text, value] of Object.entries(readJson(legacyCacheFile(project.root, lang), {}))) {
+			const id = messageId(text);
+			if (valid(value) && !byId[id] && (!manifest || isActive(id))) {
+				byId[id] = value;
+				legacyText[id] = text;
+				out.usedLegacy = true;
+			}
+		}
+		for (const [text, value] of Object.entries(overrides[lang] ?? {})) if (valid(value)) byId[messageId(text)] = value;
+		const byText = {};
+		for (const [id, value] of Object.entries(byId)) {
+			const text = textOf(id);
+			if (text) byText[text] = value;
+		}
+		for (const [text, value] of Object.entries(overrides[lang] ?? {})) if (valid(value)) byText[text] = value;
+		out.byId[lang] = byId;
+		out.byText[lang] = byText;
+		out.missing[lang] = manifest ? Object.entries(manifest.messages).filter(([id, m]) => m.status === "active" && needsTranslation(m.text, project.site.exclude) && !byId[id]).length : 0;
+	}
+	return out;
+}
+//#endregion
+//#region src/core/overrides.ts
+/** A committed file the developer edits to correct translations. It always wins over machine translation. */
+const OVERRIDES_FILE = "react-autolocale.overrides.json";
+function readOverrides(root) {
+	const file = path.join(root, OVERRIDES_FILE);
+	if (!fs.existsSync(file)) return {};
+	try {
+		return JSON.parse(fs.readFileSync(file, "utf8"));
+	} catch (err) {
+		throw new Error(`${OVERRIDES_FILE} is not valid JSON: ${err.message}`);
+	}
+}
+/** Later arguments win. */
+function mergeOverrides(...all) {
+	const out = {};
+	for (const o of all) for (const [lang, strings] of Object.entries(o ?? {})) out[lang] = {
+		...out[lang],
+		...strings
+	};
+	return out;
+}
+/**
+* Writes every generated translation into the overrides file (keeping entries already there) so it can be
+* edited. Reads the catalogs through `loadDicts`, which also covers translations made by older versions.
+*/
+function exportTranslations(project) {
+	const { byText } = loadDicts(project);
+	const generated = Object.fromEntries(Object.entries(byText).filter(([, d]) => Object.keys(d).length));
+	if (!Object.keys(generated).length) throw new Error("No generated translations found. Run `npx react-autolocale generate` first.");
+	const merged = mergeOverrides(generated, readOverrides(project.root));
+	const file = path.join(project.root, OVERRIDES_FILE);
+	writeJson(file, merged);
+	return {
+		file,
+		languages: Object.fromEntries(Object.entries(merged).map(([l, s]) => [l, Object.keys(s).length]))
+	};
+}
+//#endregion
+//#region src/core/paths.ts
+/** Internal bookkeeping (manifest, translation cache), kept apart from the catalogs the app uses. */
+const META_DIR = ".auto-locale";
+function hasRootSrc(root) {
+	try {
+		return fs.statSync(path.join(root, "src")).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Where catalogs are written, relative to the project root: an explicit `output` wins; otherwise
+* `src/generated/auto-locale` when the project has a root-level `src/`, else `generated/auto-locale`.
+*/
+function defaultOutput(root) {
+	return hasRootSrc(root) ? "src/generated/auto-locale" : "generated/auto-locale";
+}
+function resolveOutput(root, output) {
+	return path.resolve(root, output ?? defaultOutput(root));
+}
+function metaDir(root) {
+	return path.join(root, META_DIR);
+}
+/** Project-relative, forward slashes: how paths are stored in config and the manifest. */
+function toProjectPath(root, file) {
+	return path.relative(root, file).split(path.sep).join("/") || ".";
+}
+//#endregion
+//#region src/core/site.ts
+const traverse = _traverse.default ?? _traverse;
+function literal(node) {
+	if (!node) return void 0;
+	if (t.isJSXExpressionContainer(node)) return literal(node.expression);
+	if (t.isStringLiteral(node)) return node.value;
+	if (t.isBooleanLiteral(node)) return node.value;
+	if (t.isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0].value.cooked ?? void 0;
+	if (t.isArrayExpression(node)) {
+		const items = node.elements.map((e) => literal(e));
+		return items.every((i) => typeof i === "string") ? items : void 0;
+	}
+}
+/**
+* Reads the literal props of `<AutoScale ...>` from source code. Returns null if the file has none.
+* With `required: false` (languages come from auto-locale.config.ts), missing props are allowed.
+*/
+function parseAutoScale(code, file, opts = {}) {
+	if (!code.includes("AutoScale")) return null;
+	let ast;
+	try {
+		ast = parse(code, {
+			sourceType: "module",
+			plugins: parserPlugins(file)
+		});
+	} catch {
+		return null;
+	}
+	let found = null;
+	traverse(ast, { JSXOpeningElement(path) {
+		const name = path.node.name;
+		if (found || !t.isJSXIdentifier(name) || name.name !== "AutoScale") return;
+		const props = {};
+		for (const attr of path.node.attributes) if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) props[attr.name.name] = attr.value === null ? true : literal(attr.value);
+		const { original, languages, exclude, seo, siteUrl } = props;
+		if (opts.required !== false && (typeof original !== "string" || !Array.isArray(languages))) throw new Error(`${file}: <AutoScale> needs literal props, e.g. original="en" languages={["fr", "es"]}. Values must be written inline (not variables) so they can be read at build time.`);
+		found = {
+			original: typeof original === "string" ? original : "",
+			languages: Array.isArray(languages) ? languages.filter((l) => l !== original) : [],
+			exclude: Array.isArray(exclude) ? exclude : [],
+			seo: seo === true || seo === "true",
+			siteUrl: typeof siteUrl === "string" ? siteUrl : void 0
+		};
+	} });
+	return found;
+}
+function findSite(root, include, opts = {}) {
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) {
+		const site = parseAutoScale(fs.readFileSync(file, "utf8"), file, opts);
+		if (site) return site;
+	}
+	if (opts.required === false) return null;
+	throw new Error(`No <AutoScale> found in ${include.join(", ")}. Wrap your app: <AutoScale original="en" languages={["fr", "es"]}><App /></AutoScale>`);
+}
+/** Folders scanned for JSX. */
+function defaultInclude(root) {
+	return fs.existsSync(path.join(root, "src")) ? ["src"] : ["."];
+}
+//#endregion
+//#region src/core/project.ts
+const CONFIG_FILES = [
+	"auto-locale.config.ts",
+	"auto-locale.config.mts",
+	"auto-locale.config.js",
+	"auto-locale.config.mjs"
+];
+function findConfigFile(root) {
+	return CONFIG_FILES.map((f) => path.join(root, f)).find((f) => fs.existsSync(f));
+}
+/** Loads auto-locale.config.* through Vite's own config loader, so TypeScript works without extra tooling. */
+async function loadConfigFile(file, root) {
+	const { loadConfigFromFile } = await import("vite");
+	const loaded = await loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, file, root, "silent");
+	if (!loaded) throw new Error(`Could not load ${path.basename(file)}.`);
+	return loaded.config;
+}
+/** Throws a message that names the bad setting. */
+function validateConfig(config, file = "auto-locale.config.ts") {
+	const fail = (msg) => {
+		throw new Error(`${file}: ${msg}`);
+	};
+	if (config === null || typeof config !== "object") fail("must export an object, e.g. export default defineConfig({ ... }).");
+	const { sourceLocale, locales, output, include, exclude, provider } = config;
+	if (sourceLocale !== void 0 && (typeof sourceLocale !== "string" || !getLanguage(sourceLocale))) fail(`sourceLocale "${sourceLocale}" is not a supported language code.`);
+	if (locales !== void 0) {
+		if (!Array.isArray(locales) || !locales.length) fail(`locales must be a non-empty array, e.g. ["en", "fr"].`);
+		const bad = locales.filter((l) => typeof l !== "string" || !getLanguage(l));
+		if (bad.length) fail(`unsupported language code${bad.length > 1 ? "s" : ""}: ${bad.join(", ")}.`);
+	}
+	if (sourceLocale === void 0 !== (locales === void 0)) fail("set both sourceLocale and locales, or neither.");
+	if (output !== void 0 && (typeof output !== "string" || !output.trim())) fail("output must be a path string.");
+	for (const [key, value] of Object.entries({
+		include,
+		exclude
+	})) if (value !== void 0 && (!Array.isArray(value) || value.some((v) => typeof v !== "string"))) fail(`${key} must be an array of strings.`);
+	if (provider && typeof provider === "object" && !("translate" in provider)) {
+		if (!PROVIDER_NAMES.includes(provider.name)) fail(`provider.name must be one of ${PROVIDER_NAMES.join(", ")} (got "${provider.name}").`);
+		if (provider.name === "ollama" && !provider.model) fail(`provider "ollama" needs a model, e.g. { name: "ollama", model: "llama3.1" }.`);
+	}
+}
+async function loadProject(root, opts = {}) {
+	const configFile = findConfigFile(root);
+	const config = configFile ? await loadConfigFile(configFile, root) : {};
+	validateConfig(config, configFile ? path.basename(configFile) : void 0);
+	const include = config.include ?? defaultInclude(root);
+	let site;
+	if (config.sourceLocale && config.locales) {
+		const props = findSite(root, include, { required: false });
+		const languages = config.locales.filter((l) => l !== config.sourceLocale);
+		if (props?.original && (props.original !== config.sourceLocale || props.languages.join() !== languages.join())) opts.log?.(`[react-autolocale] <AutoScale> languages differ from ${path.basename(configFile)}; using the config file.`);
+		site = {
+			original: config.sourceLocale,
+			languages,
+			exclude: props?.exclude ?? [],
+			seo: props?.seo ?? false,
+			siteUrl: props?.siteUrl
+		};
+	} else site = findSite(root, include);
+	site.exclude = [.../* @__PURE__ */ new Set([...site.exclude, ...config.exclude ?? []])];
+	const output = resolveOutput(root, config.output);
+	return {
+		root,
+		configFile,
+		config,
+		site,
+		include,
+		output,
+		outputRel: toProjectPath(root, output),
+		meta: metaDir(root),
+		glossary: config.glossary ?? {}
+	};
+}
+//#endregion
+export { readBanner as A, isSourceFile as C, translateHead as D, transformJsx as E, toTranslator as F, getLanguage as I, TranslationError as M, createLocalTranslator as N, messageId as O, ollama as P, scanProject as S, parserPlugins as T, loadDicts as _, findSite as a, manifestFile as b, hasRootSrc as c, OVERRIDES_FILE as d, exportTranslations as f, importLegacyCache as g, catalogFile as h, defaultInclude as i, writeJson as j, ensureBanner as k, resolveOutput as l, readOverrides as m, loadConfigFile as n, META_DIR as o, mergeOverrides as p, loadProject as r, defaultOutput as s, findConfigFile as t, toProjectPath as u, removeFromCatalogs as v, walk as w, readManifest as x, translateMissing as y };