react-autolocale 0.0.0-stage → 0.2.0

package/dist/vite.js

@@ -0,0 +1,938 @@
+import { a as redirectScript, t as BANNER_EN } from "./suggestion-UZQ8ngd0.js";
+import { a as cacheDir, c as createLocalTranslator, d as toTranslator, f as unmask, i as readOverrides, l as mask, o as cacheFile, p as getLanguage, r as mergeOverrides, s as ensureTranslations, t as OVERRIDES_FILE, u as ollama } from "./overrides-ZQ6meLck.js";
+import fs from "node:fs";
+import path from "node:path";
+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";
+//#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 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$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 (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("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("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(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 = {};
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) {
+		const items = extractItems(fs.readFileSync(file, "utf8"), file);
+		for (const s of items.strings) {
+			found.add(s);
+			contexts[s] ??= items.contexts[s] ?? "";
+		}
+	}
+	return {
+		strings: [...found],
+		contexts
+	};
+}
+//#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/banner.ts
+const FILE = (root) => path.join(cacheDir(root), "_banner.json");
+/** 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(FILE(opts.root), "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) {
+		fs.mkdirSync(cacheDir(opts.root), { recursive: true });
+		fs.writeFileSync(FILE(opts.root), JSON.stringify({
+			_source: source,
+			...cached
+		}, null, 2) + "\n");
+	}
+	return out;
+}
+//#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 banner = {};
+	let translator;
+	let server;
+	let rendered = false;
+	const log = (msg) => console.log(msg);
+	const getTranslator = () => translator ??= options.engine ? toTranslator(options.engine) : 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, contexts } = scanProjectDetailed(root, include);
+		if (site.seo) {
+			const html = path.join(root, "index.html");
+			if (fs.existsSync(html)) strings.push(...headStrings(fs.readFileSync(html, "utf8")));
+		}
+		banner = await ensureBanner({
+			root,
+			langs: [site.original, ...site.languages],
+			getTranslator,
+			log
+		});
+		dicts = await ensureTranslations({
+			root,
+			site,
+			strings,
+			getTranslator,
+			log,
+			contexts,
+			glossary: options.glossary,
+			overrides: mergeOverrides(readOverrides(root), 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 banner = ${JSON.stringify(banner)};`,
+			`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;
+			const file = path.resolve(root, OVERRIDES_FILE);
+			s.watcher.add(file);
+			s.watcher.on("change", (changed) => changed === file && scheduleRefresh());
+		},
+		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, ollama };