react-autolocale 0.3.0-beta.1 → 0.5.0

package/dist/{project-BazDFtnp.js → project-DcYRIvym.js}

@@ -1,7 +1,7 @@
 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 { r as PROVIDER_NAMES } from "./config-ChdN65Rg.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";
@@ -10,8 +10,8 @@ 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";
+import _generate from "@babel/generator";
 const byCode = new Map([
 	{
 		code: "en",
@@ -661,8 +661,208 @@ function translateHead(doc, dict) {
 	}
 }
 //#endregion
+//#region src/core/walk.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|stories|story)\./.test(file);
+}
+/** Source files under `dir`. `skip` lists absolute folders to leave out (the generated catalogs, internal metadata). */
+function* walk(dir, skip = [], matches = isSourceFile) {
+	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 (skip.some((d) => path.resolve(d) === full)) continue;
+		if (entry.isDirectory()) yield* walk(full, skip, matches);
+		else if (matches(full)) yield full;
+	}
+}
+//#endregion
+//#region src/core/classify.ts
+/**
+* Decides whether a string written in code is text a person reads, or a code value (a URL, a class name, a CSS
+* value, an identifier, ...). Text in JSX and in known display attributes is always translated; this is for
+* strings found in data, props, ternaries and the like, where being wrong in either direction matters.
+*/
+const NOT_COPY_WORDS = /* @__PURE__ */ new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS",
+	"JSON",
+	"UTF-8",
+	"ASC",
+	"DESC",
+	"NULL",
+	"TRUE",
+	"FALSE",
+	"LTR",
+	"RTL",
+	"CSS",
+	"HTML",
+	"NONE",
+	"AUTO",
+	"DEFAULT",
+	"UNKNOWN",
+	"ERROR",
+	"SUCCESS",
+	"WARNING",
+	"INFO",
+	"DEBUG"
+]);
+/** Letters in any script. */
+const HAS_LETTER = /\p{L}/u;
+/** A single token: no spaces. */
+function singleToken(text) {
+	if (/^\p{Lu}\p{Ll}+$/u.test(text)) return true;
+	if (/^\p{Lu}{2,}$/u.test(text) && !NOT_COPY_WORDS.has(text)) return true;
+	if (/[^\x00-\x7f]/.test(text) && !/[_$\-./:]/.test(text) && !/\d/.test(text)) return true;
+	return false;
+}
+function looksLikeCopy(raw) {
+	const text = raw.trim();
+	if (text.length < 2 || !HAS_LETTER.test(text)) return false;
+	if (/^(?:https?:|ftp:|mailto:|tel:|sms:|data:|blob:|file:|javascript:|\/\/|\/|\.{1,2}\/|#|@|~\/)/i.test(text)) return false;
+	if (/:\/\//.test(text)) return false;
+	if (/^[\w.+-]+@[\w-]+\.[\w.-]+$/.test(text)) return false;
+	if (!/\s/.test(text) && /^[\w\-./@]+\.[a-z0-9]{1,5}$/i.test(text)) return false;
+	if (/^[a-z]+\/[a-z0-9.+-]+$/i.test(text)) return false;
+	if (/^[a-z]{2,3}-[A-Z][A-Za-z]{1,3}$/.test(text)) return false;
+	if (/^(?:rgba?|hsla?|var|calc|url|translate[XYZ3d]*|rotate[XYZ]?|scale[XYZ]?|matrix|linear-gradient|radial-gradient|conic-gradient|cubic-bezier|steps|polygon|inset|circle|ellipse)\(/i.test(text)) return false;
+	if (/(?:sans-serif|serif|monospace|system-ui|cursive)\b/i.test(text)) return false;
+	if (/^[\d.]+(?:px|rem|em|vh|vw|vmin|vmax|ms|s|deg|fr|ch|pt|cm|mm)(?:\s|$)/i.test(text)) return false;
+	if (/^[MmLlHhVvCcSsQqTtAaZz]\s*-?[\d.]/.test(text)) return false;
+	if (/[\w-]+\s*:\s*[^;]+;/.test(text)) return false;
+	if (/=>|<\/?[a-z][\w-]*[\s>/]|\{\s*\}|\(\s*\)\s*;|^function\b|^import\s|^const\s/.test(text)) return false;
+	if (/^[YMDHhmsaAZ\-/:.\s,]+$/.test(text)) return false;
+	if (!/\s/.test(text)) return singleToken(text.replace(/^[("“'\[]+|[.…!?:;,)"”'\]]+$/g, ""));
+	const tokens = text.split(/\s+/);
+	if (tokens.every((w) => /^[a-z][a-z0-9_:\-\/\[\].%!#]*$/.test(w)) && tokens.some((w) => /[-:_\[\]\/%!#\d]/.test(w))) return false;
+	if (tokens.length <= 3 && tokens.every((w) => /^[a-z][a-z0-9]*$|[a-z][A-Z]|_/.test(w) && /^[A-Za-z_$][\w$.]*$/.test(w)) && tokens.some((w) => /[a-z][A-Z]|_/.test(w))) return false;
+	return true;
+}
+/** Attributes on any element or component whose value is code, never text. */
+const NON_DISPLAY_ATTRS = /* @__PURE__ */ new Set([
+	"className",
+	"class",
+	"classes",
+	"style",
+	"id",
+	"key",
+	"ref",
+	"href",
+	"src",
+	"srcSet",
+	"srcset",
+	"to",
+	"path",
+	"htmlFor",
+	"type",
+	"rel",
+	"target",
+	"method",
+	"action",
+	"lang",
+	"dir",
+	"charSet",
+	"value",
+	"defaultValue",
+	"checked",
+	"d",
+	"viewBox",
+	"fill",
+	"stroke",
+	"transform",
+	"xmlns",
+	"width",
+	"height",
+	"size",
+	"variant",
+	"color",
+	"align",
+	"position",
+	"mode",
+	"kind",
+	"intent",
+	"tone",
+	"as",
+	"icon",
+	"iconName",
+	"image",
+	"img",
+	"src2",
+	"autoComplete",
+	"inputMode",
+	"accept",
+	"pattern",
+	"media",
+	"sizes",
+	"loading",
+	"crossOrigin",
+	"decoding",
+	"preserveAspectRatio",
+	"fontFamily",
+	"queryKey",
+	"testId",
+	"locale",
+	"format",
+	"selector",
+	"event"
+]);
+/** Object keys whose value is code, never text. */
+const NON_COPY_KEYS = /* @__PURE__ */ new Set([
+	...NON_DISPLAY_ATTRS,
+	"url",
+	"uri",
+	"route",
+	"slug",
+	"logo",
+	"bg",
+	"background",
+	"colour",
+	"font",
+	"transition",
+	"animation",
+	"display",
+	"cursor",
+	"overflow",
+	"justify",
+	"points",
+	"mask",
+	"filter",
+	"clipPath",
+	"mime",
+	"regex",
+	"hash",
+	"token",
+	"secret",
+	"apiKey",
+	"env",
+	"mutationKey",
+	"values",
+	"option",
+	"initialValue",
+	"labelKey",
+	"valueKey",
+	"imageUrl"
+]);
+//#endregion
 //#region src/core/transform.ts
-const traverse$1 = _traverse.default ?? _traverse;
+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([
@@ -688,7 +888,155 @@ const T_IMPORT = "__RLT";
 const TD_IMPORT = "__RLTD";
 const HOOK_IMPORT = "__rlUseT";
 const HOOK_VAR = "__rl";
+const GLOBAL_TEXT = "__rlText";
+const GLOBAL_FMT = "__rlFmt";
 const RUNTIME = "react-autolocale";
+/** Calls whose string arguments are code: selectors, event names, storage keys, paths, class helpers, logging, analytics. */
+const NON_COPY_CALLS = /* @__PURE__ */ new Set([
+	"require",
+	"import",
+	"fetch",
+	"axios",
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"request",
+	"querySelector",
+	"querySelectorAll",
+	"getElementById",
+	"getElementsByClassName",
+	"getElementsByTagName",
+	"getAttribute",
+	"setAttribute",
+	"removeAttribute",
+	"hasAttribute",
+	"closest",
+	"matches",
+	"matchMedia",
+	"addEventListener",
+	"removeEventListener",
+	"dispatchEvent",
+	"emit",
+	"on",
+	"off",
+	"once",
+	"createElementNS",
+	"classList",
+	"add",
+	"remove",
+	"toggle",
+	"contains",
+	"clsx",
+	"classnames",
+	"classNames",
+	"cn",
+	"cx",
+	"twMerge",
+	"tw",
+	"css",
+	"styled",
+	"keyframes",
+	"createContext",
+	"getItem",
+	"setItem",
+	"removeItem",
+	"stringify",
+	"parse",
+	"parseInt",
+	"parseFloat",
+	"Number",
+	"String",
+	"Boolean",
+	"Date",
+	"URL",
+	"URLSearchParams",
+	"RegExp",
+	"Symbol",
+	"Intl",
+	"NumberFormat",
+	"DateTimeFormat",
+	"split",
+	"join",
+	"replace",
+	"replaceAll",
+	"includes",
+	"indexOf",
+	"lastIndexOf",
+	"startsWith",
+	"endsWith",
+	"match",
+	"matchAll",
+	"search",
+	"test",
+	"exec",
+	"localeCompare",
+	"padStart",
+	"padEnd",
+	"repeat",
+	"normalize",
+	"charAt",
+	"log",
+	"warn",
+	"error",
+	"info",
+	"debug",
+	"trace",
+	"assert",
+	"table",
+	"group",
+	"defineProperty",
+	"hasOwnProperty",
+	"has",
+	"set",
+	"oneOf",
+	"oneOfType",
+	"enum",
+	"literal",
+	"nativeEnum",
+	"useQuery",
+	"useQueries",
+	"useInfiniteQuery",
+	"useMutation",
+	"invalidateQueries",
+	"setQueryData",
+	"getQueryData",
+	"prefetchQuery",
+	"track",
+	"trackEvent",
+	"logEvent",
+	"capture",
+	"captureMessage",
+	"captureException",
+	"gtag",
+	"navigate",
+	"redirect",
+	"createSlice",
+	"createAction",
+	"createAsyncThunk",
+	"registerPlugin",
+	"lazy",
+	"loadScript",
+	"useRef",
+	"useId",
+	"useMedia"
+]);
+/** Variable names that hold code. */
+const NON_COPY_VARS = /(?:class|style|url|href|src|path|color|font|slug|route|selector|regex|pattern|format|mime|token|secret|env|event|icon|image|img|logo|key|id)s?$/i;
+const COMPARISON_OPS = /* @__PURE__ */ new Set([
+	"===",
+	"!==",
+	"==",
+	"!=",
+	"<",
+	">",
+	"<=",
+	">=",
+	"in",
+	"instanceof"
+]);
+const IGNORE_COMMENT = /(?:i18n|autolocale|auto-locale)[- ]ignore|translate\s*:\s*no/i;
 function parserPlugins(file) {
 	if (/\.tsx$/.test(file)) return ["typescript", "jsx"];
 	if (/\.ts$/.test(file)) return ["typescript"];
@@ -718,25 +1066,137 @@ function isTranslatable(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). */
+/** A function that may call hooks: a component, or a custom hook named useX. */
+function canCallHooks(name) {
+	return isComponentName(name) || !!name && /^use[A-Z0-9]/.test(name);
+}
+function functionName(fn) {
+	if ((fn.node.type === "FunctionDeclaration" || fn.node.type === "FunctionExpression") && fn.node.id) return fn.node.id.name;
+	let up = fn.parentPath;
+	while (up && up.isCallExpression()) up = up.parentPath;
+	if (up?.isVariableDeclarator() && t.isIdentifier(up.node.id)) return up.node.id.name;
+}
+/**
+* The component (or custom hook) whose body contains `path`, so a translation hook can be added to it. Callbacks
+* inside a component count; a default parameter value does not (it runs before the hook line), and neither does
+* module-level code: those use the global lookup instead.
+*/
 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;
+	let prev = path;
+	for (let p = path.parentPath; p; prev = p, p = p.parentPath) {
+		if (!p.isFunction()) continue;
+		if (prev.listKey === "params") return null;
+		if (canCallHooks(functionName(p))) return p;
 	}
 	return null;
 }
+function calleeName(callee) {
+	if (t.isIdentifier(callee)) return callee.name;
+	if ((t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) && !callee.computed && t.isIdentifier(callee.property)) return callee.property.name;
+	return "";
+}
+const HTML_DISPLAY_ATTRS = /* @__PURE__ */ new Set([
+	...TRANSLATABLE_ATTRS,
+	"aria-roledescription",
+	"aria-valuetext",
+	"label"
+]);
+/** data-* attributes that tooltip libraries show to people. */
+const DISPLAY_DATA_ATTR = /^data-(?:[\w-]*(?:tooltip|tip|title|label|content))/;
+const isDisplayAttr = (name, html) => (html ? HTML_DISPLAY_ATTRS.has(name) : false) || DISPLAY_DATA_ATTR.test(name);
+/** True where the code needs the exact value of a string: comparisons, keys, types, selectors, paths, class helpers... */
+function inCodePosition(path) {
+	const parent = path.parent;
+	if (path.findParent((p) => p.isTSType() || p.isTSTypeAnnotation() || p.isTSInterfaceDeclaration() || p.isTSTypeAliasDeclaration() || p.isTSEnumDeclaration() || p.isTSModuleDeclaration())) return true;
+	if (t.isImportDeclaration(parent) || t.isExportNamedDeclaration(parent) || t.isExportAllDeclaration(parent)) return true;
+	if ((t.isObjectProperty(parent) || t.isObjectMethod(parent) || t.isClassProperty(parent) || t.isClassMethod(parent)) && path.key === "key" && !parent.computed) return true;
+	if (t.isMemberExpression(parent) && parent.computed && path.key === "property") return true;
+	if (t.isBinaryExpression(parent) && COMPARISON_OPS.has(parent.operator)) return true;
+	if (t.isSwitchCase(parent) && path.key === "test") return true;
+	if (t.isTaggedTemplateExpression(parent)) return true;
+	if (t.isAssignmentExpression(parent) && path.key === "right") {
+		const l = parent.left;
+		const nm = t.isMemberExpression(l) && !l.computed && t.isIdentifier(l.property) ? l.property.name : "";
+		if (NON_COPY_KEYS.has(nm) || nm === "cookie") return true;
+	}
+	let prev = path;
+	for (let p = path.parentPath; p; prev = p, p = p.parentPath) {
+		if (p.isFunction()) break;
+		if (p.isJSXAttribute()) {
+			const n = t.isJSXIdentifier(p.node.name) ? p.node.name.name : "";
+			const opening = p.parent;
+			const html = t.isJSXIdentifier(opening.name) && /^[a-z]/.test(opening.name.name);
+			if (NON_DISPLAY_ATTRS.has(n) || /^on[A-Z]/.test(n)) return true;
+			if (n.startsWith("data-") && !DISPLAY_DATA_ATTR.test(n)) return true;
+			if (html && !isDisplayAttr(n, true)) return true;
+			break;
+		}
+		if ((p.isCallExpression() || p.isNewExpression()) && prev.listKey === "arguments" && NON_COPY_CALLS.has(calleeName(p.node.callee))) return true;
+		if (p.isThrowStatement()) return true;
+		if (p.isObjectProperty() && prev.key === "value") {
+			const k = p.node.key;
+			const name = t.isIdentifier(k) ? k.name : t.isStringLiteral(k) ? k.value : "";
+			if (NON_COPY_KEYS.has(name)) return true;
+		}
+		if (p.isVariableDeclarator() && prev.key === "init" && t.isIdentifier(p.node.id) && NON_COPY_VARS.test(p.node.id.name)) return true;
+		if (p.isBinaryExpression() && COMPARISON_OPS.has(p.node.operator)) return true;
+	}
+	return false;
+}
+/** Hook calls whose arguments are read once or kept between renders, so a hook-based lookup would go stale. */
+const DEFERRED_HOOKS = /* @__PURE__ */ new Set([
+	"useState",
+	"useReducer",
+	"useRef",
+	"useMemo",
+	"useCallback",
+	"useEffect",
+	"useLayoutEffect",
+	"useInsertionEffect",
+	"useImperativeHandle",
+	"useSyncExternalStore",
+	"useTransition",
+	"useDeferredValue",
+	"createContext",
+	"createRef",
+	"memo",
+	"forwardRef"
+]);
+/** Is the string inside the arguments of one of those calls (up to the component that owns it)? */
+function inDeferredHookArgs(path) {
+	for (let p = path.parentPath; p; p = p.parentPath) {
+		if (p.isCallExpression() && DEFERRED_HOOKS.has(calleeName(p.node.callee))) return true;
+		if (p.isFunction() && canCallHooks(functionName(p))) break;
+	}
+	return false;
+}
+/** `// i18n-ignore` (or autolocale-ignore) on the string or its statement leaves it alone. */
+function hasIgnoreComment(path) {
+	for (let p = path; p; p = p.parentPath) {
+		const n = p.node;
+		if ([...n.leadingComments ?? [], ...n.trailingComments ?? []].some((c) => IGNORE_COMMENT.test(c.value))) return true;
+		if (p.isStatement()) break;
+	}
+	return false;
+}
+/** The element, attribute, property or call a string belongs to, so engines can translate it with context. */
+function contextOf(path) {
+	for (let p = path.parentPath; p; p = p.parentPath) {
+		if (p.isJSXAttribute() && t.isJSXIdentifier(p.node.name)) return p.node.name.name;
+		if (p.isObjectProperty()) {
+			const k = p.node.key;
+			if (t.isIdentifier(k)) return k.name;
+			if (t.isStringLiteral(k)) return k.value;
+		}
+		if (p.isJSXElement() && t.isJSXIdentifier(p.node.openingElement.name)) return p.node.openingElement.name.name;
+		if (p.isCallExpression()) {
+			const n = calleeName(p.node.callee);
+			if (n) return n;
+		}
+		if (p.isFunction()) break;
+	}
+	return "text";
+}
 /** `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" })));
@@ -745,43 +1205,78 @@ 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]`. */
+/** A readable placeholder name for `name`, `user.name`, `this.props.count`; null for anything else. */
 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";
+	return null;
+}
+/** Hands out placeholder names: readable ones where possible ({name}), otherwise {1}, {2}, ... */
+function namer() {
+	const used = /* @__PURE__ */ new Set();
+	let n = 0;
+	return (expr) => {
+		const base = simpleValueName(expr);
+		if (base) {
+			let name = base;
+			for (let i = 2; used.has(name); i++) name = `${base}_${i}`;
+			used.add(name);
+			return name;
+		}
+		let name;
+		do
+			name = String(++n);
+		while (used.has(name));
+		used.add(name);
+		return name;
+	};
+}
+/** Does this JSX element show any text of its own (as opposed to being an icon, image or spacer)? */
+function carriesText(el) {
+	return el.children.some((c) => t.isJSXText(c) && isTranslatable(cleanJsxText(c.value)) || t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression) && !t.isStringLiteral(c.expression) || t.isJSXElement(c) && carriesText(c));
 }
 /**
-* "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.
+* A sentence made of text plus variables, links, bold words or other elements becomes one message with
+* placeholders: "Read the {1} now", "Welcome, {name}". The pieces keep their own markup and are filled in at
+* runtime, so word order can change per language. Elements that only decorate (icons, images) stay out of it.
 */
 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 name = namer();
+	let hasTextRun = false;
+	let hasMoving = false;
+	for (const child of node.children) if (t.isJSXText(child)) {
+		const run = cleanJsxText(child.value);
+		if (isTranslatable(run)) hasTextRun = true;
+		text += run;
+	} 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);
+		const n = name(e);
 		values.push({
-			name,
+			name: n,
 			expr: e
 		});
-		text += `{${name}}`;
+		text += `{${n}}`;
+		hasMoving = true;
+	} else if (t.isJSXElement(child) || t.isJSXFragment(child)) {
+		const n = name(child);
+		values.push({
+			name: n,
+			expr: child
+		});
+		text += `{${n}}`;
+		if (carriesText(child)) hasMoving = true;
 	} else return null;
 	const letters = text.replace(/\{\w+\}/g, "");
-	if (!values.length || !isTranslatable(letters)) return null;
+	if (!values.length || !hasTextRun || !hasMoving || !isTranslatable(letters)) return null;
 	return {
 		text: text.trim(),
 		values,
@@ -789,10 +1284,11 @@ function buildTemplate(node) {
 		trail: /\s$/.test(text)
 	};
 }
-/** Parses a file, extracts translatable strings, and rewrites JSX to render translations. */
+/** Parses a file, extracts translatable strings, and rewrites the code to look them up at runtime. */
 function transformJsx(code, file, opts = {}) {
 	const rewrite = opts.rewrite !== false;
-	if (!code.includes("<")) return null;
+	const codeValues = opts.facts?.codeValues ?? /* @__PURE__ */ new Set();
+	if (!/["'`<]/.test(code)) return null;
 	let ast;
 	try {
 		ast = parse(code, {
@@ -811,33 +1307,78 @@ function transformJsx(code, file, opts = {}) {
 		contexts[text] ??= context;
 	};
 	const hookTargets = /* @__PURE__ */ new Set();
+	const generated = /* @__PURE__ */ new WeakSet();
 	let usedT = false;
 	let usedTD = false;
+	let usedGlobal = false;
+	let usedGlobalFmt = false;
 	const space = () => t.jsxExpressionContainer(t.stringLiteral(" "));
-	traverse$1(ast, {
+	/** Local names of `msg` imported from react-autolocale: msg("text") always means "translate this". */
+	const msgNames = /* @__PURE__ */ new Set();
+	for (const node of ast.program.body) {
+		if (!t.isImportDeclaration(node) || node.source.value !== RUNTIME) continue;
+		for (const sp of node.specifiers) if (t.isImportSpecifier(sp) && (t.isIdentifier(sp.imported, { name: "msg" }) || t.isStringLiteral(sp.imported, { value: "msg" }))) msgNames.add(sp.local.name);
+	}
+	const lit = (v) => {
+		const n = t.stringLiteral(v);
+		generated.add(n);
+		return n;
+	};
+	/** `__rl(id, text)` inside a component (follows language changes), `__rlText(id, text)` anywhere else. */
+	const lookup = (path, text) => {
+		const host = inDeferredHookArgs(path) ? null : enclosingComponent(path);
+		if (host) {
+			hookTargets.add(host);
+			return t.callExpression(t.identifier(HOOK_VAR), [lit(messageId(text)), lit(text)]);
+		}
+		usedGlobal = true;
+		return t.callExpression(t.identifier(GLOBAL_TEXT), [lit(messageId(text)), lit(text)]);
+	};
+	const lookupFmt = (path, text, values) => {
+		const vars = t.objectExpression(values.map((v) => t.objectProperty(/^\d+$/.test(v.name) ? t.numericLiteral(Number(v.name)) : t.identifier(v.name), v.expr)));
+		const host = inDeferredHookArgs(path) ? null : enclosingComponent(path);
+		if (host) {
+			hookTargets.add(host);
+			return t.callExpression(t.memberExpression(t.identifier(HOOK_VAR), t.identifier("f")), [
+				lit(messageId(text)),
+				lit(text),
+				vars
+			]);
+		}
+		usedGlobalFmt = true;
+		return t.callExpression(t.identifier(GLOBAL_FMT), [
+			lit(messageId(text)),
+			lit(text),
+			vars
+		]);
+	};
+	/** Common gate for a string found in code (not JSX text, which is always text). */
+	const isCopyHere = (path, text) => looksLikeCopy(text) && !codeValues.has(text.trim()) && !inCodePosition(path) && !hasIgnoreComment(path) && !insideNoTranslate(path);
+	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 (name && (SKIP_ELEMENTS.has(name) || name === T_IMPORT || name === TD_IMPORT)) 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))) {
+			if (node.children.some((c) => t.isJSXElement(c) || t.isJSXFragment(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;
+				if (tpl) {
+					record(tpl.text, context);
+					if (!rewrite) return;
+					const valueObject = t.objectExpression(tpl.values.map((v) => t.objectProperty(/^\d+$/.test(v.name) ? t.numericLiteral(Number(v.name)) : 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;
@@ -863,19 +1404,130 @@ function transformJsx(code, file, opts = {}) {
 		},
 		JSXAttribute(path) {
 			const { name, value } = path.node;
-			if (!t.isJSXIdentifier(name) || !TRANSLATABLE_ATTRS.has(name.name)) return;
-			if (!t.isStringLiteral(value)) return;
+			if (!t.isJSXIdentifier(name) || !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;
+			if (!t.isJSXIdentifier(opening.name)) return;
+			const tag = opening.name.name;
+			if (tag === T_IMPORT || tag === TD_IMPORT) return;
+			if (insideNoTranslate(path.parentPath.parentPath) || hasIgnoreComment(path)) return;
+			const html = /^[a-z]/.test(tag);
 			const text = value.value.trim();
 			if (!text || !isTranslatable(text)) return;
-			const component = enclosingComponent(path);
-			if (!component) return;
+			const attr = (n) => opening.attributes.find((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name: n }));
+			const literalOf = (a) => a && t.isStringLiteral(a.value) ? a.value.value : void 0;
+			let translate = false;
+			if (html) {
+				translate = isDisplayAttr(name.name, true);
+				if (name.name === "value" && tag === "input" && [
+					"submit",
+					"button",
+					"reset"
+				].includes(literalOf(attr("type")) ?? "")) translate = true;
+				if (name.name === "content" && tag === "meta") {
+					const who = literalOf(attr("name")) ?? literalOf(attr("property")) ?? "";
+					translate = [
+						"description",
+						"og:title",
+						"og:description",
+						"twitter:title",
+						"twitter:description"
+					].includes(who);
+				}
+			} else if (!NON_DISPLAY_ATTRS.has(name.name) && !/^on[A-Z]/.test(name.name) && !(name.name.startsWith("data-") && !DISPLAY_DATA_ATTR.test(name.name))) translate = looksLikeCopy(text) && !codeValues.has(text);
+			if (!translate) 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);
+			path.node.value = t.jsxExpressionContainer(lookup(path, text));
+		},
+		CallExpression(path) {
+			const callee = path.node.callee;
+			if (!t.isIdentifier(callee) || !msgNames.has(callee.name)) return;
+			const [arg, vars] = path.node.arguments;
+			let text = null;
+			let values = [];
+			let object = t.isObjectExpression(vars) ? vars : null;
+			if (t.isStringLiteral(arg)) text = arg.value;
+			else if (t.isTemplateLiteral(arg)) {
+				const name = namer();
+				text = arg.quasis[0].value.cooked ?? "";
+				arg.expressions.forEach((e, i) => {
+					const n = name(e);
+					values.push({
+						name: n,
+						expr: e
+					});
+					text += `{${n}}` + (arg.quasis[i + 1].value.cooked ?? "");
+				});
+			}
+			if (text === null || !/\S/.test(text)) return;
+			generated.add(arg);
+			record(text, "msg");
+			if (!rewrite) return;
+			const vs = object ? object.properties.flatMap((p) => t.isObjectProperty(p) && !p.computed && (t.isIdentifier(p.key) || t.isStringLiteral(p.key)) ? [{
+				name: t.isIdentifier(p.key) ? p.key.name : p.key.value,
+				expr: p.value
+			}] : []) : values;
+			path.replaceWith(vs.length ? lookupFmt(path, text, vs) : lookup(path, text));
+		},
+		StringLiteral(path) {
+			if (generated.has(path.node) || t.isJSXAttribute(path.parent)) return;
+			const text = path.node.value;
+			if (text !== text.trim() || !isCopyHere(path, text)) return;
+			record(text, contextOf(path));
+			if (rewrite) path.replaceWith(lookup(path, text));
+		},
+		TemplateLiteral(path) {
+			if (generated.has(path.node)) return;
+			const { quasis, expressions } = path.node;
+			const name = namer();
+			let text = quasis[0].value.cooked ?? "";
+			const values = [];
+			expressions.forEach((e, i) => {
+				if (t.isJSXElement(e) || t.isJSXFragment(e) || t.isTSType(e)) return;
+				const n = name(e);
+				values.push({
+					name: n,
+					expr: e
+				});
+				text += `{${n}}` + (quasis[i + 1].value.cooked ?? "");
+			});
+			if (values.length !== expressions.length) return;
+			if (text !== text.trim() || !isCopyHere(path, text.replace(/\{\w+\}/g, "0"))) return;
+			record(text, contextOf(path));
+			if (rewrite) path.replaceWith(values.length ? lookupFmt(path, text, values) : lookup(path, text));
+		},
+		BinaryExpression(path) {
+			if (path.node.operator !== "+" || generated.has(path.node)) return;
+			if (t.isBinaryExpression(path.parent, { operator: "+" })) return;
+			const leaves = [];
+			const flatten = (n) => {
+				if (t.isBinaryExpression(n, { operator: "+" })) {
+					flatten(n.left);
+					flatten(n.right);
+				} else leaves.push(n);
+			};
+			flatten(path.node);
+			const isText = (n) => t.isStringLiteral(n) || t.isTemplateLiteral(n) && n.expressions.length === 0;
+			const firstText = leaves.findIndex(isText);
+			if (firstText < 0 || firstText > 1) return;
+			if (leaves.some((n) => t.isJSXElement(n) || t.isJSXFragment(n))) return;
+			const name = namer();
+			let text = "";
+			const values = [];
+			for (const leaf of leaves) if (t.isStringLiteral(leaf)) text += leaf.value;
+			else if (t.isTemplateLiteral(leaf) && leaf.expressions.length === 0) text += leaf.quasis[0].value.cooked ?? "";
+			else {
+				const n = name(leaf);
+				values.push({
+					name: n,
+					expr: leaf
+				});
+				text += `{${n}}`;
+			}
+			if (text !== text.trim() || !isCopyHere(path, text.replace(/\{\w+\}/g, "0"))) return;
+			record(text, contextOf(path));
+			leaves.forEach((l) => generated.add(l));
+			if (rewrite) path.replaceWith(values.length ? lookupFmt(path, text, values) : lookup(path, text));
 		}
 	});
 	if (strings.size === 0) return null;
@@ -893,6 +1545,8 @@ function transformJsx(code, file, opts = {}) {
 	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")));
+	if (usedGlobal) specifiers.push(t.importSpecifier(t.identifier(GLOBAL_TEXT), t.identifier("__rlText")));
+	if (usedGlobalFmt) specifiers.push(t.importSpecifier(t.identifier(GLOBAL_FMT), t.identifier("__rlFmt")));
 	ast.program.body.unshift(t.importDeclaration(specifiers, t.stringLiteral(RUNTIME)));
 	const out = generate(ast, {
 		sourceMaps: true,
@@ -906,55 +1560,261 @@ function transformJsx(code, file, opts = {}) {
 	};
 }
 /** Strings (and where they appear), without rewriting. */
-function extractItems(code, file) {
-	const r = transformJsx(code, file, { rewrite: false });
+function extractItems(code, file, facts) {
+	const r = transformJsx(code, file, {
+		rewrite: false,
+		facts
+	});
 	return {
 		strings: r?.strings ?? [],
 		contexts: r?.contexts ?? {}
 	};
 }
 //#endregion
-//#region src/core/scan.ts
-const EXTENSIONS = /* @__PURE__ */ new Set([
-	".tsx",
-	".jsx",
-	".ts",
-	".js"
+//#region src/core/facts.ts
+const traverse$1 = _traverse.default ?? _traverse;
+/** Methods whose string argument is compared against something. */
+const COMPARING_METHODS = /* @__PURE__ */ new Set([
+	"includes",
+	"indexOf",
+	"lastIndexOf",
+	"startsWith",
+	"endsWith",
+	"has",
+	"equals",
+	"localeCompare"
 ]);
-const IGNORED_DIRS = /* @__PURE__ */ new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"coverage"
+const COMPARISONS = /* @__PURE__ */ new Set([
+	"===",
+	"!==",
+	"==",
+	"!=",
+	"in",
+	"instanceof"
 ]);
-function isSourceFile(file) {
-	return EXTENSIONS.has(path.extname(file)) && !file.endsWith(".d.ts") && !/\.(test|spec)\./.test(file);
+/** String values this file uses as code. */
+function codeValuesIn(code, file) {
+	const out = /* @__PURE__ */ new Set();
+	let ast;
+	try {
+		ast = parse(code, {
+			sourceType: "module",
+			plugins: parserPlugins(file)
+		});
+	} catch {
+		return out;
+	}
+	const add = (n) => {
+		if (t.isStringLiteral(n)) out.add(n.value);
+		else if (t.isTemplateLiteral(n) && n.expressions.length === 0) out.add(n.quasis[0].value.cooked ?? "");
+	};
+	traverse$1(ast, {
+		BinaryExpression(p) {
+			if (COMPARISONS.has(p.node.operator)) {
+				add(p.node.left);
+				add(p.node.right);
+			}
+		},
+		SwitchCase(p) {
+			add(p.node.test);
+		},
+		ObjectProperty(p) {
+			const k = p.node.key;
+			if (!p.node.computed && t.isIdentifier(k)) out.add(k.name);
+			else add(k);
+		},
+		ObjectMethod(p) {
+			if (!p.node.computed && t.isIdentifier(p.node.key)) out.add(p.node.key.name);
+		},
+		MemberExpression(p) {
+			if (p.node.computed) add(p.node.property);
+		},
+		CallExpression(p) {
+			const c = p.node.callee;
+			const name = t.isIdentifier(c) ? c.name : t.isMemberExpression(c) && t.isIdentifier(c.property) ? c.property.name : "";
+			if (COMPARING_METHODS.has(name)) p.node.arguments.forEach((a) => add(a));
+			if (t.isMemberExpression(c) && t.isIdentifier(c.property) && COMPARING_METHODS.has(c.property.name) && t.isArrayExpression(c.object)) c.object.elements.forEach((e) => add(e));
+		},
+		TSLiteralType(p) {
+			add(p.node.literal);
+		},
+		TSEnumMember(p) {
+			add(p.node.initializer);
+			if (t.isIdentifier(p.node.id)) out.add(p.node.id.name);
+		},
+		TSAsExpression(p) {
+			if (t.isTSTypeReference(p.node.typeAnnotation) && t.isIdentifier(p.node.typeAnnotation.typeName, { name: "const" })) {
+				const e = p.node.expression;
+				if (t.isArrayExpression(e)) e.elements.forEach((x) => add(x));
+				if (t.isObjectExpression(e)) e.properties.forEach((pr) => t.isObjectProperty(pr) && add(pr.value));
+			}
+		}
+	});
+	return out;
 }
-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;
+/** Per-file code values, so one edited file can be re-read without scanning the project again. */
+var FactsIndex = class {
+	perFile = /* @__PURE__ */ new Map();
+	union = null;
+	set(file, code) {
+		this.perFile.set(file, codeValuesIn(code, file));
+		this.union = null;
+	}
+	delete(file) {
+		this.perFile.delete(file);
+		this.union = null;
+	}
+	facts() {
+		this.union ??= new Set([...this.perFile.values()].flatMap((s) => [...s]));
+		return { codeValues: this.union };
+	}
+};
+/** Reads every source file under `include` once. */
+function buildFactsIndex(root, include) {
+	const index = new FactsIndex();
+	for (const dir of include) for (const file of walk(path.resolve(root, dir))) index.set(file, fs.readFileSync(file, "utf8"));
+	return index;
+}
+function collectProjectFacts(root, include) {
+	return buildFactsIndex(root, include).facts();
+}
+//#endregion
+//#region src/core/json.ts
+/**
+* Text kept in JSON data files (`import content from "./content.json"`): products, FAQs, team members, page copy.
+* A string value is translated when it reads like text and its key is not a code key (id, url, type, ...).
+*/
+/** JSON files that are configuration, not content. */
+const NOT_CONTENT = /(?:^|\/)(?:package(?:-lock)?|tsconfig[\w.-]*|jsconfig|composer|\.?eslintrc|\.?prettierrc|vercel|netlify|firebase|\w+\.config|[\w.-]+\.schema|manifest)\.json$/i;
+function isContentJson(file, skipDirs = []) {
+	const norm = file.split(path.sep).join("/");
+	if (!norm.endsWith(".json") || NOT_CONTENT.test(norm) || norm.includes("/node_modules/")) return false;
+	return !skipDirs.some((d) => norm.startsWith(d.split(path.sep).join("/").replace(/\/?$/, "/")));
+}
+function eligible(text, key, facts) {
+	return text === text.trim() && !NON_COPY_KEYS.has(key) && !key.startsWith("$") && looksLikeCopy(text) && !facts?.codeValues.has(text);
+}
+/** The translatable strings in a JSON document, in document order. */
+function jsonStrings(raw, facts) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		return [];
+	}
+	const out = [];
+	const visit = (v, key) => {
+		if (typeof v === "string") {
+			if (eligible(v, key, facts)) out.push({
+				text: v,
+				key
+			});
+		} else if (Array.isArray(v)) v.forEach((x) => visit(x, key));
+		else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) visit(x, k);
+	};
+	visit(data, "");
+	return out;
+}
+const IDENT = /^[A-Za-z_$][\w$]*$/;
+const RESERVED = /* @__PURE__ */ new Set([
+	"default",
+	"class",
+	"function",
+	"var",
+	"let",
+	"const",
+	"new",
+	"delete",
+	"return",
+	"if",
+	"else",
+	"for",
+	"while",
+	"do",
+	"switch",
+	"case",
+	"this",
+	"typeof",
+	"void",
+	"with",
+	"yield",
+	"import",
+	"export",
+	"enum",
+	"null",
+	"true",
+	"false"
+]);
+/**
+* A JavaScript module equivalent to Vite's own JSON import (default export plus a named export per key), with
+* translatable strings wrapped in lookups that run when the module loads.
+*/
+function jsonModule(raw, facts) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		return null;
 	}
+	if (/"__proto__"\s*:/.test(raw)) return null;
+	let used = false;
+	const write = (v, key) => {
+		if (typeof v === "string") {
+			if (!eligible(v, key, facts)) return JSON.stringify(v);
+			used = true;
+			return `__rlText(${JSON.stringify(messageId(v))},${JSON.stringify(v)})`;
+		}
+		if (Array.isArray(v)) return `[${v.map((x) => write(x, key)).join(",")}]`;
+		if (v && typeof v === "object") return `{${Object.entries(v).map(([k, x]) => `${JSON.stringify(k)}:${write(x, k)}`).join(",")}}`;
+		return JSON.stringify(v);
+	};
+	const body = write(data, "");
+	if (!used) return null;
+	return `import { __rlText } from "react-autolocale";\nconst __data = ${body};\nexport default __data;\n${(data && typeof data === "object" && !Array.isArray(data) ? Object.keys(data).filter((k) => IDENT.test(k) && !RESERVED.has(k)).map((k) => `export const ${k} = __data[${JSON.stringify(k)}];`) : []).join("\n")}\n`;
 }
+//#endregion
+//#region src/core/scan.ts
+/** `from "./data.json"`, `import("./data.json")`, `require("./data.json")` */
+const JSON_IMPORT = /(?:from\s*|import\s*\(?\s*|require\s*\(\s*)["']([^"']+\.json)["']/g;
 /** Every translatable string under the configured folders, in stable file order, and where each appears. */
-function scanProjectDetailed(root, include) {
+function scanProjectDetailed(root, include, opts = {}) {
+	const skip = opts.skip ?? [];
 	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))) {
+	const facts = collectProjectFacts(root, include);
+	const add = (text, context, rel) => {
+		found.add(text);
+		contexts[text] ??= context;
+		const list = files[text] ??= [];
+		if (!list.includes(rel)) list.push(rel);
+	};
+	const sourceFiles = [];
+	for (const dir of include) sourceFiles.push(...walk(path.resolve(root, dir), skip));
+	const jsonOnDisk = include.flatMap((dir) => [...walk(path.resolve(root, dir), skip, (f) => isContentJson(f, skip))]);
+	const importedJson = /* @__PURE__ */ new Set();
+	for (const file of sourceFiles) {
 		fileCount++;
+		const code = fs.readFileSync(file, "utf8");
 		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);
+		const items = extractItems(code, file, facts);
+		for (const s of items.strings) add(s, items.contexts[s] ?? "", rel);
+		for (const m of code.matchAll(JSON_IMPORT)) {
+			const spec = m[1];
+			if (spec.startsWith(".")) {
+				const abs = path.resolve(path.dirname(file), spec);
+				if (jsonOnDisk.includes(abs)) importedJson.add(abs);
+			} else {
+				const tail = "/" + spec.replace(/^[@~]\/?|^\/+/, "");
+				for (const j of jsonOnDisk) if (j.split(path.sep).join("/").endsWith(tail)) importedJson.add(j);
+			}
 		}
 	}
+	for (const file of importedJson) {
+		const rel = path.relative(root, file).split(path.sep).join("/");
+		for (const { text, key } of jsonStrings(fs.readFileSync(file, "utf8"), facts)) add(text, key || "text", rel);
+	}
 	return {
 		strings: [...found],
 		contexts,
@@ -973,7 +1833,7 @@ function readManifest(project) {
 /** 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);
+	const scan = scanProjectDetailed(root, project.include, { skip: [project.output, project.meta] });
 	if (site.seo) {
 		const html = path.join(root, "index.html");
 		if (fs.existsSync(html)) for (const s of headStrings(fs.readFileSync(html, "utf8"))) {
@@ -1397,4 +2257,4 @@ async function loadProject(root, opts = {}) {
 	};
 }
 //#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 };
+export { walk as A, getLanguage as B, isContentJson as C, parserPlugins as D, buildFactsIndex as E, writeJson as F, TranslationError as I, createLocalTranslator as L, messageId as M, ensureBanner as N, transformJsx as O, readBanner as P, ollama as R, scanProject as S, FactsIndex 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, translateHead as j, isSourceFile 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, jsonModule as w, readManifest as x, translateMissing as y, toTranslator as z };