@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/lingui--PcOOYry.js

@@ -0,0 +1,833 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { n as printICU } from "./codec-DuvU2VQy.js";
+import { h as parsePo } from "./library-D5CWvTQs.js";
+import { l as langFromId, s as decodeEntities, u as parseModule } from "./worker-84U6uYB3.js";
+import { _ as keyName, a as attributeExpression, b as stringValue, g as jsxNameNodes, h as jsxName, i as analyzeModule, l as identifierName, o as attributeString, p as jsxAttributes, s as childEntries, t as ModuleBuilder, u as inJsxChildren, v as memberParts, x as unwrap, y as objectProperties } from "./rewrite-CiTRAICl.js";
+import { _ as linguiId, c as newNaming, d as richCall, f as selfClosingTags, l as reactTypes, o as elementHandler, p as siteHandlers, s as entry, t as MODULE_EXTENSIONS, u as renameTags, v as parseJson } from "./i18next-CrUnKFfh.js";
+import { extname } from "node:path";
+import { readFileSync } from "node:fs";
+//#region src/cli/commands/migrate/lingui.ts
+/**
+* `vi18n migrate --from lingui` (INTERNALS §2.14): Lingui 3–5 macros and
+* runtime.
+*
+* The source text is what the macros compile to, built the way Lingui
+* builds it (`${name}` → `{name}`, other expressions → `{0}`, `plural()` /
+* `select()` / `selectOrdinal()` and `<Plural>`… as ICU, JSX elements as
+* `<0>…</0>`), so translations are found under the id Lingui gives it
+* (`generateMessageId(message, context)`, or the explicit `id`). Catalogs
+* are PO (`#. js-lingui-explicit-id` marks an explicit id), Lingui JSON or
+* minimal JSON; a fuzzy translation is kept for review, not shipped. A
+* `context` is a translator note and, when two messages share a text but
+* not their translations, the stem of their manual ids (PLAN §5.6).
+* `t`, `msg`/`defineMessage`, `<Trans>`, `<Plural>`, `i18n._()` become
+* `t()`, `msg()`, `rich()`; macro imports, `useLingui()` bindings and
+* `<I18nProvider>` go once unused.
+*/
+function isOldSource(source) {
+	return source.startsWith("@lingui/");
+}
+const MACRO_SOURCES = /* @__PURE__ */ new Set([
+	"@lingui/macro",
+	"@lingui/core/macro",
+	"@lingui/react/macro"
+]);
+var MessageText = class MessageText {
+	text = "";
+	shared;
+	constructor(shared) {
+		this.shared = shared ?? {
+			values: [],
+			elements: [],
+			consumed: [],
+			positional: 0,
+			problem: null
+		};
+	}
+	get values() {
+		return this.shared.values;
+	}
+	get elements() {
+		return this.shared.elements;
+	}
+	get problem() {
+		return this.shared.problem;
+	}
+	/** A part of the same message (a plural case): same values and counters, its own text. */
+	nested() {
+		return new MessageText(this.shared);
+	}
+	/** `{name}` for an identifier, `{0}`, `{1}`… for other expressions, as Lingui names them. */
+	argument(expression) {
+		const n = unwrap(expression);
+		if (n.type === "Identifier") {
+			const name = n.name;
+			if (!this.values.some((v) => v.name === name)) this.values.push({
+				name,
+				expression: n
+			});
+			return name;
+		}
+		const name = String(this.shared.positional++);
+		this.values.push({
+			name,
+			expression: n
+		});
+		return name;
+	}
+	fail(problem) {
+		this.shared.problem ??= problem;
+	}
+	built() {
+		return {
+			message: this.text,
+			values: this.values,
+			elements: this.elements,
+			consumed: this.shared.consumed,
+			problem: this.problem
+		};
+	}
+};
+/** Lingui's whitespace rule for JSX messages: a line break and the indentation after it are one space. */
+function normalizeWhitespace(text) {
+	return text.replace(/(?:\\(?:\r\n|\r|\n))+\s+/g, " ").replace(/(?:\r\n|\r|\n)+\s+/g, " ").trim();
+}
+/** `=N` for numeric choice keys (`0`, `_0`), CLDR categories as they are, select values without `_`. */
+function choiceKey(key) {
+	if (/^\d+$/.test(key)) return `=${key}`;
+	if (/^_\d+$/.test(key)) return `=${key.slice(1)}`;
+	if (key.startsWith("_")) return key.slice(1);
+	return key;
+}
+function createLinguiAdapter() {
+	/** locale → Lingui id → entry. */
+	const catalogs = /* @__PURE__ */ new Map();
+	/** v3 minimal JSON keys catalogs by message text: locale → text → translation. */
+	const byText = /* @__PURE__ */ new Map();
+	const namings = /* @__PURE__ */ new Map();
+	/** Source-catalog entries some call site found, for the unused-key report. */
+	const found = /* @__PURE__ */ new Set();
+	let sourceLocale = "";
+	const put = (locale, id, entryValue) => {
+		let map = catalogs.get(locale);
+		if (map === void 0) catalogs.set(locale, map = /* @__PURE__ */ new Map());
+		map.set(id, entryValue);
+		let texts = byText.get(locale);
+		if (texts === void 0) byText.set(locale, texts = /* @__PURE__ */ new Map());
+		if (entryValue.message !== null && !texts.has(entryValue.message)) texts.set(entryValue.message, entryValue);
+	};
+	const readCatalog = (file, env) => {
+		let text;
+		try {
+			text = readFileSync(file.file, "utf8");
+		} catch (error) {
+			env.report("catalog-parse", `cannot read: ${error.message}`, { file: file.file }, "error");
+			return;
+		}
+		if (extname(file.file) === ".po") {
+			const parsed = parsePo(text, {
+				locale: file.locale,
+				layout: "source",
+				isSourceLocale: false
+			});
+			for (const d of parsed.diagnostics) if (d.severity === "error") env.diagnostics.push({
+				...d,
+				file: env.rel(file.file)
+			});
+			for (const e of parsed.catalog.entries) {
+				const explicit = e.contexts.some((c) => c.trim() === "js-lingui-explicit-id");
+				const idNote = e.contexts.map((c) => /^js-lingui-id:\s*(\S+)/.exec(c.trim())?.[1]).find((x) => x !== void 0);
+				const context = e.manualId ?? e.foreignContext;
+				const msgid = e.source ?? "";
+				const id = explicit ? msgid : idNote ?? linguiId(msgid, context);
+				put(file.locale, id, {
+					message: explicit ? file.locale === sourceLocale && e.translation !== "" ? e.translation : null : msgid,
+					translation: e.translation,
+					fuzzy: e.fuzzy,
+					context,
+					file: file.file,
+					line: e.line
+				});
+			}
+			return;
+		}
+		const parsed = parseJson(text);
+		if (parsed.problem !== null) {
+			env.report("catalog-parse", parsed.problem.message, {
+				file: file.file,
+				line: parsed.problem.line
+			}, "error");
+			return;
+		}
+		if (typeof parsed.value !== "object" || parsed.value === null || Array.isArray(parsed.value)) {
+			env.report("catalog-parse", "a Lingui JSON catalog is an object of messages by id", { file: file.file }, "error");
+			return;
+		}
+		const lines = text.split("\n");
+		for (const [id, value] of Object.entries(parsed.value)) {
+			const line = lines.findIndex((l) => l.includes(`${JSON.stringify(id)}:`)) + 1;
+			if (typeof value === "string") {
+				put(file.locale, id, {
+					message: null,
+					translation: value,
+					fuzzy: false,
+					context: null,
+					file: file.file,
+					line
+				});
+				let texts = byText.get(file.locale);
+				if (texts === void 0) byText.set(file.locale, texts = /* @__PURE__ */ new Map());
+				texts.set(id, {
+					message: id,
+					translation: value,
+					fuzzy: false,
+					context: null,
+					file: file.file,
+					line
+				});
+			} else if (typeof value === "object" && value !== null) {
+				const record = value;
+				put(file.locale, id, {
+					message: typeof record.message === "string" ? record.message : null,
+					translation: typeof record.translation === "string" ? record.translation : "",
+					fuzzy: record.fuzzy === true || Array.isArray(record.flags) && record.flags.includes("fuzzy"),
+					context: typeof record.context === "string" ? record.context : null,
+					file: file.file,
+					line
+				});
+			}
+		}
+	};
+	/** The catalog entry of a message in a locale: by id, else (v3) by its text. */
+	const lookup = (locale, id, message, context) => {
+		let entryFound = catalogs.get(locale)?.get(id);
+		if (entryFound === void 0 && message !== null) {
+			const byMessage = byText.get(locale)?.get(message);
+			if (byMessage !== void 0 && (byMessage.context ?? null) === context) entryFound = byMessage;
+		}
+		if (entryFound !== void 0 && locale === sourceLocale) {
+			found.add(entryFound);
+			const other = catalogs.get(locale)?.get(entryFound.message ?? "");
+			if (other !== void 0) found.add(other);
+		}
+		return entryFound;
+	};
+	/**
+	* Registers a message. `message` is the macro's text (null for a runtime
+	* lookup by explicit id, whose text comes from the source catalog).
+	*/
+	const define = (env, input, origin, tags) => {
+		const id = input.id ?? linguiId(input.message ?? "", input.context);
+		if (env.message(id) !== void 0) {
+			lookup(sourceLocale, id, input.message, input.context);
+			return { key: id };
+		}
+		const sourceEntry = lookup(sourceLocale, id, input.message, input.context);
+		let source = input.message;
+		if (source === null) {
+			source = sourceEntry?.message ?? (sourceEntry?.translation || null);
+			if (source === null) return { problem: `${id} has no message in the code or the ${sourceLocale} catalog` };
+		}
+		const naming = newNaming();
+		const rename = (text, isSource) => {
+			if (tags === null) return text;
+			let nodes;
+			try {
+				nodes = env.codec.parse(text);
+			} catch (error) {
+				if (!isDiagnosticError(error)) throw error;
+				return { error: error.diagnostic.message };
+			}
+			return printICU(renameTags(nodes, naming, tags.pathOf, tags.elementAt, isSource));
+		};
+		const numbered = (text) => text.replace(/<(\/?)(\d+)(\/?)>/g, (_, a, n, b) => `<${a}t${n}${b}>`);
+		const sourceText = rename(numbered(source), true);
+		if (typeof sourceText !== "string") return { problem: `${id}: ${sourceText.error}` };
+		const translations = /* @__PURE__ */ new Map();
+		for (const locale of catalogs.keys()) {
+			if (locale === sourceLocale) continue;
+			const found = lookup(locale, id, input.message, input.context);
+			if (found === void 0 || found.translation === "") continue;
+			if (found.fuzzy) {
+				translations.set(locale, {
+					unconverted: found.translation,
+					reason: "Lingui marked it fuzzy",
+					file: found.file,
+					line: found.line
+				});
+				continue;
+			}
+			const converted = rename(numbered(found.translation), false);
+			translations.set(locale, typeof converted === "string" ? { icu: converted } : {
+				unconverted: found.translation,
+				reason: converted.error,
+				file: found.file,
+				line: found.line
+			});
+		}
+		const notes = [input.comment, input.context].filter((n) => n !== null && n !== "");
+		if (!env.define({
+			key: id,
+			named: input.id !== null,
+			source: sourceText,
+			context: notes.length === 0 ? null : notes.join("; "),
+			hint: input.context,
+			translations,
+			file: origin.file,
+			line: origin.line
+		})) return { problem: `${id} could not be converted` };
+		if (tags !== null) namings.set(id, naming);
+		return { key: id };
+	};
+	const planModule = (file, text, env) => {
+		let program;
+		try {
+			program = parseModule(text, langFromId(file), file).program;
+		} catch (error) {
+			if (!isDiagnosticError(error)) throw error;
+			env.diagnostics.push({
+				...error.diagnostic,
+				file: env.rel(file)
+			});
+			return null;
+		}
+		const info = analyzeModule(program);
+		const builder = new ModuleBuilder({
+			file,
+			text,
+			info,
+			isOldSource
+		});
+		const tsx = extname(file) === ".tsx";
+		const lineOf = (offset) => text.slice(0, offset).split("\n").length;
+		const imported = (name, macro = null) => {
+			const locals = /* @__PURE__ */ new Set();
+			for (const declaration of info.imports) {
+				if (!isOldSource(declaration.source)) continue;
+				if (macro !== null && MACRO_SOURCES.has(declaration.source) !== macro) continue;
+				for (const s of declaration.specifiers) if (s.imported === name) locals.add(s.local);
+			}
+			return locals;
+		};
+		const macroT = imported("t", true);
+		const macroMsg = /* @__PURE__ */ new Set([...imported("msg", true), ...imported("defineMessage", true)]);
+		const choiceMacros = /* @__PURE__ */ new Map();
+		for (const [name, format] of [
+			["plural", "plural"],
+			["select", "select"],
+			["selectOrdinal", "selectordinal"]
+		]) for (const local of imported(name, true)) choiceMacros.set(local, format);
+		const transMacro = imported("Trans", true);
+		const choiceComponents = /* @__PURE__ */ new Map();
+		for (const [name, format] of [
+			["Plural", "plural"],
+			["Select", "select"],
+			["SelectOrdinal", "selectordinal"]
+		]) for (const local of imported(name, true)) choiceComponents.set(local, format);
+		const providers = imported("I18nProvider");
+		const runtimeI18n = imported("i18n");
+		const linguiT = /* @__PURE__ */ new Set();
+		const linguiUnderscore = /* @__PURE__ */ new Set();
+		const linguiInstances = /* @__PURE__ */ new Set();
+		const useLingui = imported("useLingui");
+		for (const binding of info.bindings) {
+			const init = binding.declarator?.init;
+			if (init === null || init === void 0) continue;
+			const call = unwrap(init);
+			const callee = call.type === "CallExpression" ? identifierName(call.callee) : null;
+			if (callee === null || !useLingui.has(callee)) continue;
+			builder.hooks.push(binding);
+			const slot = binding.slot;
+			const key = slot !== null && slot.type === "Property" ? keyName(slot) : null;
+			if (key === "t") linguiT.add(binding);
+			else if (key === "_") linguiUnderscore.add(binding);
+			else if (key === "i18n") linguiInstances.add(binding);
+		}
+		/** Locals holding `msg`/`defineMessage` results: their members are `msg()` refs now. */
+		const messageTables = /* @__PURE__ */ new Set();
+		for (const binding of info.bindings) {
+			const init = binding.declarator?.init;
+			if (init === null || init === void 0) continue;
+			let found = false;
+			const look = (n) => {
+				if (found) return;
+				if (n.type === "TaggedTemplateExpression" || n.type === "CallExpression") {
+					const callee = identifierName(n.type === "CallExpression" ? n.callee : n.tag);
+					if (callee !== null && macroMsg.has(callee)) found = true;
+				}
+				for (const [, child] of childEntries(n)) look(child);
+			};
+			look(init);
+			if (found) messageTables.add(binding.name);
+		}
+		const relativeImports = /* @__PURE__ */ new Set();
+		for (const declaration of info.imports) {
+			if (!declaration.source.startsWith(".")) continue;
+			for (const s of declaration.specifiers) relativeImports.add(s.local);
+		}
+		const resolve = (name, offset) => {
+			let best = null;
+			for (const b of info.bindings) {
+				if (b.name !== name || offset < b.scope.start || offset >= b.scope.end) continue;
+				if (best === null || b.scope.end - b.scope.start < best.scope.end - best.scope.start) best = b;
+			}
+			return best;
+		};
+		const isMacroT = (callee) => {
+			const n = unwrap(callee);
+			if (n.type === "CallExpression") return isMacroT(n.callee);
+			if (n.type !== "Identifier") return false;
+			const binding = resolve(n.name, n.start);
+			return binding !== null && (macroT.has(n.name) ? binding.kind === "import" : linguiT.has(binding));
+		};
+		const calleeNodes = (callee) => {
+			const n = unwrap(callee);
+			if (n.type === "CallExpression") return calleeNodes(n.callee);
+			return n.type === "Identifier" ? [n] : [];
+		};
+		/** Choice macros and components a message absorbed: not sites of their own. */
+		const absorbed = /* @__PURE__ */ new Set();
+		const template = (quasi, out) => {
+			const quasis = quasi.quasis;
+			const expressions = quasi.expressions;
+			for (let i = 0; i < quasis.length; i++) {
+				out.text += quasis[i].value.cooked ?? "";
+				const expression = expressions[i];
+				if (expression !== void 0) placeholder(expression, out);
+			}
+		};
+		const placeholder = (expression, out) => {
+			const n = unwrap(expression);
+			if (n.type === "CallExpression") {
+				const callee = identifierName(n.callee);
+				const format = callee === null ? void 0 : choiceMacros.get(callee);
+				if (format !== void 0) {
+					absorbed.add(n);
+					out.shared.consumed.push(unwrap(n.callee));
+					choice(n, format, out);
+					return;
+				}
+			}
+			out.text += `{${out.argument(n)}}`;
+		};
+		/** `plural(value, { one: "…", other: \`…\` })` as `{value, plural, one {…} other {…}}`. */
+		const choice = (call, format, out) => {
+			const [value, options] = call.arguments;
+			const props = options === void 0 ? null : objectProperties(options);
+			if (value === void 0 || props === null || props.spreads.length > 0) {
+				out.fail(`${format}() needs a value and an object literal of cases`);
+				return;
+			}
+			const name = out.argument(value);
+			const cases = [];
+			for (const [key, property] of props.properties) {
+				const v = unwrap(property.value);
+				if (key === "offset") {
+					cases.unshift(`offset:${String(v.value)}`);
+					continue;
+				}
+				const inner = out.nested();
+				const literal = stringValue(v);
+				if (literal !== null) inner.text = literal;
+				else if (v.type === "TemplateLiteral") template(v, inner);
+				else placeholder(v, inner);
+				cases.push(`${choiceKey(key)} {${inner.text}}`);
+			}
+			out.text += `{${name}, ${format}, ${cases.join(" ")}}`;
+		};
+		/** JSX children of `<Trans>` (or a choice component's JSX option). */
+		const jsx = (children, out) => {
+			for (const child of children) if (child.type === "JSXText") out.text += decodeEntities(child.value);
+			else if (child.type === "JSXExpressionContainer") {
+				const expression = unwrap(child.expression);
+				if (expression.type === "JSXEmptyExpression") continue;
+				const literal = stringValue(expression);
+				if (literal !== null) out.text += literal;
+				else if (expression.type === "TemplateLiteral") template(expression, out);
+				else placeholder(expression, out);
+			} else if (child.type === "JSXElement") {
+				const name = jsxName(child);
+				const format = choiceComponents.get(name);
+				if (format !== void 0) {
+					absorbed.add(child);
+					out.shared.consumed.push(...jsxNameNodes(child));
+					choiceComponent(child, format, out);
+					continue;
+				}
+				const index = out.elements.length;
+				out.elements.push(child);
+				if (child.children.filter((c) => !(c.type === "JSXText" && c.value.trim() === "" && c.value.includes("\n"))).length === 0) out.text += `<${index}/>`;
+				else {
+					out.text += `<${index}>`;
+					jsx(child.children, out);
+					out.text += `</${index}>`;
+				}
+			} else if (child.type === "JSXFragment") jsx(child.children, out);
+		};
+		/** `<Plural value={n} one="…" other={<b>…</b>} />` as an ICU plural. */
+		const choiceComponent = (element, format, out) => {
+			const attributes = jsxAttributes(element);
+			const value = attributeExpression(attributes.named.get("value")?.value ?? null);
+			if (value === null || attributes.spreads.length > 0) {
+				out.fail(`<${jsxName(element)}> needs a value={…} and no spread props`);
+				return;
+			}
+			const name = out.argument(value);
+			const cases = [];
+			for (const [key, { value: attribute }] of attributes.named) {
+				if (key === "value" || key === "id" || key === "comment" || key === "context" || key === "render") continue;
+				if (key === "offset") {
+					cases.unshift(`offset:${attributeString(attribute) ?? String(attributeExpression(attribute)?.value)}`);
+					continue;
+				}
+				const inner = out.nested();
+				const literal = attributeString(attribute);
+				if (literal !== null) inner.text = literal;
+				else {
+					const expression = attributeExpression(attribute);
+					if (expression === null) continue;
+					const n = unwrap(expression);
+					if (n.type === "JSXElement" || n.type === "JSXFragment") jsx([n], inner);
+					else if (n.type === "TemplateLiteral") template(n, inner);
+					else placeholder(n, inner);
+				}
+				cases.push(`${choiceKey(key)} {${inner.text}}`);
+			}
+			out.text += `{${name}, ${format}, ${cases.join(" ")}}`;
+		};
+		/** `{ id, message, context, comment }` of a macro descriptor (message a string or template). */
+		const descriptor = (node, out) => {
+			const props = objectProperties(node);
+			if (props === null || props.spreads.length > 0) return null;
+			const field = (name) => {
+				const property = props.properties.get(name);
+				if (property === void 0) return null;
+				return stringValue(property.value) ?? void 0;
+			};
+			const id = field("id");
+			const context = field("context");
+			const comment = field("comment");
+			if (id === void 0 || context === void 0 || comment === void 0) return null;
+			const messageProperty = props.properties.get("message");
+			if (messageProperty === void 0) return {
+				id,
+				message: null,
+				context,
+				comment
+			};
+			const value = unwrap(messageProperty.value);
+			const literal = stringValue(value);
+			if (literal !== null) out.text = literal;
+			else if (value.type === "TemplateLiteral") template(value, out);
+			else return null;
+			return {
+				id,
+				message: out.text,
+				context,
+				comment
+			};
+		};
+		const valuesCode = (r, values, extra = []) => {
+			const entries = [...extra, ...values.map(({ name, expression }) => entry(name, r.src(expression.start, expression.end)))];
+			return entries.length === 0 ? "" : `, { ${entries.join(", ")} }`;
+		};
+		/** A `t` macro (template or descriptor) or a standalone choice macro, as `t()`. */
+		const tSite = (node, built, input, consume) => {
+			if (built.problem !== null) {
+				builder.note(node.start, `${built.problem}; not rewritten`);
+				return;
+			}
+			const defined = define(env, {
+				...input,
+				message: built.message
+			}, {
+				file,
+				line: lineOf(node.start)
+			}, null);
+			if ("problem" in defined) {
+				builder.note(node.start, `${defined.problem}; not rewritten`);
+				return;
+			}
+			builder.site(node, (r) => `${r.fn.t}(${r.message(defined.key)}${valuesCode(r, built.values)})`, {
+				keys: [defined.key],
+				uses: ["t"],
+				consume: [...consume, ...built.consumed]
+			});
+		};
+		/** `<Trans>` (or a choice component) whose message is `built`, as `rich()` or `t()`. */
+		const jsxSite = (element, built, input) => {
+			if (built.problem !== null) {
+				builder.note(element.start, `<${jsxName(element)}>: ${built.problem}; not rewritten`);
+				return;
+			}
+			const elements = built.elements;
+			const pathOf = (name) => /^t\d+$/.test(name) ? name.slice(1) : null;
+			const elementAt = (path) => elements[Number(path)] ?? null;
+			const defined = define(env, {
+				...input,
+				message: built.message
+			}, {
+				file,
+				line: lineOf(element.start)
+			}, {
+				pathOf,
+				elementAt
+			});
+			if ("problem" in defined) {
+				builder.note(element.start, `${defined.problem}; <${jsxName(element)}> was not rewritten`);
+				return;
+			}
+			const message = env.message(defined.key);
+			const naming = namings.get(defined.key);
+			if (message === void 0 || naming === void 0) return;
+			const { handlers, missing } = siteHandlers(naming, elementAt);
+			if (missing.length > 0) {
+				builder.note(element.start, `<${jsxName(element)}>: a tag maps to no element here; not rewritten`, [defined.key]);
+				return;
+			}
+			const selfClosing = selfClosingTags(env.codec.parse(message.canonical));
+			const rich = handlers.size > 0;
+			const types = rich && tsx ? reactTypes(builder) : null;
+			builder.site(element, (r) => {
+				const handlerEntries = [...handlers].map(([name, handler]) => entry(name, elementHandler(handler, selfClosing.has(name), r, types)));
+				const values = built.values.map(({ name, expression }) => entry(name, r.src(expression.start, expression.end)));
+				const call = rich ? richCall(r, defined.key, [...handlerEntries, ...values], types) : `${r.fn.t}(${r.message(defined.key)}${values.length === 0 ? "" : `, { ${values.join(", ")} }`})`;
+				return inJsxChildren(info, element) ? `{${call}}` : call;
+			}, {
+				keys: [defined.key],
+				uses: [rich ? "rich" : "t"],
+				consume: [...jsxNameNodes(element), ...built.consumed]
+			});
+		};
+		const transElement = (element) => {
+			const attributes = jsxAttributes(element);
+			if (attributes.spreads.length > 0 || attributes.named.has("render") || attributes.named.has("component")) {
+				builder.note(element.start, "<Trans> with spread props, render or component was not rewritten");
+				return;
+			}
+			const read = (name) => attributes.named.has(name) ? attributeString(attributes.named.get(name)?.value ?? null) : null;
+			const out = new MessageText();
+			jsx(element.children, out);
+			out.text = normalizeWhitespace(out.text);
+			jsxSite(element, out.built(), {
+				id: read("id"),
+				context: read("context"),
+				comment: read("comment")
+			});
+		};
+		const choiceElement = (element, format) => {
+			const attributes = jsxAttributes(element);
+			const read = (name) => attributes.named.has(name) ? attributeString(attributes.named.get(name)?.value ?? null) : null;
+			const out = new MessageText();
+			choiceComponent(element, format, out);
+			jsxSite(element, out.built(), {
+				id: read("id"),
+				context: read("context"),
+				comment: read("comment")
+			});
+		};
+		/** `msg`/`defineMessage` as `msg()`: only without placeholders (a vi18n descriptor holds no values). */
+		const msgSite = (node, out, input) => {
+			if (out.problem !== null || out.values.length > 0) {
+				builder.note(node.start, out.problem ?? "msg/defineMessage with placeholders captures values, which a vi18n msg() descriptor does not: pass them to t() where it is rendered; not rewritten");
+				return;
+			}
+			const defined = define(env, {
+				...input,
+				message: out.text
+			}, {
+				file,
+				line: lineOf(node.start)
+			}, null);
+			if ("problem" in defined) {
+				builder.note(node.start, `${defined.problem}; not rewritten`);
+				return;
+			}
+			const callee = node.type === "CallExpression" ? node.callee : node.tag;
+			builder.site(node, (r) => `${r.fn.msg}(${r.message(defined.key)})`, {
+				keys: [defined.key],
+				uses: ["msg"],
+				consume: calleeNodes(callee)
+			});
+		};
+		/** `i18n._(…)` / `i18n.t(…)` / `_(…)` at runtime. */
+		const runtimeCall = (node) => {
+			const callee = unwrap(node.callee);
+			let consume = [];
+			if (callee.type === "Identifier") {
+				const binding = resolve(callee.name, callee.start);
+				if (binding === null || !linguiUnderscore.has(binding)) return false;
+				consume = [callee];
+			} else {
+				const member = memberParts(callee);
+				if (member === null || member.property !== "_" && member.property !== "t") return false;
+				let root = unwrap(member.object);
+				while (root.type === "MemberExpression") root = unwrap(root.object);
+				const name = identifierName(root);
+				if (name === null) return false;
+				const binding = resolve(name, root.start);
+				if (!(runtimeI18n.has(name) || binding !== null && linguiInstances.has(binding))) return false;
+				if (unwrap(member.object).type === "Identifier") consume = [unwrap(member.object)];
+			}
+			const args = node.arguments;
+			const first = args[0];
+			if (first === void 0 || first.type === "SpreadElement") return false;
+			const values = args[1] ?? null;
+			const n = unwrap(first);
+			const id = stringValue(n);
+			let key = null;
+			if (id !== null) {
+				const defined = define(env, {
+					id,
+					message: null,
+					context: null,
+					comment: null
+				}, {
+					file,
+					line: lineOf(node.start)
+				}, null);
+				if ("problem" in defined) {
+					builder.note(node.start, `${defined.problem}; not rewritten`);
+					return true;
+				}
+				key = defined.key;
+			} else if (n.type === "ObjectExpression") {
+				const out = new MessageText();
+				const d = descriptor(n, out);
+				if (d === null || out.values.length > 0) {
+					builder.note(node.start, "a runtime descriptor vi18n migrate cannot read was not rewritten");
+					return true;
+				}
+				const defined = define(env, d, {
+					file,
+					line: lineOf(node.start)
+				}, null);
+				if ("problem" in defined) {
+					builder.note(node.start, `${defined.problem}; not rewritten`);
+					return true;
+				}
+				key = defined.key;
+			} else {
+				let root = n;
+				while (root.type === "MemberExpression") root = unwrap(root.object);
+				const name = identifierName(root);
+				if (!(name !== null && (messageTables.has(name) || relativeImports.has(name)) || isMsgMacro(n))) {
+					builder.note(node.start, "i18n._() with a message vi18n migrate cannot trace was not rewritten: pass a msg() descriptor to t()");
+					return true;
+				}
+			}
+			const resolvedKey = key;
+			builder.site(node, (r) => {
+				const message = resolvedKey === null ? r.src(first.start, first.end) : r.message(resolvedKey);
+				return `${r.fn.t}(${message}${values === null ? "" : `, ${r.src(values.start, values.end)}`})`;
+			}, {
+				keys: resolvedKey === null ? [] : [resolvedKey],
+				uses: ["t"],
+				consume
+			});
+			return true;
+		};
+		const isMsgMacro = (n) => {
+			const callee = n.type === "TaggedTemplateExpression" ? n.tag : n.type === "CallExpression" ? n.callee : null;
+			const name = callee === null ? null : identifierName(callee);
+			return name !== null && macroMsg.has(name);
+		};
+		const unwrapProvider = (element) => {
+			const opening = element.openingElement;
+			const closing = element.closingElement;
+			const children = element.children.filter((c) => !(c.type === "JSXText" && c.value.trim() === ""));
+			builder.consumeRange(opening);
+			builder.consume(jsxNameNodes(element));
+			const nested = inJsxChildren(info, element);
+			builder.replace(element, (r) => {
+				if (closing === null) return nested ? "" : "null";
+				if (nested) return r.src(opening.end, closing.start).trim();
+				if (children.length === 1 && children[0].type === "JSXElement") return r.src(children[0].start, children[0].end);
+				return `<>${r.src(opening.end, closing.start)}</>`;
+			});
+		};
+		const visit = (node) => {
+			if (node.type === "TaggedTemplateExpression") {
+				const tag = node.tag;
+				const name = identifierName(tag);
+				if (isMacroT(tag)) {
+					const out = new MessageText();
+					template(node.quasi, out);
+					tSite(node, out.built(), {
+						id: null,
+						context: null,
+						comment: null
+					}, calleeNodes(tag));
+				} else if (name !== null && macroMsg.has(name)) {
+					const out = new MessageText();
+					template(node.quasi, out);
+					msgSite(node, out, {
+						id: null,
+						context: null,
+						comment: null
+					});
+				}
+			} else if (node.type === "CallExpression") {
+				const callee = node.callee;
+				const name = identifierName(callee);
+				const arg = node.arguments[0];
+				if (isMacroT(callee) && unwrap(callee).type === "Identifier" && arg !== void 0 && unwrap(arg).type === "ObjectExpression") {
+					const out = new MessageText();
+					const d = descriptor(unwrap(arg), out);
+					if (d === null) builder.note(node.start, "t({…}) with a computed descriptor was not rewritten");
+					else tSite(node, {
+						...out.built(),
+						message: d.message ?? ""
+					}, d, calleeNodes(callee));
+				} else if (name !== null && macroMsg.has(name) && arg !== void 0) {
+					const out = new MessageText();
+					const d = unwrap(arg).type === "ObjectExpression" ? descriptor(unwrap(arg), out) : null;
+					if (d === null) builder.note(node.start, `${name}() with a computed descriptor was not rewritten`);
+					else msgSite(node, out, d);
+				} else if (name !== null && choiceMacros.has(name) && !absorbed.has(node)) {
+					const out = new MessageText();
+					choice(node, choiceMacros.get(name), out);
+					tSite(node, out.built(), {
+						id: null,
+						context: null,
+						comment: null
+					}, calleeNodes(callee));
+				} else if (!runtimeCall(node)) {
+					const member = memberParts(callee);
+					if (member !== null && (member.property === "activate" || member.property === "load" || member.property === "loadAndActivate")) {
+						const object = identifierName(member.object);
+						if (object !== null && (runtimeI18n.has(object) || /^i18n$/.test(object))) builder.note(node.start, member.property === "activate" ? "i18n.activate(locale): use setLocale(locale) from @menapo/vi18n" : `i18n.${member.property}(): vi18n loads catalogs itself; delete this once nothing uses Lingui`);
+					} else if (name !== null && imported("setupI18n").has(name)) builder.note(node.start, "setupI18n(): use createTranslator(locale) or withLocale() from @menapo/vi18n/server");
+				}
+			} else if (node.type === "JSXElement") {
+				const name = jsxName(node);
+				if (transMacro.has(name)) transElement(node);
+				else if (choiceComponents.has(name) && !absorbed.has(node)) choiceElement(node, choiceComponents.get(name));
+				else if (providers.has(name)) unwrapProvider(node);
+				else if (imported("Trans", false).has(name)) builder.note(node.start, "<Trans id> from @lingui/react (the runtime component) was not rewritten: use t() or rich() with the message");
+			}
+			for (const [, child] of childEntries(node)) visit(child);
+		};
+		visit(program);
+		return builder.finish();
+	};
+	return {
+		catalogExtensions: [".po", ".json"],
+		catalogsRequired: false,
+		extensions: MODULE_EXTENSIONS,
+		mentions: (text) => text.includes("@lingui/"),
+		load(files, env) {
+			sourceLocale = env.config.sourceLocale;
+			const sorted = [...files].sort((a, b) => Number(b.locale === sourceLocale) - Number(a.locale === sourceLocale));
+			for (const file of sorted) readCatalog(file, env);
+		},
+		planFile: planModule,
+		unusedKeys() {
+			const out = [];
+			for (const [id, e] of catalogs.get(sourceLocale) ?? []) if (!found.has(e)) out.push(e.message !== null && e.message !== id ? `${id} (${e.message})` : id);
+			return out;
+		}
+	};
+}
+//#endregion
+export { createLinguiAdapter };