react-autolocale 0.0.0-stage → 0.1.0

package/dist/vite.js

@@ -0,0 +1,1242 @@
+import { n as redirectScript } from "./redirect-CKNY4ru5.js";
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import os from "node:os";
+import { pathToFileURL } from "node:url";
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import * as t from "@babel/types";
+import { JSDOM, VirtualConsole } from "jsdom";
+import { createServer } from "vite";
+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
+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 Error(`Could not install the translation engine automatically. Install it yourself: npm install -D @huggingface/transformers`);
+		}
+	}
+	const mod = await import(pathToFileURL(entry).href);
+	return mod.pipeline ? mod : mod.default;
+}
+const NLLB_MODEL = "Xenova/nllb-200-distilled-600M";
+const BATCH = 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} (first run downloads it)...`);
+			let lastPct = -10;
+			p = hf.then((m) => m.pipeline("translation", model, {
+				dtype: "q8",
+				progress_callback: (e) => {
+					if (e.status === "progress" && e.progress - lastPct >= 10) {
+						lastPct = e.progress;
+						log(`  downloading ${e.file}: ${Math.round(e.progress)}%`);
+					}
+				}
+			}));
+			pipes.set(model, p);
+		}
+		return p;
+	};
+	const run = async (model, texts, options) => {
+		const pipe = await getPipe(model);
+		const out = [];
+		for (let i = 0; i < texts.length; i += BATCH) {
+			const res = await pipe(texts.slice(i, i + BATCH), {
+				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`;
+/** Swaps excluded phrases for placeholders so the model leaves them alone. */
+function mask(text, exclude) {
+	const phrases = [];
+	let masked = text;
+	for (const phrase of [...exclude].sort((a, b) => b.length - a.length)) {
+		if (!phrase || !masked.includes(phrase)) continue;
+		masked = masked.split(phrase).join(token(phrases.length));
+		phrases.push(phrase);
+	}
+	return {
+		masked,
+		phrases
+	};
+}
+/** Puts excluded phrases 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;
+}
+//#endregion
+//#region src/core/cache.ts
+/** Generated translations live here, outside the source tree. */
+function cacheDir(root) {
+	return path.join(root, "node_modules", ".cache", "react-autolocale");
+}
+function cacheFile(root, lang) {
+	return path.join(cacheDir(root), `${lang}.json`);
+}
+function readDict(file) {
+	try {
+		return JSON.parse(fs.readFileSync(file, "utf8"));
+	} catch {
+		return {};
+	}
+}
+/** Strings that are entirely an excluded phrase need no translation. */
+function needsTranslation(s, exclude) {
+	return !exclude.includes(s.trim());
+}
+/** Translates only strings missing from the cache, drops unused ones, and returns every language's dictionary. */
+async function ensureTranslations(opts) {
+	const { root, site, strings } = opts;
+	const log = opts.log ?? (() => {});
+	const wanted = strings.filter((s) => needsTranslation(s, site.exclude));
+	const result = {};
+	fs.mkdirSync(cacheDir(root), { recursive: true });
+	for (const lang of site.languages) {
+		const file = cacheFile(root, lang);
+		const existing = readDict(file);
+		const fixed = opts.overrides?.[lang] ?? {};
+		const missing = wanted.filter((s) => !existing[s] && !fixed[s]);
+		const next = {};
+		for (const s of wanted) if (existing[s]) next[s] = existing[s];
+		for (const s of wanted) if (fixed[s]) next[s] = fixed[s];
+		if (missing.length) {
+			log(`[react-autolocale] ${lang}: translating ${missing.length} new string${missing.length === 1 ? "" : "s"}...`);
+			const jobs = missing.map((s) => ({
+				source: s,
+				...mask(s, site.exclude)
+			}));
+			const out = await opts.getTranslator().translate(jobs.map((j) => j.masked), site.original, lang);
+			jobs.forEach((job, i) => {
+				const restored = unmask(out[i] ?? "", job.phrases);
+				if (restored) next[job.source] = restored;
+				else log(`[react-autolocale] ${lang}: kept "${job.source}" untranslated (could not preserve excluded text)`);
+			});
+		}
+		if (!(JSON.stringify(existing) === JSON.stringify(next))) fs.writeFileSync(file, JSON.stringify(next, null, 2) + "\n");
+		result[lang] = next;
+	}
+	return result;
+}
+//#endregion
+//#region src/core/transform.ts
+const traverse$2 = _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-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 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);
+}
+/**
+* Text next to a `{expression}` is a sentence fragment ("Hello {name}"): translating the
+* pieces separately gives wrong results, so dynamic content is left for v2.
+*/
+function hasDynamicChild(node) {
+	return node.children.some((c) => t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression) && !t.isStringLiteral(c.expression));
+}
+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;
+}
+/** 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();
+	const hookTargets = /* @__PURE__ */ new Set();
+	let usedT = false;
+	traverse$2(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 (hasDynamicChild(node)) 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;
+				}
+				strings.add(text);
+				if (!rewrite) {
+					children.push(child);
+					continue;
+				}
+				const space = () => t.jsxExpressionContainer(t.stringLiteral(" "));
+				if (/^\s/.test(cleaned)) children.push(space());
+				children.push(t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(T_IMPORT), [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;
+			const text = value.value.trim();
+			if (!text || !isTranslatable(text)) return;
+			const component = enclosingComponent(path);
+			if (!component) return;
+			strings.add(text);
+			if (!rewrite) return;
+			path.node.value = t.jsxExpressionContainer(t.callExpression(t.identifier(HOOK_VAR), [t.stringLiteral(text)]));
+			hookTargets.add(component);
+		}
+	});
+	if (strings.size === 0) return null;
+	if (!rewrite) return {
+		code,
+		map: null,
+		strings: [...strings]
+	};
+	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 (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]
+	};
+}
+/** Strings only, without rewriting (used by `react-autolocale sync`). */
+function extractStrings(code, file) {
+	return transformJsx(code, file, { rewrite: false })?.strings ?? [];
+}
+//#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. */
+function scanProject(root, include) {
+	const found = /* @__PURE__ */ new Set();
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) for (const s of extractStrings(fs.readFileSync(file, "utf8"), file)) found.add(s);
+	return [...found];
+}
+//#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/routes.ts
+const traverse$1 = _traverse.default ?? _traverse;
+function str(node) {
+	if (t.isJSXExpressionContainer(node)) return str(node.expression);
+	if (t.isStringLiteral(node)) return node.value;
+	if (t.isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0].value.cooked ?? null;
+	return null;
+}
+/** "/a" + "b" -> "/a/b"; an absolute child replaces the parent. */
+function join(parent, child) {
+	if (child.startsWith("/")) return child;
+	return (parent.replace(/\/+$/, "") + "/" + child).replace(/\/+/g, "/");
+}
+/** Only fixed paths can become static pages: no :params, wildcards or optional segments. */
+function isStatic(p) {
+	return p.startsWith("/") && !/[:*?()]/.test(p);
+}
+function jsxRoutePath(el) {
+	if (!t.isJSXIdentifier(el.name) || el.name.name !== "Route") return null;
+	for (const a of el.attributes) if (t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name: "path" })) return str(a.value);
+	return null;
+}
+const PAGE_PROPS = /* @__PURE__ */ new Set([
+	"element",
+	"Component",
+	"lazy",
+	"index"
+]);
+/** A <Route> that only groups children (no element, Component, lazy or index) is not a page itself. */
+function jsxIsPage(el, hasChildren) {
+	if (!hasChildren) return true;
+	return el.attributes.some((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && PAGE_PROPS.has(a.name.name));
+}
+function objectIsPage(obj) {
+	if (!obj.properties.some((p) => t.isObjectProperty(p) && t.isIdentifier(p.key, { name: "children" }))) return true;
+	return obj.properties.some((p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && PAGE_PROPS.has(p.key.name));
+}
+function objectPath(obj) {
+	for (const p of obj.properties) if (t.isObjectProperty(p) && (t.isIdentifier(p.key, { name: "path" }) || t.isStringLiteral(p.key, { value: "path" }))) return str(p.value);
+	return null;
+}
+/** Static route paths defined in one file (React Router <Route path> and route objects with `path`). */
+function routesInCode(code, file) {
+	if (!code.includes("path")) return [];
+	let ast;
+	try {
+		ast = parse(code, {
+			sourceType: "module",
+			plugins: parserPlugins(file)
+		});
+	} catch {
+		return [];
+	}
+	const found = /* @__PURE__ */ new Set();
+	const add = (p) => isStatic(p) && found.add(p);
+	traverse$1(ast, {
+		JSXOpeningElement(p) {
+			const own = jsxRoutePath(p.node);
+			if (own === null) return;
+			const chain = [own];
+			for (let up = p.parentPath.parentPath; up; up = up.parentPath) if (up.isJSXElement()) {
+				const parentPath = jsxRoutePath(up.node.openingElement);
+				if (parentPath !== null) chain.unshift(parentPath);
+			}
+			const el = p.parent;
+			if (jsxIsPage(p.node, !!el.children?.some((c) => t.isJSXElement(c)))) add(chain.reduce((acc, seg) => join(acc, seg), "/"));
+		},
+		ObjectExpression(p) {
+			const own = objectPath(p.node);
+			if (own === null) return;
+			const chain = [own];
+			for (let up = p.parentPath; up; up = up.parentPath) if (up.isObjectProperty() && t.isIdentifier(up.node.key, { name: "children" })) {
+				const parentObj = up.parentPath;
+				if (parentObj?.isObjectExpression()) {
+					const parentPath = objectPath(parentObj.node);
+					if (parentPath !== null) chain.unshift(parentPath);
+				}
+			}
+			if (objectIsPage(p.node)) add(chain.reduce((acc, seg) => join(acc, seg), "/"));
+		}
+	});
+	return [...found];
+}
+/** Every static route found in the project's source folders. */
+function discoverRoutes(root, include) {
+	const all = /* @__PURE__ */ new Set();
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) for (const r of routesInCode(fs.readFileSync(file, "utf8"), file)) all.add(r);
+	return [...all];
+}
+//#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. */
+function parseAutoScale(code, file) {
+	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 (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,
+			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;
+}
+/** Finds the first <AutoScale> in the project's source folders. */
+function findSite(root, include) {
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) {
+		const site = parseAutoScale(fs.readFileSync(file, "utf8"), file);
+		if (site) return site;
+	}
+	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/vite/seo.ts
+const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+const restOf = (p) => p.pathname.slice(p.lang.length + 1) || "/";
+function buildSitemap(base, pages) {
+	const byRest = /* @__PURE__ */ new Map();
+	for (const p of pages) {
+		const rest = restOf(p);
+		byRest.set(rest, [...byRest.get(rest) ?? [], p.lang]);
+	}
+	return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:xhtml=\"http://www.w3.org/1999/xhtml\">\n" + pages.map((p) => {
+		const rest = restOf(p);
+		const alts = byRest.get(rest).map((l) => `    <xhtml:link rel="alternate" hreflang="${l}" href="${esc(base + "/" + l + rest)}"/>`).join("\n");
+		return `  <url>\n    <loc>${esc(base + p.pathname)}</loc>\n${alts}\n  </url>`;
+	}).join("\n") + `\n</urlset>\n`;
+}
+/**
+* seo mode: translated title/meta, canonical, hreflang alternates and a sitemap.
+* Only runs when <AutoScale seo> is set; without it these files are never touched.
+*/
+function applySeo(opts) {
+	const { outDir, site, dicts, pages, log } = opts;
+	const base = (site.siteUrl ?? "").replace(/\/+$/, "");
+	if (!base) log("[react-autolocale] seo: no siteUrl set, so hreflang and canonical use relative URLs and no sitemap is written. Add siteUrl=\"https://your-site.com\" to <AutoScale>.");
+	const langsByRest = /* @__PURE__ */ new Map();
+	for (const p of pages) langsByRest.set(restOf(p), [...langsByRest.get(restOf(p)) ?? [], p.lang]);
+	for (const page of pages) {
+		const rest = restOf(page);
+		const doc = new JSDOM(fs.readFileSync(page.file, "utf8")).window.document;
+		if (page.lang !== site.original) translateHead(doc, dicts[page.lang] ?? {});
+		doc.querySelectorAll("link[rel=\"canonical\"]").forEach((n) => n.remove());
+		const add = (attrs) => {
+			const link = doc.createElement("link");
+			for (const [k, v] of Object.entries(attrs)) link.setAttribute(k, v);
+			doc.head.append(link);
+		};
+		add({
+			rel: "canonical",
+			href: `${base}/${page.lang}${rest}`
+		});
+		const langs = langsByRest.get(rest);
+		for (const l of langs) add({
+			rel: "alternate",
+			hreflang: l,
+			href: `${base}/${l}${rest}`
+		});
+		add({
+			rel: "alternate",
+			hreflang: "x-default",
+			href: `${base}/${langs.includes(site.original) ? site.original : langs[0]}${rest}`
+		});
+		fs.writeFileSync(page.file, "<!DOCTYPE html>" + doc.documentElement.outerHTML);
+	}
+	if (base) {
+		const sitemapPages = pages.filter((p) => p.pathname.startsWith(`/${p.lang}/`) && p.file !== path.join(outDir, "index.html"));
+		fs.writeFileSync(path.join(outDir, "sitemap.xml"), buildSitemap(base, sitemapPages));
+		log("[react-autolocale] seo: wrote sitemap.xml (reference it from robots.txt)");
+	}
+}
+//#endregion
+//#region src/vite/prerender.ts
+const MAX_PAGES = 500;
+/** Normalizes an internal link like "/fr/about?x=1#y" to "/fr/about/", or returns [] for anything else. */
+function pageLink(href, lang) {
+	let url;
+	try {
+		url = new URL(href, `http://localhost/${lang}/`);
+	} catch {
+		return [];
+	}
+	if (url.origin !== "http://localhost") return [];
+	const p = url.pathname.replace(/\/+$/, "");
+	if (p !== `/${lang}` && !p.startsWith(`/${lang}/`)) return [];
+	if (/\.[a-z0-9]+$/i.test(p)) return [];
+	return [p + "/"];
+}
+/** Normalizes a user-supplied route like "thank-you" or "/users/1" to "/thank-you/"; null if unusable. */
+function routePath(route) {
+	const p = route.trim().split(/[?#]/)[0].replace(/^\/+|\/+$/g, "");
+	if (/^[a-z]{2,3}$/i.test(p) || /\.[a-z0-9]+$/i.test(p)) return p ? null : "/";
+	return p ? `/${p}/` : "/";
+}
+/** The module script in the project's index.html, e.g. "/src/main.tsx". */
+function findEntry(root) {
+	const html = fs.readFileSync(path.join(root, "index.html"), "utf8");
+	for (const tag of html.match(/<script\b[^>]*>/gi) ?? []) if (/type=["']module["']/i.test(tag)) {
+		const src = /src=["']([^"']+)["']/i.exec(tag)?.[1];
+		if (src) return src;
+	}
+	throw new Error("Could not find <script type=\"module\" src=...> in index.html.");
+}
+/** Makes the jsdom window the global scope, so browser-only code in the app can run in Node. Returns an undo function. */
+function installDom(dom) {
+	const win = dom.window;
+	const keys = /* @__PURE__ */ new Set([
+		"window",
+		"document",
+		"navigator",
+		"localStorage",
+		"sessionStorage",
+		"location",
+		"history"
+	]);
+	for (const k of Object.getOwnPropertyNames(win)) if (!(k in globalThis)) keys.add(k);
+	const saved = /* @__PURE__ */ new Map();
+	for (const k of keys) {
+		saved.set(k, Object.getOwnPropertyDescriptor(globalThis, k));
+		try {
+			Object.defineProperty(globalThis, k, {
+				configurable: true,
+				get: () => win[k]
+			});
+		} catch {}
+	}
+	return () => {
+		for (const [k, d] of saved) if (d) Object.defineProperty(globalThis, k, d);
+		else delete globalThis[k];
+	};
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Waits until the page has content and has stopped changing (so lazy routes and Suspense have resolved). */
+async function waitForRender(dom) {
+	const doc = dom.window.document;
+	const root = doc.getElementById("root");
+	const deadline = Date.now() + 1e4;
+	let last = "";
+	let changedAt = Date.now();
+	while (Date.now() < deadline) {
+		const now = (root ?? doc.body).innerHTML;
+		if (now !== last) last = now, changedAt = Date.now();
+		else if (now && Date.now() - changedAt >= 400) return;
+		await sleep(25);
+	}
+}
+/** Browser APIs apps commonly call during render that jsdom does not implement. */
+function polyfill(win) {
+	class Noop {
+		observe() {}
+		unobserve() {}
+		disconnect() {}
+		takeRecords() {
+			return [];
+		}
+	}
+	win.matchMedia ??= (query) => ({
+		matches: false,
+		media: query,
+		onchange: null,
+		addListener() {},
+		removeListener() {},
+		addEventListener() {},
+		removeEventListener() {},
+		dispatchEvent: () => false
+	});
+	win.ResizeObserver ??= Noop;
+	win.IntersectionObserver ??= Noop;
+	win.scrollTo ??= () => {};
+	win.Element.prototype.scrollIntoView ??= () => {};
+}
+/**
+* Renders the app once per language in a DOM and writes static pages: dist/<lang>/index.html
+* (and dist/index.html for the original language). Only #root's content and one inline state script
+* are added; everything else in the page is left as built.
+*/
+async function prerender(opts) {
+	const { root, outDir, site, include, dicts, log } = opts;
+	const extraRoutes = (opts.routes ?? []).map(routePath).filter((r) => r !== null);
+	const sourceUrls = include.flatMap((dir) => [...walk(path.resolve(root, dir))]).filter(isSourceFile).map((f) => "/" + path.relative(root, f).split(path.sep).join("/"));
+	const template = fs.readFileSync(path.join(outDir, "index.html"), "utf8");
+	const entry = findEntry(root);
+	const server = await createServer({
+		root,
+		appType: "custom",
+		logLevel: "silent",
+		server: {
+			middlewareMode: true,
+			hmr: false,
+			watch: null
+		}
+	});
+	const failures = [];
+	const pages = [];
+	const ssrEnv = server.environments?.ssr;
+	const runner = ssrEnv?.runner;
+	const loadModule = (url) => runner ? runner.import(url) : server.ssrLoadModule(url);
+	const resetModules = () => runner ? runner.clearCache() : server.moduleGraph.invalidateAll();
+	await Promise.all(sourceUrls.map((u) => (ssrEnv?.transformRequest ? ssrEnv.transformRequest(u) : server.transformRequest(u, { ssr: true })).catch(() => null)));
+	/** Renders one URL and returns the same-language page links found in it. */
+	async function renderPage(lang, pathname) {
+		const dict = lang === site.original ? {} : dicts[lang] ?? {};
+		const errors = [];
+		const virtualConsole = new VirtualConsole();
+		virtualConsole.on("jsdomError", (e) => errors.push(String(e.message).split("\n")[0]));
+		const dom = new JSDOM(template, {
+			url: `http://localhost${pathname}`,
+			pretendToBeVisual: true,
+			virtualConsole
+		});
+		const win = dom.window;
+		win.__AUTOSCALE__ = {
+			lang,
+			dict
+		};
+		win.addEventListener("error", (e) => errors.push(String(e.error?.message ?? e.message ?? e)));
+		polyfill(win);
+		const restore = installDom(dom);
+		try {
+			resetModules();
+			await loadModule(entry);
+			await waitForRender(dom);
+		} catch (err) {
+			errors.push(err.message);
+		} finally {
+			restore();
+		}
+		const rootEl = dom.window.document.getElementById("root");
+		if (errors.length || rootEl && !rootEl.childElementCount) {
+			failures.push({
+				pathname,
+				error: errors[0] ?? "the page rendered nothing"
+			});
+			dom.window.close();
+			return [];
+		}
+		const doc = dom.window.document;
+		doc.documentElement.lang = lang;
+		doc.documentElement.dir = getLanguage(lang)?.rtl ? "rtl" : "ltr";
+		const state = doc.createElement("script");
+		state.textContent = `window.__AUTOSCALE__=${JSON.stringify({
+			lang,
+			dict
+		}).replace(/</g, "\\u003c")}`;
+		doc.head.prepend(state);
+		const links = [...doc.querySelectorAll("a[href]")].flatMap((a) => pageLink(a.getAttribute("href"), lang));
+		const html = dom.serialize();
+		const dir = path.join(outDir, ...pathname.split("/").filter(Boolean));
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "index.html"), html);
+		pages.push({
+			lang,
+			pathname,
+			file: path.join(dir, "index.html")
+		});
+		if (pathname === `/${site.original}/`) {
+			const rootDoc = new JSDOM(html).window.document;
+			const redirect = rootDoc.createElement("script");
+			redirect.textContent = redirectScript([site.original, ...site.languages], site.original);
+			rootDoc.head.prepend(redirect);
+			const rootFile = path.join(outDir, "index.html");
+			fs.writeFileSync(rootFile, "<!DOCTYPE html>" + rootDoc.documentElement.outerHTML);
+			pages.push({
+				lang,
+				pathname,
+				file: rootFile
+			});
+		}
+		log(`[react-autolocale] wrote ${pathname}`);
+		dom.window.close();
+		return links;
+	}
+	try {
+		for (const lang of [site.original, ...site.languages]) {
+			const queue = [`/${lang}/`, ...extraRoutes.map((r) => `/${lang}${r}`)];
+			const seen = new Set(queue);
+			if (seen.size < queue.length) queue.splice(0, queue.length, ...seen);
+			for (let i = 0; i < queue.length; i++) for (const next of await renderPage(lang, queue[i])) if (!seen.has(next) && seen.size < MAX_PAGES) seen.add(next), queue.push(next);
+		}
+		if (failures.length) throw new Error(`${failures.length} page(s) failed to prerender:\n` + failures.map((f) => `  ${f.pathname}  ${f.error}`).join("\n"));
+		if (site.seo) applySeo({
+			outDir,
+			site,
+			dicts,
+			pages,
+			log
+		});
+	} finally {
+		await server.close();
+	}
+}
+//#endregion
+//#region src/vite/index.ts
+const VIRTUAL_ID = "virtual:react-autolocale";
+const RESOLVED_ID = "\0" + VIRTUAL_ID;
+function reactAutolocale(options = {}) {
+	let config;
+	let root = process.cwd();
+	let include = [];
+	let includeDirs = [];
+	let site;
+	let dicts = {};
+	let translator;
+	let server;
+	let rendered = false;
+	const log = (msg) => console.log(msg);
+	const getTranslator = () => translator ??= createLocalTranslator(log);
+	async function refresh() {
+		include = options.include ?? defaultInclude(root);
+		includeDirs = include.map((d) => path.resolve(root, d) + path.sep);
+		site = findSite(root, include);
+		const strings = scanProject(root, include);
+		if (site.seo) {
+			const html = path.join(root, "index.html");
+			if (fs.existsSync(html)) strings.push(...headStrings(fs.readFileSync(html, "utf8")));
+		}
+		dicts = await ensureTranslations({
+			root,
+			site,
+			strings,
+			getTranslator,
+			log,
+			overrides: options.overrides
+		});
+	}
+	function virtualModule() {
+		const meta = site.languages.map((code) => ({
+			code,
+			native: getLanguage(code)?.native ?? code,
+			rtl: !!getLanguage(code)?.rtl
+		}));
+		const loaders = site.languages.filter((code) => fs.existsSync(cacheFile(root, code))).map((code) => `${JSON.stringify(code)}: () => import(${JSON.stringify(cacheFile(root, code))})`);
+		return [
+			`export const original = ${JSON.stringify(site.original)};`,
+			`export const originalNative = ${JSON.stringify(getLanguage(site.original)?.native ?? site.original)};`,
+			`export const seo = ${JSON.stringify(site.seo)};`,
+			`export const languages = ${JSON.stringify(meta)};`,
+			`export const loaders = { ${loaders.join(", ")} };`
+		].join("\n");
+	}
+	let timer;
+	let busy = false;
+	function scheduleRefresh() {
+		clearTimeout(timer);
+		timer = setTimeout(async () => {
+			if (busy || !server) return;
+			busy = true;
+			try {
+				await refresh();
+				const mod = server.moduleGraph.getModuleById(RESOLVED_ID);
+				if (mod) server.moduleGraph.invalidateModule(mod);
+				server.ws.send({ type: "full-reload" });
+			} catch (err) {
+				log(`[react-autolocale] ${err.message}`);
+			} finally {
+				busy = false;
+			}
+		}, 400);
+	}
+	return {
+		name: "react-autolocale",
+		enforce: "pre",
+		config() {
+			return {
+				optimizeDeps: { exclude: ["react-autolocale"] },
+				ssr: { noExternal: ["react-autolocale"] },
+				test: { server: { deps: { inline: ["react-autolocale"] } } }
+			};
+		},
+		configResolved(resolved) {
+			config = resolved;
+			root = resolved.root;
+		},
+		configureServer(s) {
+			server = s;
+		},
+		async buildStart() {
+			if (config.build.ssr) return;
+			await refresh();
+		},
+		resolveId(id) {
+			return id === VIRTUAL_ID ? RESOLVED_ID : null;
+		},
+		load(id) {
+			return id === RESOLVED_ID ? virtualModule() : null;
+		},
+		transform(code, id) {
+			const file = id.split("?")[0];
+			if (file.startsWith("\0") || file.includes("node_modules") || !isSourceFile(file)) return null;
+			if (!includeDirs.some((d) => file.startsWith(d))) return null;
+			const result = transformJsx(code, file);
+			if (!result) return null;
+			if (config.command === "serve" && site) {
+				if (!site.languages.every((l) => result.strings.every((s) => site.exclude.includes(s.trim()) || dicts[l]?.[s]))) scheduleRefresh();
+			}
+			return {
+				code: result.code,
+				map: result.map
+			};
+		},
+		closeBundle: {
+			order: "post",
+			async handler() {
+				if (config.command !== "build" || config.build.ssr || rendered) return;
+				rendered = true;
+				const extra = typeof options.routes === "function" ? await options.routes() : options.routes ?? [];
+				const routes = [.../* @__PURE__ */ new Set([...discoverRoutes(root, include), ...extra])];
+				await prerender({
+					root,
+					outDir: path.resolve(root, config.build.outDir),
+					site,
+					include,
+					routes,
+					dicts,
+					log
+				});
+			}
+		}
+	};
+}
+//#endregion
+export { reactAutolocale as default, reactAutolocale };